oomph::MeshAsGeomObject Class Reference

#include <mesh_as_geometric_object.h>

Inheritance diagram for oomph::MeshAsGeomObject:

Public Member Functions
SamplePointContainer *	sample_point_container_pt () const
	Pointer to the sample point container. More...
FiniteElement *	finite_element_pt (const unsigned &e)
	Return pointer to e-th finite element. More...
unsigned	sample_point_container_version () const
unsigned	nelement ()
	Number of elements in the underlying mesh. More...
	MeshAsGeomObject (Mesh *const &mesh_pt)
	Constructor. More...
	MeshAsGeomObject (SamplePointContainerParameters *sample_point_container_parameters_pt)
	Constructor. More...
	MeshAsGeomObject ()
	Empty Constructor. More...
	~MeshAsGeomObject ()
	Destructor. More...
	MeshAsGeomObject (const MeshAsGeomObject &)=delete
	Broken copy constructor. More...
void	operator= (const MeshAsGeomObject &)=delete
	Broken assignment operator. More...
unsigned	ngeom_data () const
	How many items of Data does the shape of the object depend on? More...
Data *	geom_data_pt (const unsigned &j)
void	locate_zeta (const Vector< double > &zeta, GeomObject *&sub_geom_object_pt, Vector< double > &s, const bool &use_coordinate_as_initial_guess=false)
void	position (const Vector< double > &zeta, Vector< double > &r) const
void	position (const unsigned &t, const Vector< double > &zeta, Vector< double > &r) const
void	dposition (const Vector< double > &xi, DenseMatrix< double > &drdxi) const
	Return the derivative of the position. More...
Public Member Functions inherited from oomph::GeomObject
	GeomObject ()
	Default constructor. More...
	GeomObject (const unsigned &ndim)
	GeomObject (const unsigned &nlagrangian, const unsigned &ndim)
	GeomObject (const unsigned &nlagrangian, const unsigned &ndim, TimeStepper *time_stepper_pt)
	GeomObject (const GeomObject &dummy)=delete
	Broken copy constructor. More...
void	operator= (const GeomObject &)=delete
	Broken assignment operator. More...
virtual	~GeomObject ()
	(Empty) destructor More...
unsigned	nlagrangian () const
	Access function to # of Lagrangian coordinates. More...
unsigned	ndim () const
	Access function to # of Eulerian coordinates. More...
void	set_nlagrangian_and_ndim (const unsigned &n_lagrangian, const unsigned &n_dim)
	Set # of Lagrangian and Eulerian coordinates. More...
TimeStepper *&	time_stepper_pt ()
TimeStepper *	time_stepper_pt () const
virtual void	position (const double &t, const Vector< double > &zeta, Vector< double > &r) const
virtual void	dposition_dt (const Vector< double > &zeta, const unsigned &j, Vector< double > &drdt)
virtual void	d2position (const Vector< double > &zeta, RankThreeTensor< double > &ddrdzeta) const
virtual void	d2position (const Vector< double > &zeta, Vector< double > &r, DenseMatrix< double > &drdzeta, RankThreeTensor< double > &ddrdzeta) const
virtual void	interpolated_zeta (const Vector< double > &s, Vector< double > &zeta) const

Private Member Functions
void	build_it (SamplePointContainerParameters *sample_point_container_parameters_pt)
	Helper function to actually build the thing. More...

Private Attributes
Vector< Data * >	Geom_data_pt
	Vector of pointers to Data items that affects the object's shape. More...
Vector< FiniteElement * >	Sub_geom_object_pt
	Internal storage for the elements that constitute the object. More...
SamplePointContainer *	Sample_point_container_pt
	Pointer to the sample point container. More...
Mesh *	Mesh_pt
	Pointer to mesh. More...
unsigned	Sample_point_container_version

Additional Inherited Members
Protected Attributes inherited from oomph::GeomObject
unsigned	NLagrangian
	Number of Lagrangian (intrinsic) coordinates. More...
unsigned	Ndim
	Number of Eulerian coordinates. More...
TimeStepper *	Geom_object_time_stepper_pt

Detailed Description

///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// This class provides a GeomObject representation of a given finite element mesh. The Lagrangian coordinate is taken to be the dimension of the (first) element in the mesh and the Eulerian coordinate is taken to be the dimension of the (first) node in the mesh. If there are no elements or nodes the appropriate dimensions will be set to zero. The constituent elements of the mesh must have their own GeomObject representations, so they must be FiniteElements, and they become sub-objects in this compound GeomObject.

Constructor & Destructor Documentation

MeshAsGeomObject() [1/4]

oomph::MeshAsGeomObject::MeshAsGeomObject ( Mesh *const &  mesh_pt )

inline

Constructor.

                                           : GeomObject()
    {
      // Create default parameters
      SamplePointContainerParameters* sample_point_container_parameters_pt = 0;
      MeshAsGeomObject_Helper::create_sample_point_container_parameters(
        mesh_pt, sample_point_container_parameters_pt);
 
      // Build the bastard
      build_it(sample_point_container_parameters_pt);
      delete sample_point_container_parameters_pt;
    }

References build_it(), and oomph::MeshAsGeomObject_Helper::create_sample_point_container_parameters().

MeshAsGeomObject() [2/4]

oomph::MeshAsGeomObject::MeshAsGeomObject ( SamplePointContainerParameters *  sample_point_container_parameters_pt )

inline

Constructor.

      : GeomObject()
    {
      build_it(sample_point_container_parameters_pt);
    }

References build_it().

MeshAsGeomObject() [3/4]

oomph::MeshAsGeomObject::MeshAsGeomObject ( )

inline

Empty Constructor.

{}

~MeshAsGeomObject()

oomph::MeshAsGeomObject::~MeshAsGeomObject ( )

inline

Destructor.

    {
      delete Sample_point_container_pt;
    }

References Sample_point_container_pt.

MeshAsGeomObject() [4/4]

oomph::MeshAsGeomObject::MeshAsGeomObject ( const MeshAsGeomObject &  )

delete

Broken copy constructor.

Member Function Documentation

build_it()

void oomph::MeshAsGeomObject::build_it ( SamplePointContainerParameters *  sample_point_container_parameters_pt )

inlineprivate

Helper function to actually build the thing.

    {
      Mesh_pt = sample_point_container_parameters_pt->mesh_pt();
      if (dynamic_cast<RefineableBinArrayParameters*>(
            sample_point_container_parameters_pt) != 0)
      {
        Sample_point_container_version = UseRefineableBinArray;
      }
      else if (dynamic_cast<NonRefineableBinArrayParameters*>(
                 sample_point_container_parameters_pt) != 0)
      {
        Sample_point_container_version = UseNonRefineableBinArray;
      }
#ifdef OOMPH_HAS_CGAL
      else if (dynamic_cast<CGALSamplePointContainerParameters*>(
                 sample_point_container_parameters_pt) != 0)
      {
        Sample_point_container_version = UseCGALSamplePointContainer;
      }
#endif
      else
      {
        throw OomphLibError("Wrong sample_point_container_parameters_pt",
                            OOMPH_CURRENT_FUNCTION,
                            OOMPH_EXCEPTION_LOCATION);
      }
 
#ifdef OOMPH_HAS_MPI
 
      // Set communicator
      Communicator_pt = Mesh_pt->communicator_pt();
 
#endif
 
 
      // Storage for the Lagrangian and Eulerian dimension
      int dim[2] = {0, 0};
 
      // Set the Lagrangian dimension from the dimension of the first element
      // if it exists (if not the Lagrangian dimension will be zero)
      if (Mesh_pt->nelement() != 0)
      {
        dim[0] = Mesh_pt->finite_element_pt(0)->dim();
      }
 
      // Read out the Eulerian dimension from the first node, if it exists.
      //(if not the Eulerian dimension will be zero);
      if (Mesh_pt->nnode() != 0)
      {
        dim[1] = Mesh_pt->node_pt(0)->ndim();
      }
 
      // Need to do an Allreduce to ensure that the dimension is consistent
      // even when no elements are assigned to a certain processor
#ifdef OOMPH_HAS_MPI
 
      // Only a problem if the mesh has been distributed
      if (Mesh_pt->is_mesh_distributed())
      {
        // Need a non-null communicator
        if (Communicator_pt != 0)
        {
          int n_proc = Communicator_pt->nproc();
          if (n_proc > 1)
          {
            int dim_reduce[2];
            MPI_Allreduce(&dim,
                          &dim_reduce,
                          2,
                          MPI_INT,
                          MPI_MAX,
                          Communicator_pt->mpi_comm());
 
            dim[0] = dim_reduce[0];
            dim[1] = dim_reduce[1];
          }
        }
      }
#endif
 
      // Set the Lagrangian and Eulerian dimensions within this geometric object
      this->set_nlagrangian_and_ndim(static_cast<unsigned>(dim[0]),
                                     static_cast<unsigned>(dim[1]));
 
      // Create temporary storage for geometric Data (don't count
      // Data twice!
      std::set<Data*> tmp_geom_data;
 
      // Copy all the elements in the mesh into local storage
      // N.B. elements must be able to have a geometric object representation.
      unsigned n_sub_object = Mesh_pt->nelement();
      Sub_geom_object_pt.resize(n_sub_object);
      for (unsigned e = 0; e < n_sub_object; e++)
      {
        // (Try to) cast to a finite element:
        Sub_geom_object_pt[e] =
          dynamic_cast<FiniteElement*>(Mesh_pt->element_pt(e));
 
#ifdef PARANOID
        if (Sub_geom_object_pt[e] == 0)
        {
          std::ostringstream error_message;
          error_message << "Unable to dynamic cast element: " << std::endl
                        << "into a FiniteElement: GeomObject representation is "
                           "not possible\n";
          throw OomphLibError(error_message.str(),
                              OOMPH_CURRENT_FUNCTION,
                              OOMPH_EXCEPTION_LOCATION);
        }
#endif
 
        // Add the geometric Data of each element into set
        unsigned ngeom_data = Sub_geom_object_pt[e]->ngeom_data();
        for (unsigned i = 0; i < ngeom_data; i++)
        {
          tmp_geom_data.insert(Sub_geom_object_pt[e]->geom_data_pt(i));
        }
      }
 
      // Now copy unique geom Data values across into vector
      unsigned ngeom = tmp_geom_data.size();
      Geom_data_pt.resize(ngeom);
      typedef std::set<Data*>::iterator IT;
      unsigned count = 0;
      for (IT it = tmp_geom_data.begin(); it != tmp_geom_data.end(); it++)
      {
        Geom_data_pt[count] = *it;
        count++;
      }
 
      // Build the right type of bin array
      switch (Sample_point_container_version)
      {
        case UseRefineableBinArray:
 
          Sample_point_container_pt =
            new RefineableBinArray(sample_point_container_parameters_pt);
          break;
 
        case UseNonRefineableBinArray:
 
          Sample_point_container_pt =
            new NonRefineableBinArray(sample_point_container_parameters_pt);
          break;
 
#ifdef OOMPH_HAS_CGAL
 
        case UseCGALSamplePointContainer:
 
          Sample_point_container_pt =
            new CGALSamplePointContainer(sample_point_container_parameters_pt);
          break;
 
#endif
 
        default:
 
          oomph_info << "Sample_point_container_version = "
                     << Sample_point_container_version << std::endl;
          throw OomphLibError("Sample_point_container_version",
                              OOMPH_CURRENT_FUNCTION,
                              OOMPH_EXCEPTION_LOCATION);
      }
    }

References oomph::Mesh::communicator_pt(), oomph::FiniteElement::dim(), e(), oomph::Mesh::element_pt(), oomph::Mesh::finite_element_pt(), Geom_data_pt, geom_data_pt(), i, oomph::Mesh::is_mesh_distributed(), Mesh_pt, oomph::SamplePointContainerParameters::mesh_pt(), oomph::Node::ndim(), oomph::Mesh::nelement(), ngeom_data(), oomph::Mesh::nnode(), oomph::Mesh::node_pt(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::oomph_info, Sample_point_container_pt, Sample_point_container_version, oomph::GeomObject::set_nlagrangian_and_ndim(), Sub_geom_object_pt, oomph::UseNonRefineableBinArray, and oomph::UseRefineableBinArray.

Referenced by MeshAsGeomObject().

dposition()

void oomph::MeshAsGeomObject::dposition ( const Vector< double > &  xi, DenseMatrix< double > &  drdxi  ) const

inlinevirtual

Return the derivative of the position.

Reimplemented from oomph::GeomObject.

    {
      throw OomphLibError("dposition() not implemented",
                          OOMPH_CURRENT_FUNCTION,
                          OOMPH_EXCEPTION_LOCATION);
    }

References OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

finite_element_pt()

FiniteElement* oomph::MeshAsGeomObject::finite_element_pt ( const unsigned &  e )

inline

Return pointer to e-th finite element.

    {
      return Sub_geom_object_pt[e];
    }

References e(), and Sub_geom_object_pt.

geom_data_pt()

Data* oomph::MeshAsGeomObject::geom_data_pt ( const unsigned &  j )

inlinevirtual

Return pointer to the j-th Data item that the object's shape depends on

Reimplemented from oomph::GeomObject.

    {
      return Geom_data_pt[j];
    }

References Geom_data_pt, and j.

Referenced by build_it().

locate_zeta()

void oomph::MeshAsGeomObject::locate_zeta ( const Vector< double > &  zeta, GeomObject *&  sub_geom_object_pt, Vector< double > &  s, const bool &  use_coordinate_as_initial_guess = false  )

inlinevirtual

Find the sub geometric object and local coordinate therein that corresponds to the intrinsic coordinate zeta. If sub_geom_object_pt=0 on return from this function, none of the constituent sub-objects contain the required coordinate. Following from the general interface to this function in GeomObjects, setting the optional bool argument to true means that each time the sub-object's locate_zeta function is called, the coordinate argument "s" is used as the initial guess. However, this doesn't make sense here and the argument is ignored (though a warning is issued when the code is compiled in PARANOID setting)

Reimplemented from oomph::GeomObject.

    {
#ifdef PARANOID
      if (use_coordinate_as_initial_guess)
      {
        OomphLibWarning(
          "Ignoring the use_coordinate_as_initial_guess argument.",
          "MeshAsGeomObject::locate_zeta()",
          OOMPH_EXCEPTION_LOCATION);
      }
#endif
 
 
      // Do locate in sample point container
      Sample_point_container_pt->locate_zeta(zeta, sub_geom_object_pt, s);
    }

References SamplePointContainer::locate_zeta(), OOMPH_EXCEPTION_LOCATION, s, Sample_point_container_pt, and Eigen::zeta().

Referenced by DarcyProblem< ELEMENT >::doc_shape_functions(), position(), SegregatedFSICollapsibleChannelProblem< ELEMENT >::SegregatedFSICollapsibleChannelProblem(), SegregatedFSIDrivenCavityProblem< ELEMENT >::SegregatedFSIDrivenCavityProblem(), oomph::LineVisualiser::setup(), oomph::HelmholtzMGPreconditioner< DIM >::setup_interpolation_matrices(), oomph::MGSolver< DIM >::setup_interpolation_matrices_unstructured(), and oomph::HelmholtzMGPreconditioner< DIM >::setup_interpolation_matrices_unstructured().

nelement()

unsigned oomph::MeshAsGeomObject::nelement ( )

inline

Number of elements in the underlying mesh.

    {
      return Sub_geom_object_pt.size();
    }

References Sub_geom_object_pt.

ngeom_data()

unsigned oomph::MeshAsGeomObject::ngeom_data ( ) const

inlinevirtual

How many items of Data does the shape of the object depend on?

Reimplemented from oomph::GeomObject.

    {
      return Geom_data_pt.size();
    }

References Geom_data_pt.

Referenced by build_it().

operator=()

void oomph::MeshAsGeomObject::operator= ( const MeshAsGeomObject &  )

delete

Broken assignment operator.

position() [1/2]

void oomph::MeshAsGeomObject::position ( const unsigned &  t, const Vector< double > &  zeta, Vector< double > &  r  ) const

inlinevirtual

Parametrised position on object: r(zeta). Evaluated at previous timestep. t=0: current time; t>0: previous timestep. This provides an (expensive!) default implementation in which we loop over all the constituent sub-objects and check if they contain zeta and then evaluate their position() function.

Reimplemented from oomph::GeomObject.

    {
      // Storage for the GeomObject that contains the zeta coordinate
      // and the intrinsic coordinate within it.
      GeomObject* sub_geom_object_pt;
      const unsigned n_lagrangian = this->nlagrangian();
      Vector<double> s(n_lagrangian);
 
      // Find the sub object containing zeta, and the local intrinsic coordinate
      // within it
      const_cast<MeshAsGeomObject*>(this)->locate_zeta(
        zeta, sub_geom_object_pt, s);
      if (sub_geom_object_pt == 0)
      {
        std::ostringstream error_message;
        error_message << "Cannot locate zeta ";
        for (unsigned i = 0; i < n_lagrangian; i++)
        {
          error_message << zeta[i] << " ";
        }
        error_message << std::endl;
        Mesh_pt->output("most_recent_mesh.dat");
        throw OomphLibError(error_message.str(),
                            OOMPH_CURRENT_FUNCTION,
                            OOMPH_EXCEPTION_LOCATION);
      }
      // Call that sub-object's position function
      sub_geom_object_pt->position(t, s, r);
 
    } // end of position

References i, locate_zeta(), Mesh_pt, oomph::GeomObject::nlagrangian(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::Mesh::output(), oomph::GeomObject::position(), UniformPSDSelfTest::r, s, plotPSD::t, and Eigen::zeta().

position() [2/2]

void oomph::MeshAsGeomObject::position ( const Vector< double > &  zeta, Vector< double > &  r  ) const

inlinevirtual

Return the position as a function of the intrinsic coordinate zeta. This provides an (expensive!) default implementation in which we loop over all the constituent sub-objects and check if they contain zeta and then evaluate their position() function.

Implements oomph::GeomObject.

    {
      // Call position function at current timestep:
      unsigned t = 0;
      position(t, zeta, r);
    }

References UniformPSDSelfTest::r, plotPSD::t, and Eigen::zeta().

Referenced by oomph::RefineableTetgenMesh< ELEMENT >::snap_nodes_onto_boundary().

sample_point_container_pt()

SamplePointContainer* oomph::MeshAsGeomObject::sample_point_container_pt ( ) const

inline

Pointer to the sample point container.

    {
      return Sample_point_container_pt;
    }

References Sample_point_container_pt.

Referenced by oomph::RefineableGmshTetMesh< ELEMENT >::adapt(), and oomph::LineVisualiser::setup().

sample_point_container_version()

unsigned oomph::MeshAsGeomObject::sample_point_container_version ( ) const

inline

Which sample point container is used in locate zeta? (uses enum Sample_Point_Container_Type)

    {
      return Sample_point_container_version;
    }

References Sample_point_container_version.

Member Data Documentation

Geom_data_pt

Vector<Data*> oomph::MeshAsGeomObject::Geom_data_pt

private

Vector of pointers to Data items that affects the object's shape.

Referenced by build_it(), geom_data_pt(), and ngeom_data().

Mesh_pt

Mesh* oomph::MeshAsGeomObject::Mesh_pt

private

Pointer to mesh.

Referenced by build_it(), and position().

Sample_point_container_pt

SamplePointContainer* oomph::MeshAsGeomObject::Sample_point_container_pt

private

Pointer to the sample point container.

Referenced by build_it(), locate_zeta(), sample_point_container_pt(), and ~MeshAsGeomObject().

Sample_point_container_version

unsigned oomph::MeshAsGeomObject::Sample_point_container_version

private

Which version of the sample point container are we using?

Referenced by build_it(), and sample_point_container_version().

Sub_geom_object_pt

Vector<FiniteElement*> oomph::MeshAsGeomObject::Sub_geom_object_pt

private

Internal storage for the elements that constitute the object.

Referenced by build_it(), finite_element_pt(), and nelement().

---

The documentation for this class was generated from the following file:

• mesh_as_geometric_object.h