Public Member Functions | Protected Attributes | List of all members
RectangleWithHoleMesh< ELEMENT > Class Template Reference

Domain-based mesh for rectangular mesh with circular hole. More...

+ Inheritance diagram for RectangleWithHoleMesh< ELEMENT >:

Public Member Functions

 RectangleWithHoleMesh (GeomObject *cylinder_pt, const double &length, const double &height, TimeStepper *time_stepper_pt=&Mesh::Default_TimeStepper)
 
RectangleWithHoleDomain * domain_pt ()
 Access function to the domain. More...
 
 RectangleWithHoleMesh (GeomObject *cylinder_pt, const double &length, const double &height, TimeStepper *time_stepper_pt=&Mesh::Default_TimeStepper)
 
RectangleWithHoleDomain * domain_pt ()
 Access function to the domain. More...
 
const double & length ()
 Access function to length. More...
 
const double & height ()
 Access function to height. More...
 
 RectangleWithHoleMesh (GeomObject *cylinder_pt, const double &length, const double &height, TimeStepper *time_stepper_pt=&Mesh::Default_TimeStepper)
 
RectangleWithHoleDomain * domain_pt ()
 Access function to the domain. More...
 
- Public Member Functions inherited from oomph::Mesh
 Mesh ()
 Default constructor. More...
 
 Mesh (const Vector< Mesh * > &sub_mesh_pt)
 
void merge_meshes (const Vector< Mesh * > &sub_mesh_pt)
 
virtual void setup_boundary_element_info ()
 
virtual void setup_boundary_element_info (std::ostream &outfile)
 
virtual void reset_boundary_element_info (Vector< unsigned > &ntmp_boundary_elements, Vector< Vector< unsigned >> &ntmp_boundary_elements_in_region, Vector< FiniteElement * > &deleted_elements)
 Virtual function to perform the reset boundary elements info rutines. More...
 
template<class BULK_ELEMENT >
void doc_boundary_coordinates (const unsigned &b, std::ofstream &the_file)
 
virtual void scale_mesh (const double &factor)
 
 Mesh (const Mesh &dummy)=delete
 Broken copy constructor. More...
 
void operator= (const Mesh &)=delete
 Broken assignment operator. More...
 
virtual ~Mesh ()
 Virtual Destructor to clean up all memory. More...
 
void flush_element_and_node_storage ()
 
void flush_element_storage ()
 
void flush_node_storage ()
 
Node *& node_pt (const unsigned long &n)
 Return pointer to global node n. More...
 
Node * node_pt (const unsigned long &n) const
 Return pointer to global node n (const version) More...
 
GeneralisedElement *& element_pt (const unsigned long &e)
 Return pointer to element e. More...
 
GeneralisedElement * element_pt (const unsigned long &e) const
 Return pointer to element e (const version) More...
 
const Vector< GeneralisedElement * > & element_pt () const
 Return reference to the Vector of elements. More...
 
Vector< GeneralisedElement * > & element_pt ()
 Return reference to the Vector of elements. More...
 
FiniteElement * finite_element_pt (const unsigned &e) const
 
Node *& boundary_node_pt (const unsigned &b, const unsigned &n)
 Return pointer to node n on boundary b. More...
 
Node * boundary_node_pt (const unsigned &b, const unsigned &n) const
 Return pointer to node n on boundary b. More...
 
void set_nboundary (const unsigned &nbound)
 Set the number of boundaries in the mesh. More...
 
void remove_boundary_nodes ()
 Clear all pointers to boundary nodes. More...
 
void remove_boundary_nodes (const unsigned &b)
 
void remove_boundary_node (const unsigned &b, Node *const &node_pt)
 Remove a node from the boundary b. More...
 
void add_boundary_node (const unsigned &b, Node *const &node_pt)
 Add a (pointer to) a node to the b-th boundary. More...
 
void copy_boundary_node_data_from_nodes ()
 
bool boundary_coordinate_exists (const unsigned &i) const
 Indicate whether the i-th boundary has an intrinsic coordinate. More...
 
unsigned long nelement () const
 Return number of elements in the mesh. More...
 
unsigned long nnode () const
 Return number of nodes in the mesh. More...
 
unsigned ndof_types () const
 Return number of dof types in mesh. More...
 
unsigned elemental_dimension () const
 Return number of elemental dimension in mesh. More...
 
unsigned nodal_dimension () const
 Return number of nodal dimension in mesh. More...
 
void add_node_pt (Node *const &node_pt)
 Add a (pointer to a) node to the mesh. More...
 
void add_element_pt (GeneralisedElement *const &element_pt)
 Add a (pointer to) an element to the mesh. More...
 
virtual void node_update (const bool &update_all_solid_nodes=false)
 
virtual void reorder_nodes (const bool &use_old_ordering=true)
 
virtual void get_node_reordering (Vector< Node * > &reordering, const bool &use_old_ordering=true) const
 
template<class BULK_ELEMENT , template< class > class FACE_ELEMENT>
void build_face_mesh (const unsigned &b, Mesh *const &face_mesh_pt)
 
unsigned self_test ()
 Self-test: Check elements and nodes. Return 0 for OK. More...
 
void max_and_min_element_size (double &max_size, double &min_size)
 
double total_size ()
 
void check_inverted_elements (bool &mesh_has_inverted_elements, std::ofstream &inverted_element_file)
 
void check_inverted_elements (bool &mesh_has_inverted_elements)
 
unsigned check_for_repeated_nodes (const double &epsilon=1.0e-12)
 
Vector< Node * > prune_dead_nodes ()
 
unsigned nboundary () const
 Return number of boundaries. More...
 
unsigned long nboundary_node (const unsigned &ibound) const
 Return number of nodes on a particular boundary. More...
 
FiniteElement * boundary_element_pt (const unsigned &b, const unsigned &e) const
 Return pointer to e-th finite element on boundary b. More...
 
Node * get_some_non_boundary_node () const
 
unsigned nboundary_element (const unsigned &b) const
 Return number of finite elements that are adjacent to boundary b. More...
 
int face_index_at_boundary (const unsigned &b, const unsigned &e) const
 
virtual void dump (std::ofstream &dump_file, const bool &use_old_ordering=true) const
 Dump the data in the mesh into a file for restart. More...
 
void dump (const std::string &dump_file_name, const bool &use_old_ordering=true) const
 Dump the data in the mesh into a file for restart. More...
 
virtual void read (std::ifstream &restart_file)
 Read solution from restart file. More...
 
void output_paraview (std::ofstream &file_out, const unsigned &nplot) const
 
void output_fct_paraview (std::ofstream &file_out, const unsigned &nplot, FiniteElement::SteadyExactSolutionFctPt exact_soln_pt) const
 
void output_fct_paraview (std::ofstream &file_out, const unsigned &nplot, const double &time, FiniteElement::UnsteadyExactSolutionFctPt exact_soln_pt) const
 
void output (std::ostream &outfile)
 Output for all elements. More...
 
void output (std::ostream &outfile, const unsigned &n_plot)
 Output at f(n_plot) points in each element. More...
 
void output (FILE *file_pt)
 Output for all elements (C-style output) More...
 
void output (FILE *file_pt, const unsigned &nplot)
 Output at f(n_plot) points in each element (C-style output) More...
 
void output (const std::string &output_filename)
 Output for all elements. More...
 
void output (const std::string &output_filename, const unsigned &n_plot)
 Output at f(n_plot) points in each element. More...
 
void output_fct (std::ostream &outfile, const unsigned &n_plot, FiniteElement::SteadyExactSolutionFctPt)
 Output a given Vector function at f(n_plot) points in each element. More...
 
void output_fct (std::ostream &outfile, const unsigned &n_plot, const double &time, FiniteElement::UnsteadyExactSolutionFctPt)
 
void output_boundaries (std::ostream &outfile)
 Output the nodes on the boundaries (into separate tecplot zones) More...
 
void output_boundaries (const std::string &output_filename)
 
void assign_initial_values_impulsive ()
 Assign initial values for an impulsive start. More...
 
void shift_time_values ()
 
void calculate_predictions ()
 
void set_nodal_and_elemental_time_stepper (TimeStepper *const &time_stepper_pt, const bool &preserve_existing_data)
 
virtual void set_mesh_level_time_stepper (TimeStepper *const &time_stepper_pt, const bool &preserve_existing_data)
 
void set_consistent_pinned_values_for_continuation (ContinuationStorageScheme *const &continuation_stepper_pt)
 Set consistent values for pinned data in continuation. More...
 
bool does_pointer_correspond_to_mesh_data (double *const &parameter_pt)
 Does the double pointer correspond to any mesh data. More...
 
void set_nodal_time_stepper (TimeStepper *const &time_stepper_pt, const bool &preserve_existing_data)
 Set the timestepper associated with the nodal data in the mesh. More...
 
void set_elemental_internal_time_stepper (TimeStepper *const &time_stepper_pt, const bool &preserve_existing_data)
 
virtual void compute_norm (double &norm)
 
virtual void compute_norm (Vector< double > &norm)
 
virtual void compute_error (std::ostream &outfile, FiniteElement::UnsteadyExactSolutionFctPt exact_soln_pt, const double &time, double &error, double &norm)
 
virtual void compute_error (std::ostream &outfile, FiniteElement::SteadyExactSolutionFctPt exact_soln_pt, double &error, double &norm)
 
virtual void compute_error (FiniteElement::SteadyExactSolutionFctPt exact_soln_pt, double &error, double &norm)
 
virtual void compute_error (FiniteElement::SteadyExactSolutionFctPt exact_soln_pt, Vector< double > &error, Vector< double > &norm)
 
virtual void compute_error (std::ostream &outfile, FiniteElement::UnsteadyExactSolutionFctPt exact_soln_pt, const double &time, Vector< double > &error, Vector< double > &norm)
 
virtual void compute_error (std::ostream &outfile, FiniteElement::SteadyExactSolutionFctPt exact_soln_pt, Vector< double > &error, Vector< double > &norm)
 
virtual void compute_error (FiniteElement::UnsteadyExactSolutionFctPt exact_soln_pt, const double &time, double &error, double &norm)
 Returns the norm of the error and that of the exact solution. More...
 
virtual void compute_error (FiniteElement::UnsteadyExactSolutionFctPt exact_soln_pt, const double &time, Vector< double > &error, Vector< double > &norm)
 
bool is_mesh_distributed () const
 Boolean to indicate if Mesh has been distributed. More...
 
OomphCommunicator * communicator_pt () const
 
void delete_all_external_storage ()
 Wipe the storage for all externally-based elements. More...
 

Protected Attributes

RectangleWithHoleDomain * Domain_pt
 Pointer to the domain. More...
 
double Length
 
double Height
 
- Protected Attributes inherited from oomph::Mesh
Vector< Vector< Node * > > Boundary_node_pt
 
bool Lookup_for_elements_next_boundary_is_setup
 
Vector< Vector< FiniteElement * > > Boundary_element_pt
 
Vector< Vector< int > > Face_index_at_boundary
 
Vector< Node * > Node_pt
 Vector of pointers to nodes. More...
 
Vector< GeneralisedElement * > Element_pt
 Vector of pointers to generalised elements. More...
 
std::vector< bool > Boundary_coordinate_exists
 

Additional Inherited Members

- Public Types inherited from oomph::Mesh
typedef void(FiniteElement::* SteadyExactSolutionFctPt) (const Vector< double > &x, Vector< double > &soln)
 
typedef void(FiniteElement::* UnsteadyExactSolutionFctPt) (const double &time, const Vector< double > &x, Vector< double > &soln)
 
- Static Public Attributes inherited from oomph::Mesh
static Steady< 0 > Default_TimeStepper
 The Steady Timestepper. More...
 
static bool Suppress_warning_about_empty_mesh_level_time_stepper_function
 Static boolean flag to control warning about mesh level timesteppers. More...
 
- Protected Member Functions inherited from oomph::Mesh
unsigned long assign_global_eqn_numbers (Vector< double * > &Dof_pt)
 Assign (global) equation numbers to the nodes. More...
 
void describe_dofs (std::ostream &out, const std::string &current_string) const
 
void describe_local_dofs (std::ostream &out, const std::string &current_string) const
 
void assign_local_eqn_numbers (const bool &store_local_dof_pt)
 Assign local equation numbers in all elements. More...
 
void convert_to_boundary_node (Node *&node_pt, const Vector< FiniteElement * > &finite_element_pt)
 
void convert_to_boundary_node (Node *&node_pt)
 

Detailed Description

template<class ELEMENT>
class RectangleWithHoleMesh< ELEMENT >

Domain-based mesh for rectangular mesh with circular hole.

/////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////

Constructor & Destructor Documentation

◆ RectangleWithHoleMesh() [1/3]

template<class ELEMENT >
RectangleWithHoleMesh< ELEMENT >::RectangleWithHoleMesh ( GeomObject *  cylinder_pt,
const double &  length,
const double &  height,
TimeStepper *  time_stepper_pt = &Mesh::Default_TimeStepper 
)
inline

Constructor: Pass pointer to geometric object that represents the cylinder, the length and height of the domain. The GeomObject must be parametrised such that \(\zeta \in [0,2\pi]\) sweeps around the circumference in anticlockwise direction. Timestepper defaults to Steady default timestepper.

686  {
687  //Create the domain
688  Domain_pt = new RectangleWithHoleDomain(cylinder_pt,length,height);
689 
690  //Initialise the node counter
691  unsigned long node_count=0;
692 
693  //Vectors used to get data from domains
694  Vector<double> s(2),r(2);
695 
696  //Setup temporary storage for the Node
697  Vector<Node*> Tmp_node_pt;
698 
699  //Now blindly loop over the macro elements and associate and finite
700  //element with each
701  unsigned nmacro_element = Domain_pt->nmacro_element();
702  for(unsigned e=0;e<nmacro_element;e++)
703  {
704  //Create the FiniteElement and add to the Element_pt Vector
705  Element_pt.push_back(new ELEMENT);
706 
707  //Read out the number of linear points in the element
708  unsigned np =
709  dynamic_cast<ELEMENT*>(finite_element_pt(e))->nnode_1d();
710 
711  //Loop over nodes in the column
712  for(unsigned l1=0;l1<np;l1++)
713  {
714  //Loop over the nodes in the row
715  for(unsigned l2=0;l2<np;l2++)
716  {
717  //Allocate the memory for the node
718  Tmp_node_pt.push_back(finite_element_pt(e)->
719  construct_node(l1*np+l2,time_stepper_pt));
720 
721  //Read out the position of the node from the macro element
722  s[0] = -1.0 + 2.0*(double)l2/(double)(np-1);
723  s[1] = -1.0 + 2.0*(double)l1/(double)(np-1);
724  Domain_pt->macro_element_pt(e)->macro_map(s,r);
725 
726  //Set the position of the node
727  Tmp_node_pt[node_count]->x(0) = r[0];
728  Tmp_node_pt[node_count]->x(1) = r[1];
729 
730  //Increment the node number
731  node_count++;
732  }
733  }
734  } //End of loop over macro elements
735 
736 
737 
738  //Now the elements have been created, but there will be nodes in
739  //common, need to loop over the common edges and sort it, by reassigning
740  //pointers and the deleting excess nodes
741 
742  //Read out the number of linear points in the element
743  unsigned np=dynamic_cast<ELEMENT*>(finite_element_pt(0))->nnode_1d();
744 
745  //Edge between Elements 0 and 8
746  for(unsigned n=0;n<np;n++)
747  {
748  finite_element_pt(8)->node_pt(n*np + (np-1)) =
749  finite_element_pt(0)->node_pt(n*np);
750  //Remover the nodes in element 8 from the temporary node list
751  delete Tmp_node_pt[8*np*np + n*np + (np-1)];
752  Tmp_node_pt[8*np*np + n*np + (np-1)] = 0;
753  }
754 
755  //Edge between Elements 0 and 1
756  for(unsigned n=0;n<np;n++)
757  {
758  //Set the nodes in element 1 to be the same as in element 0
759  finite_element_pt(1)->node_pt(n*np)
760  = finite_element_pt(0)->node_pt((np-1)*np+np-1-n);
761 
762  //Remove the nodes in element 1 from the temporary node list
763  delete Tmp_node_pt[np*np + n*np];
764  Tmp_node_pt[np*np + n*np] = 0;
765  }
766 
767  //Edge between Elements 0 and 3
768  for(unsigned n=0;n<np;n++)
769  {
770  //Set the nodes in element 3 to be the same as in element 0
771  finite_element_pt(3)->node_pt(n*np)
772  = finite_element_pt(0)->node_pt(n);
773 
774  //Remove the nodes in element 3 from the temporary node list
775  delete Tmp_node_pt[3*np*np + n*np];
776  Tmp_node_pt[3*np*np + n*np] = 0;
777  }
778 
779  //Edge between Element 1 and 2
780  for(unsigned n=0;n<np;n++)
781  {
782  //Set the nodes in element 2 to be the same as in element 1
783  finite_element_pt(2)->node_pt(np*(np-1)+n)
784  = finite_element_pt(1)->node_pt(np*n+np-1);
785 
786  //Remove the nodes in element 2 from the temporary node list
787  delete Tmp_node_pt[2*np*np + np*(np-1)+n];
788  Tmp_node_pt[2*np*np + np*(np-1)+n] = 0;
789  }
790 
791 
792  //Edge between Element 3 and 2
793  for(unsigned n=0;n<np;n++)
794  {
795  //Set the nodes in element 2 to be the same as in element 3
796  finite_element_pt(2)->node_pt(n)
797  = finite_element_pt(3)->node_pt(np*(np-n-1)+np-1);
798 
799  //Remove the nodes in element 2 from the temporary node list
800  delete Tmp_node_pt[2*np*np + n];
801  Tmp_node_pt[2*np*np + n] = 0;
802  }
803 
804 
805  //Edge between Element 2 and 4
806  for(unsigned n=0;n<np;n++)
807  {
808  //Set the nodes in element 4 to be the same as in element 2
809  finite_element_pt(4)->node_pt(n*np)
810  = finite_element_pt(2)->node_pt(np*n+np-1);
811 
812  //Remove the nodes in element 4 from the temporary node list
813  delete Tmp_node_pt[4*np*np + n*np];
814  Tmp_node_pt[4*np*np + n*np] = 0;
815  }
816 
817  //Edge between Element 4 and 5
818  for(unsigned n=0;n<np;n++)
819  {
820  //Set the nodes in element 5 to be the same as in element 4
821  finite_element_pt(5)->node_pt(n*np)
822  = finite_element_pt(4)->node_pt(np*n+np-1);
823 
824  //Remove the nodes in element 5 from the temporary node list
825  delete Tmp_node_pt[5*np*np + n*np];
826  Tmp_node_pt[5*np*np + n*np] = 0;
827  }
828 
829  //Edge between Element 5 and 6
830  for(unsigned n=0;n<np;n++)
831  {
832  //Set the nodes in element 6 to be the same as in element 5
833  finite_element_pt(6)->node_pt(n*np)
834  = finite_element_pt(5)->node_pt(np*n+np-1);
835 
836  //Remove the nodes in element 6 from the temporary node list
837  delete Tmp_node_pt[6*np*np + n*np];
838  Tmp_node_pt[6*np*np + n*np] = 0;
839  }
840 
841  //Edge between Element 6 and 7
842  for(unsigned n=0;n<np;n++)
843  {
844  //Set the nodes in element 7 to be the same as in element 6
845  finite_element_pt(7)->node_pt(n*np)
846  = finite_element_pt(6)->node_pt(np*n+np-1);
847 
848  //Remove the nodes in element 7 from the temporary node list
849  delete Tmp_node_pt[7*np*np + n*np];
850  Tmp_node_pt[7*np*np + n*np] = 0;
851  }
852 
853  //Now set the actual true nodes
854  for(unsigned long n=0;n<node_count;n++)
855  {
856  if(Tmp_node_pt[n]!=0) {Node_pt.push_back(Tmp_node_pt[n]);}
857  }
858 
859  //Finally set the nodes on the boundaries
860  set_nboundary(5);
861 
862  for(unsigned n=0;n<np;n++)
863  {
864  //Left hand side
865  Node* nod_pt=finite_element_pt(8)->node_pt(n*np);
866  convert_to_boundary_node(nod_pt);
867  add_boundary_node(3,nod_pt);
868 
869  //Right hand side
870  nod_pt=finite_element_pt(7)->node_pt(n*np+np-1);
871  convert_to_boundary_node(nod_pt);
872  add_boundary_node(1,nod_pt);
873 
874  //First part of lower boundary
875  nod_pt = finite_element_pt(8)->node_pt(n);
876  convert_to_boundary_node(nod_pt);
877  add_boundary_node(0,nod_pt);
878 
879  //First part of upper boundary
880  nod_pt = finite_element_pt(8)->node_pt(np*(np-1) + n);
881  convert_to_boundary_node(nod_pt);
882  add_boundary_node(2,nod_pt);
883 
884  //First part of hole boundary
885  nod_pt=finite_element_pt(3)->node_pt(np*(np-1)+n);
886  convert_to_boundary_node(nod_pt);
887  add_boundary_node(4,nod_pt);
888  }
889 
890  for(unsigned n=1;n<np;n++)
891  {
892  //Second part of lower boundary
893  Node* nod_pt=finite_element_pt(3)->node_pt(n);
894  convert_to_boundary_node(nod_pt);
895  add_boundary_node(0,nod_pt);
896 
897  //Third part of lower boundary
898  nod_pt=finite_element_pt(4)->node_pt(n);
899  convert_to_boundary_node(nod_pt);
900  add_boundary_node(0,nod_pt);
901 
902  //Second part of upper boundary
903  nod_pt=finite_element_pt(1)->node_pt(np*(np-1)+n);
904  convert_to_boundary_node(nod_pt);
905  add_boundary_node(2,nod_pt);
906 
907  //Third part of upper boundary
908  nod_pt=finite_element_pt(4)->node_pt(np*(np-1)+n);
909  convert_to_boundary_node(nod_pt);
910  add_boundary_node(2,nod_pt);
911 
912  //Next part of hole
913  nod_pt=finite_element_pt(2)->node_pt(n*np);
914  convert_to_boundary_node(nod_pt);
915  add_boundary_node(4,nod_pt);
916  }
917 
918  for(unsigned n=1;n<np;n++)
919  {
920  //Third part of lower boundary
921  Node* nod_pt=finite_element_pt(5)->node_pt(n);
922  convert_to_boundary_node(nod_pt);
923  add_boundary_node(0,nod_pt);
924 
925  //Third part of upper boundary
926  nod_pt=finite_element_pt(5)->node_pt(np*(np-1)+n);
927  convert_to_boundary_node(nod_pt);
928  add_boundary_node(2,nod_pt);
929  }
930 
931  for(unsigned n=1;n<np;n++)
932  {
933  //Fourth part of lower boundary
934  Node* nod_pt=finite_element_pt(6)->node_pt(n);
935  convert_to_boundary_node(nod_pt);
936  add_boundary_node(0,nod_pt);
937 
938  //Fourth part of upper boundary
939  nod_pt=finite_element_pt(6)->node_pt(np*(np-1)+n);
940  convert_to_boundary_node(nod_pt);
941  add_boundary_node(2,nod_pt);
942  }
943 
944  for(unsigned n=1;n<np;n++)
945  {
946  //Final part of lower boundary
947  Node* nod_pt=finite_element_pt(7)->node_pt(n);
948  convert_to_boundary_node(nod_pt);
949  add_boundary_node(0,nod_pt);
950 
951  //Final part of upper boundary
952  nod_pt=finite_element_pt(7)->node_pt(np*(np-1)+n);
953  convert_to_boundary_node(nod_pt);
954  add_boundary_node(2,nod_pt);
955 
956  //Next part of hole
957  nod_pt=finite_element_pt(1)->node_pt(np-n-1);
958  convert_to_boundary_node(nod_pt);
959  add_boundary_node(4,nod_pt);
960  }
961 
962  for(unsigned n=1;n<np-1;n++)
963  {
964  //Final part of hole
965  Node* nod_pt=finite_element_pt(0)->node_pt(np*(np-n-1)+np-1);
966  convert_to_boundary_node(nod_pt);
967  add_boundary_node(4,nod_pt);
968  }
969 
970 
971  }
n
const unsigned n
Definition: CG3DPackingUnitTest.cpp:11
e
Array< double, 1, 3 > e(1./3., 0.5, 2.)
RectangleWithHoleMesh::Domain_pt
RectangleWithHoleDomain * Domain_pt
Pointer to the domain.
Definition: adaptive_hopf.cc:979
RectangleWithHoleMesh::height
const double & height()
Access function to height.
Definition: adaptive_hopf_with_separate_meshes.cc:990
RectangleWithHoleMesh::length
const double & length()
Access function to length.
Definition: adaptive_hopf_with_separate_meshes.cc:988
oomph::Domain::nmacro_element
unsigned nmacro_element()
Number of macro elements in domain.
Definition: domain.h:123
oomph::Domain::macro_element_pt
MacroElement * macro_element_pt(const unsigned &i)
Access to i-th macro element.
Definition: domain.h:116
oomph::FiniteElement::node_pt
Node *& node_pt(const unsigned &n)
Return a pointer to the local node n.
Definition: elements.h:2175
oomph::MacroElement::macro_map
void macro_map(const Vector< double > &s, Vector< double > &r)
The mapping from local to global coordinates at the current time : r(s)
Definition: macro_element.h:126
oomph::Mesh::add_boundary_node
void add_boundary_node(const unsigned &b, Node *const &node_pt)
Add a (pointer to) a node to the b-th boundary.
Definition: mesh.cc:243
oomph::Mesh::Node_pt
Vector< Node * > Node_pt
Vector of pointers to nodes.
Definition: mesh.h:183
oomph::Mesh::finite_element_pt
FiniteElement * finite_element_pt(const unsigned &e) const
Definition: mesh.h:473
oomph::Mesh::set_nboundary
void set_nboundary(const unsigned &nbound)
Set the number of boundaries in the mesh.
Definition: mesh.h:505
oomph::Mesh::convert_to_boundary_node
void convert_to_boundary_node(Node *&node_pt, const Vector< FiniteElement * > &finite_element_pt)
Definition: mesh.cc:2590
oomph::Mesh::Element_pt
Vector< GeneralisedElement * > Element_pt
Vector of pointers to generalised elements.
Definition: mesh.h:186
oomph::Node
Definition: nodes.h:906
oomph::RectangleWithHoleDomain
Rectangular domain with circular whole.
Definition: rectangle_with_hole_domain.h:43
s
RealScalar s
Definition: level1_cplx_impl.h:130
UniformPSDSelfTest.r
r
Definition: UniformPSDSelfTest.py:20

References e(), Global_Physical_Variables::height(), n, UniformPSDSelfTest::r, and s.

◆ RectangleWithHoleMesh() [2/3]

template<class ELEMENT >
RectangleWithHoleMesh< ELEMENT >::RectangleWithHoleMesh ( GeomObject *  cylinder_pt,
const double &  length,
const double &  height,
TimeStepper *  time_stepper_pt = &Mesh::Default_TimeStepper 
)
inline

Constructor: Pass pointer to geometric object that represents the cylinder, the length and height of the domain. The GeomObject must be parametrised such that \(\zeta \in [0,2\pi]\) sweeps around the circumference in anticlockwise direction. Timestepper defaults to Steady default timestepper.

695  {
696  //Create the domain
697  Domain_pt = new RectangleWithHoleDomain(cylinder_pt,length,height);
698 
699  Length = length; Height = height;
700 
701  //Initialise the node counter
702  unsigned long node_count=0;
703 
704  //Vectors used to get data from domains
705  Vector<double> s(2),r(2);
706 
707  //Setup temporary storage for the Node
708  Vector<Node*> Tmp_node_pt;
709 
710  //Now blindly loop over the macro elements and associate and finite
711  //element with each
712  unsigned nmacro_element = Domain_pt->nmacro_element();
713  for(unsigned e=0;e<nmacro_element;e++)
714  {
715  //Create the FiniteElement and add to the Element_pt Vector
716  Element_pt.push_back(new ELEMENT);
717 
718  //Read out the number of linear points in the element
719  unsigned np =
720  dynamic_cast<ELEMENT*>(finite_element_pt(e))->nnode_1d();
721 
722  //Loop over nodes in the column
723  for(unsigned l1=0;l1<np;l1++)
724  {
725  //Loop over the nodes in the row
726  for(unsigned l2=0;l2<np;l2++)
727  {
728  //Allocate the memory for the node
729  Tmp_node_pt.push_back(finite_element_pt(e)->
730  construct_node(l1*np+l2,time_stepper_pt));
731 
732  //Read out the position of the node from the macro element
733  s[0] = -1.0 + 2.0*(double)l2/(double)(np-1);
734  s[1] = -1.0 + 2.0*(double)l1/(double)(np-1);
735  Domain_pt->macro_element_pt(e)->macro_map(s,r);
736 
737  //Set the position of the node
738  Tmp_node_pt[node_count]->x(0) = r[0];
739  Tmp_node_pt[node_count]->x(1) = r[1];
740 
741  //Increment the node number
742  node_count++;
743  }
744  }
745  } //End of loop over macro elements
746 
747 
748 
749  //Now the elements have been created, but there will be nodes in
750  //common, need to loop over the common edges and sort it, by reassigning
751  //pointers and the deleting excess nodes
752 
753  //Read out the number of linear points in the element
754  unsigned np=dynamic_cast<ELEMENT*>(finite_element_pt(0))->nnode_1d();
755 
756  //Edge between Elements 0 and 8
757  for(unsigned n=0;n<np;n++)
758  {
759  finite_element_pt(8)->node_pt(n*np + (np-1)) =
760  finite_element_pt(0)->node_pt(n*np);
761  //Remover the nodes in element 8 from the temporary node list
762  delete Tmp_node_pt[8*np*np + n*np + (np-1)];
763  Tmp_node_pt[8*np*np + n*np + (np-1)] = 0;
764  }
765 
766  //Edge between Elements 0 and 1
767  for(unsigned n=0;n<np;n++)
768  {
769  //Set the nodes in element 1 to be the same as in element 0
770  finite_element_pt(1)->node_pt(n*np)
771  = finite_element_pt(0)->node_pt((np-1)*np+np-1-n);
772 
773  //Remove the nodes in element 1 from the temporary node list
774  delete Tmp_node_pt[np*np + n*np];
775  Tmp_node_pt[np*np + n*np] = 0;
776  }
777 
778  //Edge between Elements 0 and 3
779  for(unsigned n=0;n<np;n++)
780  {
781  //Set the nodes in element 3 to be the same as in element 0
782  finite_element_pt(3)->node_pt(n*np)
783  = finite_element_pt(0)->node_pt(n);
784 
785  //Remove the nodes in element 3 from the temporary node list
786  delete Tmp_node_pt[3*np*np + n*np];
787  Tmp_node_pt[3*np*np + n*np] = 0;
788  }
789 
790  //Edge between Element 1 and 2
791  for(unsigned n=0;n<np;n++)
792  {
793  //Set the nodes in element 2 to be the same as in element 1
794  finite_element_pt(2)->node_pt(np*(np-1)+n)
795  = finite_element_pt(1)->node_pt(np*n+np-1);
796 
797  //Remove the nodes in element 2 from the temporary node list
798  delete Tmp_node_pt[2*np*np + np*(np-1)+n];
799  Tmp_node_pt[2*np*np + np*(np-1)+n] = 0;
800  }
801 
802 
803  //Edge between Element 3 and 2
804  for(unsigned n=0;n<np;n++)
805  {
806  //Set the nodes in element 2 to be the same as in element 3
807  finite_element_pt(2)->node_pt(n)
808  = finite_element_pt(3)->node_pt(np*(np-n-1)+np-1);
809 
810  //Remove the nodes in element 2 from the temporary node list
811  delete Tmp_node_pt[2*np*np + n];
812  Tmp_node_pt[2*np*np + n] = 0;
813  }
814 
815 
816  //Edge between Element 2 and 4
817  for(unsigned n=0;n<np;n++)
818  {
819  //Set the nodes in element 4 to be the same as in element 2
820  finite_element_pt(4)->node_pt(n*np)
821  = finite_element_pt(2)->node_pt(np*n+np-1);
822 
823  //Remove the nodes in element 4 from the temporary node list
824  delete Tmp_node_pt[4*np*np + n*np];
825  Tmp_node_pt[4*np*np + n*np] = 0;
826  }
827 
828  //Edge between Element 4 and 5
829  for(unsigned n=0;n<np;n++)
830  {
831  //Set the nodes in element 5 to be the same as in element 4
832  finite_element_pt(5)->node_pt(n*np)
833  = finite_element_pt(4)->node_pt(np*n+np-1);
834 
835  //Remove the nodes in element 5 from the temporary node list
836  delete Tmp_node_pt[5*np*np + n*np];
837  Tmp_node_pt[5*np*np + n*np] = 0;
838  }
839 
840  //Edge between Element 5 and 6
841  for(unsigned n=0;n<np;n++)
842  {
843  //Set the nodes in element 6 to be the same as in element 5
844  finite_element_pt(6)->node_pt(n*np)
845  = finite_element_pt(5)->node_pt(np*n+np-1);
846 
847  //Remove the nodes in element 6 from the temporary node list
848  delete Tmp_node_pt[6*np*np + n*np];
849  Tmp_node_pt[6*np*np + n*np] = 0;
850  }
851 
852  //Edge between Element 6 and 7
853  for(unsigned n=0;n<np;n++)
854  {
855  //Set the nodes in element 7 to be the same as in element 6
856  finite_element_pt(7)->node_pt(n*np)
857  = finite_element_pt(6)->node_pt(np*n+np-1);
858 
859  //Remove the nodes in element 7 from the temporary node list
860  delete Tmp_node_pt[7*np*np + n*np];
861  Tmp_node_pt[7*np*np + n*np] = 0;
862  }
863 
864  //Now set the actual true nodes
865  for(unsigned long n=0;n<node_count;n++)
866  {
867  if(Tmp_node_pt[n]!=0) {Node_pt.push_back(Tmp_node_pt[n]);}
868  }
869 
870  //Finally set the nodes on the boundaries
871  set_nboundary(5);
872 
873  for(unsigned n=0;n<np;n++)
874  {
875  //Left hand side
876  Node* nod_pt=finite_element_pt(8)->node_pt(n*np);
877  convert_to_boundary_node(nod_pt);
878  add_boundary_node(3,nod_pt);
879 
880  //Right hand side
881  nod_pt=finite_element_pt(7)->node_pt(n*np+np-1);
882  convert_to_boundary_node(nod_pt);
883  add_boundary_node(1,nod_pt);
884 
885  //First part of lower boundary
886  nod_pt = finite_element_pt(8)->node_pt(n);
887  convert_to_boundary_node(nod_pt);
888  add_boundary_node(0,nod_pt);
889 
890  //First part of upper boundary
891  nod_pt = finite_element_pt(8)->node_pt(np*(np-1) + n);
892  convert_to_boundary_node(nod_pt);
893  add_boundary_node(2,nod_pt);
894 
895  //First part of hole boundary
896  nod_pt=finite_element_pt(3)->node_pt(np*(np-1)+n);
897  convert_to_boundary_node(nod_pt);
898  add_boundary_node(4,nod_pt);
899  }
900 
901  for(unsigned n=1;n<np;n++)
902  {
903  //Second part of lower boundary
904  Node* nod_pt=finite_element_pt(3)->node_pt(n);
905  convert_to_boundary_node(nod_pt);
906  add_boundary_node(0,nod_pt);
907 
908  //Third part of lower boundary
909  nod_pt=finite_element_pt(4)->node_pt(n);
910  convert_to_boundary_node(nod_pt);
911  add_boundary_node(0,nod_pt);
912 
913  //Second part of upper boundary
914  nod_pt=finite_element_pt(1)->node_pt(np*(np-1)+n);
915  convert_to_boundary_node(nod_pt);
916  add_boundary_node(2,nod_pt);
917 
918  //Third part of upper boundary
919  nod_pt=finite_element_pt(4)->node_pt(np*(np-1)+n);
920  convert_to_boundary_node(nod_pt);
921  add_boundary_node(2,nod_pt);
922 
923  //Next part of hole
924  nod_pt=finite_element_pt(2)->node_pt(n*np);
925  convert_to_boundary_node(nod_pt);
926  add_boundary_node(4,nod_pt);
927  }
928 
929  for(unsigned n=1;n<np;n++)
930  {
931  //Third part of lower boundary
932  Node* nod_pt=finite_element_pt(5)->node_pt(n);
933  convert_to_boundary_node(nod_pt);
934  add_boundary_node(0,nod_pt);
935 
936  //Third part of upper boundary
937  nod_pt=finite_element_pt(5)->node_pt(np*(np-1)+n);
938  convert_to_boundary_node(nod_pt);
939  add_boundary_node(2,nod_pt);
940  }
941 
942  for(unsigned n=1;n<np;n++)
943  {
944  //Fourth part of lower boundary
945  Node* nod_pt=finite_element_pt(6)->node_pt(n);
946  convert_to_boundary_node(nod_pt);
947  add_boundary_node(0,nod_pt);
948 
949  //Fourth part of upper boundary
950  nod_pt=finite_element_pt(6)->node_pt(np*(np-1)+n);
951  convert_to_boundary_node(nod_pt);
952  add_boundary_node(2,nod_pt);
953  }
954 
955  for(unsigned n=1;n<np;n++)
956  {
957  //Final part of lower boundary
958  Node* nod_pt=finite_element_pt(7)->node_pt(n);
959  convert_to_boundary_node(nod_pt);
960  add_boundary_node(0,nod_pt);
961 
962  //Final part of upper boundary
963  nod_pt=finite_element_pt(7)->node_pt(np*(np-1)+n);
964  convert_to_boundary_node(nod_pt);
965  add_boundary_node(2,nod_pt);
966 
967  //Next part of hole
968  nod_pt=finite_element_pt(1)->node_pt(np-n-1);
969  convert_to_boundary_node(nod_pt);
970  add_boundary_node(4,nod_pt);
971  }
972 
973  for(unsigned n=1;n<np-1;n++)
974  {
975  //Final part of hole
976  Node* nod_pt=finite_element_pt(0)->node_pt(np*(np-n-1)+np-1);
977  convert_to_boundary_node(nod_pt);
978  add_boundary_node(4,nod_pt);
979  }
980 
981 
982  }
RectangleWithHoleMesh::Height
double Height
Definition: adaptive_hopf_with_separate_meshes.cc:1000
RectangleWithHoleMesh::Length
double Length
Definition: adaptive_hopf_with_separate_meshes.cc:998

References e(), GlobalParameters::Height, Global_Physical_Variables::height(), Global_Physical_Variables::Length, n, UniformPSDSelfTest::r, and s.

◆ RectangleWithHoleMesh() [3/3]

template<class ELEMENT >
RectangleWithHoleMesh< ELEMENT >::RectangleWithHoleMesh ( GeomObject *  cylinder_pt,
const double &  length,
const double &  height,
TimeStepper *  time_stepper_pt = &Mesh::Default_TimeStepper 
)
inline

Constructor: Pass pointer to geometric object that represents the cylinder, the length and height of the domain. The GeomObject must be parametrised such that \(\zeta \in [0,2\pi]\) sweeps around the circumference in anticlockwise direction. Timestepper defaults to Steady default timestepper.

633  {
634  //Create the domain
635  Domain_pt = new RectangleWithHoleDomain(cylinder_pt,length,height);
636 
637  //Initialise the node counter
638  unsigned long node_count=0;
639 
640  //Vectors used to get data from domains
641  Vector<double> s(2),r(2);
642 
643  //Setup temporary storage for the Node
644  Vector<Node*> Tmp_node_pt;
645 
646  //Now blindly loop over the macro elements and associate and finite
647  //element with each
648  unsigned nmacro_element = Domain_pt->nmacro_element();
649  for(unsigned e=0;e<nmacro_element;e++)
650  {
651  //Create the FiniteElement and add to the Element_pt Vector
652  Element_pt.push_back(new ELEMENT);
653 
654  //Read out the number of linear points in the element
655  unsigned np =
656  dynamic_cast<ELEMENT*>(finite_element_pt(e))->nnode_1d();
657 
658  //Loop over nodes in the column
659  for(unsigned l1=0;l1<np;l1++)
660  {
661  //Loop over the nodes in the row
662  for(unsigned l2=0;l2<np;l2++)
663  {
664  //Allocate the memory for the node
665  Tmp_node_pt.push_back(finite_element_pt(e)->
666  construct_node(l1*np+l2,time_stepper_pt));
667 
668  //Read out the position of the node from the macro element
669  s[0] = -1.0 + 2.0*(double)l2/(double)(np-1);
670  s[1] = -1.0 + 2.0*(double)l1/(double)(np-1);
671  Domain_pt->macro_element_pt(e)->macro_map(s,r);
672 
673  //Set the position of the node
674  Tmp_node_pt[node_count]->x(0) = r[0];
675  Tmp_node_pt[node_count]->x(1) = r[1];
676 
677  //Increment the node number
678  node_count++;
679  }
680  }
681  } //End of loop over macro elements
682 
683 
684 
685  //Now the elements have been created, but there will be nodes in
686  //common, need to loop over the common edges and sort it, by reassigning
687  //pointers and the deleting excess nodes
688 
689  //Read out the number of linear points in the element
690  unsigned np=dynamic_cast<ELEMENT*>(finite_element_pt(0))->nnode_1d();
691 
692  //Edge between Elements 0 and 1
693  for(unsigned n=0;n<np;n++)
694  {
695  //Set the nodes in element 1 to be the same as in element 0
696  finite_element_pt(1)->node_pt(n*np)
697  = finite_element_pt(0)->node_pt((np-1)*np+np-1-n);
698 
699  //Remove the nodes in element 1 from the temporary node list
700  delete Tmp_node_pt[np*np + n*np];
701  Tmp_node_pt[np*np + n*np] = 0;
702  }
703 
704  //Edge between Elements 0 and 3
705  for(unsigned n=0;n<np;n++)
706  {
707  //Set the nodes in element 3 to be the same as in element 0
708  finite_element_pt(3)->node_pt(n*np)
709  = finite_element_pt(0)->node_pt(n);
710 
711  //Remove the nodes in element 3 from the temporary node list
712  delete Tmp_node_pt[3*np*np + n*np];
713  Tmp_node_pt[3*np*np + n*np] = 0;
714  }
715 
716  //Edge between Element 1 and 2
717  for(unsigned n=0;n<np;n++)
718  {
719  //Set the nodes in element 2 to be the same as in element 1
720  finite_element_pt(2)->node_pt(np*(np-1)+n)
721  = finite_element_pt(1)->node_pt(np*n+np-1);
722 
723  //Remove the nodes in element 2 from the temporary node list
724  delete Tmp_node_pt[2*np*np + np*(np-1)+n];
725  Tmp_node_pt[2*np*np + np*(np-1)+n] = 0;
726  }
727 
728 
729  //Edge between Element 3 and 2
730  for(unsigned n=0;n<np;n++)
731  {
732  //Set the nodes in element 2 to be the same as in element 3
733  finite_element_pt(2)->node_pt(n)
734  = finite_element_pt(3)->node_pt(np*(np-n-1)+np-1);
735 
736  //Remove the nodes in element 2 from the temporary node list
737  delete Tmp_node_pt[2*np*np + n];
738  Tmp_node_pt[2*np*np + n] = 0;
739  }
740 
741 
742  //Edge between Element 2 and 4
743  for(unsigned n=0;n<np;n++)
744  {
745  //Set the nodes in element 4 to be the same as in element 2
746  finite_element_pt(4)->node_pt(n*np)
747  = finite_element_pt(2)->node_pt(np*n+np-1);
748 
749  //Remove the nodes in element 4 from the temporary node list
750  delete Tmp_node_pt[4*np*np + n*np];
751  Tmp_node_pt[4*np*np + n*np] = 0;
752  }
753 
754  //Edge between Element 4 and 5
755  for(unsigned n=0;n<np;n++)
756  {
757  //Set the nodes in element 5 to be the same as in element 4
758  finite_element_pt(5)->node_pt(n*np)
759  = finite_element_pt(4)->node_pt(np*n+np-1);
760 
761  //Remove the nodes in element 5 from the temporary node list
762  delete Tmp_node_pt[5*np*np + n*np];
763  Tmp_node_pt[5*np*np + n*np] = 0;
764  }
765 
766  //Edge between Element 5 and 6
767  for(unsigned n=0;n<np;n++)
768  {
769  //Set the nodes in element 6 to be the same as in element 5
770  finite_element_pt(6)->node_pt(n*np)
771  = finite_element_pt(5)->node_pt(np*n+np-1);
772 
773  //Remove the nodes in element 6 from the temporary node list
774  delete Tmp_node_pt[6*np*np + n*np];
775  Tmp_node_pt[6*np*np + n*np] = 0;
776  }
777 
778  //Edge between Element 6 and 7
779  for(unsigned n=0;n<np;n++)
780  {
781  //Set the nodes in element 7 to be the same as in element 6
782  finite_element_pt(7)->node_pt(n*np)
783  = finite_element_pt(6)->node_pt(np*n+np-1);
784 
785  //Remove the nodes in element 7 from the temporary node list
786  delete Tmp_node_pt[7*np*np + n*np];
787  Tmp_node_pt[7*np*np + n*np] = 0;
788  }
789 
790  //Now set the actual true nodes
791  for(unsigned long n=0;n<node_count;n++)
792  {
793  if(Tmp_node_pt[n]!=0) {Node_pt.push_back(Tmp_node_pt[n]);}
794  }
795 
796  //Finally set the nodes on the boundaries
797  set_nboundary(5);
798 
799  for(unsigned n=0;n<np;n++)
800  {
801  //Left hand side
802  Node* nod_pt=finite_element_pt(0)->node_pt(n*np);
803  convert_to_boundary_node(nod_pt);
804  add_boundary_node(3,nod_pt);
805 
806  //Right hand side
807  nod_pt=finite_element_pt(7)->node_pt(n*np+np-1);
808  convert_to_boundary_node(nod_pt);
809  add_boundary_node(1,nod_pt);
810 
811  //First part of lower boundary
812  nod_pt=finite_element_pt(3)->node_pt(n);
813  convert_to_boundary_node(nod_pt);
814  add_boundary_node(0,nod_pt);
815 
816  //First part of upper boundary
817  nod_pt=finite_element_pt(1)->node_pt(np*(np-1)+n);
818  convert_to_boundary_node(nod_pt);
819  add_boundary_node(2,nod_pt);
820 
821  //First part of hole boundary
822  nod_pt=finite_element_pt(3)->node_pt(np*(np-1)+n);
823  convert_to_boundary_node(nod_pt);
824  add_boundary_node(4,nod_pt);
825  }
826 
827  for(unsigned n=1;n<np;n++)
828  {
829  //Second part of lower boundary
830  Node* nod_pt=finite_element_pt(4)->node_pt(n);
831  convert_to_boundary_node(nod_pt);
832  add_boundary_node(0,nod_pt);
833 
834  //Second part of upper boundary
835  nod_pt=finite_element_pt(4)->node_pt(np*(np-1)+n);
836  convert_to_boundary_node(nod_pt);
837  add_boundary_node(2,nod_pt);
838 
839  //Next part of hole
840  nod_pt=finite_element_pt(2)->node_pt(n*np);
841  convert_to_boundary_node(nod_pt);
842  add_boundary_node(4,nod_pt);
843  }
844 
845  for(unsigned n=1;n<np;n++)
846  {
847  //Third part of lower boundary
848  Node* nod_pt=finite_element_pt(5)->node_pt(n);
849  convert_to_boundary_node(nod_pt);
850  add_boundary_node(0,nod_pt);
851 
852  //Third part of upper boundary
853  nod_pt=finite_element_pt(5)->node_pt(np*(np-1)+n);
854  convert_to_boundary_node(nod_pt);
855  add_boundary_node(2,nod_pt);
856  }
857 
858  for(unsigned n=1;n<np;n++)
859  {
860  //Fourth part of lower boundary
861  Node* nod_pt=finite_element_pt(6)->node_pt(n);
862  convert_to_boundary_node(nod_pt);
863  add_boundary_node(0,nod_pt);
864 
865  //Fourth part of upper boundary
866  nod_pt=finite_element_pt(6)->node_pt(np*(np-1)+n);
867  convert_to_boundary_node(nod_pt);
868  add_boundary_node(2,nod_pt);
869  }
870 
871  for(unsigned n=1;n<np;n++)
872  {
873  //Final part of lower boundary
874  Node* nod_pt=finite_element_pt(7)->node_pt(n);
875  convert_to_boundary_node(nod_pt);
876  add_boundary_node(0,nod_pt);
877 
878  //Final part of upper boundary
879  nod_pt=finite_element_pt(7)->node_pt(np*(np-1)+n);
880  convert_to_boundary_node(nod_pt);
881  add_boundary_node(2,nod_pt);
882 
883  //Next part of hole
884  nod_pt=finite_element_pt(1)->node_pt(np-n-1);
885  convert_to_boundary_node(nod_pt);
886  add_boundary_node(4,nod_pt);
887  }
888 
889  for(unsigned n=1;n<np-1;n++)
890  {
891  //Final part of hole
892  Node* nod_pt=finite_element_pt(0)->node_pt(np*(np-n-1)+np-1);
893  convert_to_boundary_node(nod_pt);
894  add_boundary_node(4,nod_pt);
895  }
896 
897 
898  }

References e(), Global_Physical_Variables::height(), n, UniformPSDSelfTest::r, and s.

Member Function Documentation

◆ domain_pt() [1/3]

template<class ELEMENT >
RectangleWithHoleDomain* RectangleWithHoleMesh< ELEMENT >::domain_pt ( )
inline

Access function to the domain.

974 {return Domain_pt;}

◆ domain_pt() [2/3]

template<class ELEMENT >
RectangleWithHoleDomain* RectangleWithHoleMesh< ELEMENT >::domain_pt ( )
inline

Access function to the domain.

985 {return Domain_pt;}

◆ domain_pt() [3/3]

template<class ELEMENT >
RectangleWithHoleDomain* RectangleWithHoleMesh< ELEMENT >::domain_pt ( )
inline

Access function to the domain.

901 {return Domain_pt;}

◆ height()

template<class ELEMENT >
const double& RectangleWithHoleMesh< ELEMENT >::height ( )
inline

Access function to height.

990 {return Height;}

References GlobalParameters::Height.

◆ length()

template<class ELEMENT >
const double& RectangleWithHoleMesh< ELEMENT >::length ( )
inline

Access function to length.

988 {return Length;}

References Global_Physical_Variables::Length.

Member Data Documentation

◆ Domain_pt

template<class ELEMENT >
RectangleWithHoleDomain* RectangleWithHoleMesh< ELEMENT >::Domain_pt
protected

Pointer to the domain.

◆ Height

template<class ELEMENT >
double RectangleWithHoleMesh< ELEMENT >::Height
protected

◆ Length

template<class ELEMENT >
double RectangleWithHoleMesh< ELEMENT >::Length
protected
The documentation for this class was generated from the following files: