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

#include <cylinder_with_flag_mesh.template.h>

+ Inheritance diagram for oomph::CylinderWithFlagMesh< ELEMENT >:

Public Member Functions

 CylinderWithFlagMesh (Circle *cylinder_pt, GeomObject *top_flag_pt, GeomObject *bottom_flag_pt, GeomObject *tip_flag_pt, const double &length, const double &height, const double &flag_length, const double &flag_height, const double &centre_x, const double &centre_y, const double &a, TimeStepper *time_stepper_pt=&Mesh::Default_TimeStepper)
 
virtual ~CylinderWithFlagMesh ()
 Destructor: Kill the domain. More...
 
CylinderWithFlagDomain * 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 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...
 
- Public Member Functions inherited from oomph::QuadMeshBase
 QuadMeshBase ()
 Constructor (empty) More...
 
 QuadMeshBase (const QuadMeshBase &node)=delete
 Broken copy constructor. More...
 
void operator= (const QuadMeshBase &)=delete
 Broken assignment operator. More...
 
virtual ~QuadMeshBase ()
 Destructor (empty) More...
 
void setup_boundary_element_info ()
 
void setup_boundary_element_info (std::ostream &outfile)
 

Protected Attributes

CylinderWithFlagDomain * Domain_pt
 Pointer to the domain. More...
 
- 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 oomph::CylinderWithFlagMesh< ELEMENT >

Domain-based mesh for cylinder with flag as in Turek benchmark.

Constructor & Destructor Documentation

◆ CylinderWithFlagMesh()

template<class ELEMENT >
oomph::CylinderWithFlagMesh< ELEMENT >::CylinderWithFlagMesh ( Circle *  cylinder_pt,
GeomObject *  top_flag_pt,
GeomObject *  bottom_flag_pt,
GeomObject *  tip_flag_pt,
const double &  length,
const double &  height,
const double &  flag_length,
const double &  flag_height,
const double &  centre_x,
const double &  centre_y,
const double &  a,
TimeStepper *  time_stepper_pt = &Mesh::Default_TimeStepper 
)

Constructor. Pass the pointers to the GeomObjects that parametrise the cylinder, the three edges of the flag, the length and height of the domain, the length and height of the flag, the coordinates of the centre of the cylinder and its radius. Timestepper defaults to Steady default timestepper.

56  {
57  // Mesh can only be built with 2D Qelements.
58  MeshChecker::assert_geometric_element<QElementGeometricBase, ELEMENT>(2);
59 
60  // Create the domain
61  Domain_pt = new CylinderWithFlagDomain(cylinder_pt,
62  top_flag_pt,
63  bottom_flag_pt,
64  tip_flag_pt,
65  length,
66  height,
67  flag_length,
68  flag_height,
69  centre_x,
70  centre_y,
71  a);
72 
73  // Initialise the node counter
74  unsigned long node_count = 0;
75 
76  // Vectors used to get data from domains
77  Vector<double> s(2);
78  Vector<double> r(2);
79 
80  // Setup temporary storage for the Node
81  Vector<Node*> tmp_node_pt;
82 
83  // Now blindly loop over the macro elements and associate and finite
84  // element with each
85  unsigned nmacro_element = Domain_pt->nmacro_element();
86  for (unsigned e = 0; e < nmacro_element; e++)
87  {
88  // Create the FiniteElement and add to the Element_pt Vector
89  Element_pt.push_back(new ELEMENT);
90 
91  // Read out the number of linear points in the element
92  unsigned np =
93  dynamic_cast<ELEMENT*>(this->finite_element_pt(e))->nnode_1d();
94 
95  // Loop over nodes in the column
96  for (unsigned l1 = 0; l1 < np; l1++)
97  {
98  // Loop over the nodes in the row
99  for (unsigned l2 = 0; l2 < np; l2++)
100  {
101  // Allocate the memory for the node
102  tmp_node_pt.push_back(
103  this->finite_element_pt(e)->construct_boundary_node(
104  l1 * np + l2, time_stepper_pt));
105 
106  // Read out the position of the node from the macro element
107  s[0] = -1.0 + 2.0 * (double)l2 / (double)(np - 1);
108  s[1] = -1.0 + 2.0 * (double)l1 / (double)(np - 1);
109  Domain_pt->macro_element_pt(e)->macro_map(s, r);
110 
111  // Set the position of the node
112  tmp_node_pt[node_count]->x(0) = r[0];
113  tmp_node_pt[node_count]->x(1) = r[1];
114 
115  // Increment the node number
116  node_count++;
117  }
118  }
119  } // End of loop over macro elements
120 
121  // Now the elements have been created, but there will be nodes in
122  // common, need to loop over the common edges and sort it, by reassigning
123  // pointers and the deleting excess nodes
124 
125  // Read out the number of linear points in the element
126  unsigned np =
127  dynamic_cast<ELEMENT*>(this->finite_element_pt(0))->nnode_1d();
128 
129  // Edge between Elements 0 and 1
130  for (unsigned n = 0; n < np; n++)
131  {
132  // Set the nodes in element 1 to be the same as in element 0
133  this->finite_element_pt(1)->node_pt(n * np) =
134  this->finite_element_pt(0)->node_pt((np - 1) * np + np - 1 - n);
135 
136  // Remove the nodes in element 1 from the temporaray node list
137  delete tmp_node_pt[np * np + n * np];
138  tmp_node_pt[np * np + n * np] = 0;
139  }
140 
141  // Edge between Elements 1 and 2
142  for (unsigned n = 0; n < np; n++)
143  {
144  // Set the nodes in element 2 to be the same as in element 1
145  this->finite_element_pt(2)->node_pt(n * np) =
146  this->finite_element_pt(1)->node_pt(np * n + np - 1);
147 
148  // Remove the nodes in element 2 from the temporaray node list
149  delete tmp_node_pt[2 * np * np + n * np];
150  tmp_node_pt[2 * np * np + n * np] = 0;
151  }
152 
153  // Edge between Element 2 and 3
154  for (unsigned n = 0; n < np; n++)
155  {
156  // Set the nodes in element 3 to be the same as in element 2
157  this->finite_element_pt(3)->node_pt(np * (np - 1) + n) =
158  this->finite_element_pt(2)->node_pt(np * n + np - 1);
159 
160  // Remove the nodes in element 3 from the temporaray node list
161  delete tmp_node_pt[3 * np * np + np * (np - 1) + n];
162  tmp_node_pt[3 * np * np + np * (np - 1) + n] = 0;
163  }
164 
165  // Edge between Element 5 and 4
166  for (unsigned n = 0; n < np; n++)
167  {
168  // Set the nodes in element 4 to be the same as in element 5
169  this->finite_element_pt(4)->node_pt(n) =
170  this->finite_element_pt(5)->node_pt(np * (np - n - 1) + np - 1);
171 
172  // Remove the nodes in element 4 from the temporaray node list
173  delete tmp_node_pt[4 * np * np + n];
174  tmp_node_pt[4 * np * np + n] = 0;
175  }
176 
177  // Edge between Elements 6 and 5
178  for (unsigned n = 0; n < np; n++)
179  {
180  // Set the nodes in element 5 to be the same as in element 6
181  this->finite_element_pt(5)->node_pt(n * np) =
182  this->finite_element_pt(6)->node_pt(np * n + np - 1);
183 
184  // Remove the nodes in element 5 from the temporaray node list
185  delete tmp_node_pt[5 * np * np + n * np];
186  tmp_node_pt[5 * np * np + n * np] = 0;
187  }
188 
189  // Edge between Elements 0 and 6
190  for (unsigned n = 0; n < np; n++)
191  {
192  // Set the nodes in element 6 to be the same as in element 0
193  this->finite_element_pt(6)->node_pt(n * np) =
194  this->finite_element_pt(0)->node_pt(n);
195 
196  // Remove the nodes in element 6 from the temporaray node list
197  delete tmp_node_pt[6 * np * np + n * np];
198  tmp_node_pt[6 * np * np + n * np] = 0;
199  }
200 
201  // Edge between Elements 2 and 7
202  for (unsigned n = 0; n < np; n++)
203  {
204  // Set the nodes in element 7 to be the same as in element 2
205  this->finite_element_pt(7)->node_pt(n * np) =
206  this->finite_element_pt(2)->node_pt((np - 1) * np + np - 1 - n);
207 
208  // Remove the nodes in element 7 from the temporaray node list
209  delete tmp_node_pt[7 * np * np + n * np];
210  tmp_node_pt[7 * np * np + n * np] = 0;
211  }
212 
213  // Edge between Elements 3 and 8
214  for (unsigned n = 0; n < np; n++)
215  {
216  // Set the nodes in element 8 to be the same as in element 3
217  this->finite_element_pt(8)->node_pt(n * np) =
218  this->finite_element_pt(3)->node_pt(np * n + np - 1);
219 
220  // Remove the nodes in element 8 from the temporaray node list
221  delete tmp_node_pt[8 * np * np + n * np];
222  tmp_node_pt[8 * np * np + n * np] = 0;
223  }
224 
225  // Edge between Elements 4 and 9
226  for (unsigned n = 0; n < np; n++)
227  {
228  // Set the nodes in element 9 to be the same as in element 4
229  this->finite_element_pt(9)->node_pt(n * np) =
230  this->finite_element_pt(4)->node_pt(np * n + np - 1);
231 
232  // Remove the nodes in element 9 from the temporaray node list
233  delete tmp_node_pt[9 * np * np + n * np];
234  tmp_node_pt[9 * np * np + n * np] = 0;
235  }
236 
237 
238  // Edge between Elements 5 and 10
239  for (unsigned n = 0; n < np; n++)
240  {
241  // Set the nodes in element 10 to be the same as in element 5
242  this->finite_element_pt(10)->node_pt(n * np) =
243  this->finite_element_pt(5)->node_pt(n);
244 
245  // Remove the nodes in element 10 from the temporaray node list
246  delete tmp_node_pt[10 * np * np + n * np];
247  tmp_node_pt[10 * np * np + n * np] = 0;
248  }
249 
250 
251  // Edge between Elements 7 and 11
252  for (unsigned n = 0; n < np; n++)
253  {
254  // Set the nodes in element 11 to be the same as in element 7
255  this->finite_element_pt(11)->node_pt(n * np) =
256  this->finite_element_pt(7)->node_pt(np * n + np - 1);
257 
258  // Remove the nodes in element 11 from the temporaray node list
259  delete tmp_node_pt[11 * np * np + n * np];
260  tmp_node_pt[11 * np * np + n * np] = 0;
261  }
262 
263  // Edge between Elements 8 and 12
264  for (unsigned n = 0; n < np; n++)
265  {
266  // Set the nodes in element 12 to be the same as in element 8
267  this->finite_element_pt(12)->node_pt(n * np) =
268  this->finite_element_pt(8)->node_pt(np * n + np - 1);
269 
270  // Remove the nodes in element 12 from the temporaray node list
271  delete tmp_node_pt[12 * np * np + n * np];
272  tmp_node_pt[12 * np * np + n * np] = 0;
273  }
274 
275  // Edge between Elements 9 and 13
276  for (unsigned n = 0; n < np; n++)
277  {
278  // Set the nodes in element 13 to be the same as in element 9
279  this->finite_element_pt(13)->node_pt(n * np) =
280  this->finite_element_pt(9)->node_pt(np * n + np - 1);
281 
282  // Remove the nodes in element 13 from the temporaray node list
283  delete tmp_node_pt[13 * np * np + n * np];
284  tmp_node_pt[13 * np * np + n * np] = 0;
285  }
286 
287  // Edge between Elements 10 and 14
288  for (unsigned n = 0; n < np; n++)
289  {
290  // Set the nodes in element 14 to be the same as in element 10
291  this->finite_element_pt(14)->node_pt(n * np) =
292  this->finite_element_pt(10)->node_pt(np * n + np - 1);
293 
294  // Remove the nodes in element 14 from the temporaray node list
295  delete tmp_node_pt[14 * np * np + n * np];
296  tmp_node_pt[14 * np * np + n * np] = 0;
297  }
298 
299 
300  // Edge between Elements 7 and 8
301  for (unsigned n = 0; n < np; n++)
302  {
303  // Set the nodes in element 8 to be the same as in element 7
304  this->finite_element_pt(8)->node_pt(np * (np - 1) + n) =
305  this->finite_element_pt(7)->node_pt(n);
306 
307  // Remove the nodes in element 8 from the temporaray node list
308  delete tmp_node_pt[8 * np * np + np * (np - 1) + n];
309  tmp_node_pt[8 * np * np + np * (np - 1) + n] = 0;
310  }
311 
312 
313  // Edge between Elements 9 and 10
314  for (unsigned n = 0; n < np; n++)
315  {
316  // Set the nodes in element 10 to be the same as in element 9
317  this->finite_element_pt(10)->node_pt(np * (np - 1) + n) =
318  this->finite_element_pt(9)->node_pt(n);
319 
320  // Remove the nodes in element 10 from the temporaray node list
321  delete tmp_node_pt[10 * np * np + np * (np - 1) + n];
322  tmp_node_pt[10 * np * np + np * (np - 1) + n] = 0;
323  }
324 
325 
326  // Edge between Elements 11 and 15
327  for (unsigned n = 0; n < np; n++)
328  {
329  // Set the nodes in element 15 to be the same as in element 11
330  this->finite_element_pt(15)->node_pt(n * np) =
331  this->finite_element_pt(11)->node_pt(np * n + np - 1);
332 
333  // Remove the nodes in element 15 from the temporaray node list
334  delete tmp_node_pt[15 * np * np + n * np];
335  tmp_node_pt[15 * np * np + n * np] = 0;
336  }
337 
338  // Edge between Elements 12 and 16
339  for (unsigned n = 0; n < np; n++)
340  {
341  // Set the nodes in element 16 to be the same as in element 12
342  this->finite_element_pt(16)->node_pt(n * np) =
343  this->finite_element_pt(12)->node_pt(np * n + np - 1);
344 
345  // Remove the nodes in element 16 from the temporaray node list
346  delete tmp_node_pt[16 * np * np + n * np];
347  tmp_node_pt[16 * np * np + n * np] = 0;
348  }
349 
350  // Edge between Elements 13 and 17
351  for (unsigned n = 0; n < np; n++)
352  {
353  // Set the nodes in element 17 to be the same as in element 13
354  this->finite_element_pt(17)->node_pt(n * np) =
355  this->finite_element_pt(13)->node_pt(np * n + np - 1);
356 
357  // Remove the nodes in element 17 from the temporaray node list
358  delete tmp_node_pt[17 * np * np + n * np];
359  tmp_node_pt[17 * np * np + n * np] = 0;
360  }
361 
362  // Edge between Elements 14 and 18
363  for (unsigned n = 0; n < np; n++)
364  {
365  // Set the nodes in element 18 to be the same as in element 14
366  this->finite_element_pt(18)->node_pt(n * np) =
367  this->finite_element_pt(14)->node_pt(np * n + np - 1);
368 
369  // Remove the nodes in element 18 from the temporaray node list
370  delete tmp_node_pt[18 * np * np + n * np];
371  tmp_node_pt[18 * np * np + n * np] = 0;
372  }
373 
374 
375  // Edge between Elements 11 and 12
376  for (unsigned n = 0; n < np; n++)
377  {
378  // Set the nodes in element 12 to be the same as in element 11
379  this->finite_element_pt(12)->node_pt(np * (np - 1) + n) =
380  this->finite_element_pt(11)->node_pt(n);
381 
382  // Remove the nodes in element 12 from the temporaray node list
383  delete tmp_node_pt[12 * np * np + np * (np - 1) + n];
384  tmp_node_pt[12 * np * np + np * (np - 1) + n] = 0;
385  }
386 
387 
388  // Edge between Elements 13 and 14
389  for (unsigned n = 0; n < np; n++)
390  {
391  // Set the nodes in element 14 to be the same as in element 13
392  this->finite_element_pt(14)->node_pt(np * (np - 1) + n) =
393  this->finite_element_pt(13)->node_pt(n);
394 
395  // Remove the nodes in element 14 from the temporaray node list
396  delete tmp_node_pt[14 * np * np + np * (np - 1) + n];
397  tmp_node_pt[14 * np * np + np * (np - 1) + n] = 0;
398  }
399 
400 
401  // Edge between Element 15 and 19
402  for (unsigned n = 0; n < np; n++)
403  {
404  // Set the nodes in element 19 to be the same as in element 15
405  this->finite_element_pt(19)->node_pt(np * (np - 1) + n) =
406  this->finite_element_pt(15)->node_pt(np * n + np - 1);
407 
408  // Remove the nodes in element 19 from the temporaray node list
409  delete tmp_node_pt[19 * np * np + np * (np - 1) + n];
410  tmp_node_pt[19 * np * np + np * (np - 1) + n] = 0;
411  }
412 
413 
414  // Edge between Elements 19 and 16
415  for (unsigned n = 0; n < np; n++)
416  {
417  // Set the nodes in element 19 to be the same as in element 16
418  this->finite_element_pt(16)->node_pt(np * n + np - 1) =
419  this->finite_element_pt(19)->node_pt(n * np);
420 
421  // Remove the nodes in element 16 from the temporaray node list
422  delete tmp_node_pt[16 * np * np + np * (np - 1) + n];
423  tmp_node_pt[16 * np * np + np * (np - 1) + n] = 0;
424  }
425 
426 
427  // Edge between Elements 15 and 16
428  for (unsigned n = 0; n < np; n++)
429  {
430  // Set the nodes in element 16 to be the same as in element 15
431  this->finite_element_pt(16)->node_pt(np * (np - 1) + n) =
432  this->finite_element_pt(15)->node_pt(n);
433 
434  // Remove the nodes in element 16 from the temporaray node list
435  delete tmp_node_pt[16 * np * np + np * (np - 1) + n];
436  tmp_node_pt[16 * np * np + np * (np - 1) + n] = 0;
437  }
438 
439 
440  // Edge between Element 18 and 20
441  for (unsigned n = 0; n < np; n++)
442  {
443  // Set the nodes in element 20 to be the same as in element 18
444  this->finite_element_pt(20)->node_pt(n) =
445  this->finite_element_pt(18)->node_pt(np * (np - n - 1) + np - 1);
446 
447  // Remove the nodes in element 20 from the temporaray node list
448  delete tmp_node_pt[20 * np * np + n];
449  tmp_node_pt[20 * np * np + n] = 0;
450  }
451 
452 
453  // Edge between Elements 17 and 20
454  for (unsigned n = 0; n < np; n++)
455  {
456  // Set the nodes in element 20 to be the same as in element 17
457  this->finite_element_pt(20)->node_pt(n * np) =
458  this->finite_element_pt(17)->node_pt(np * n + np - 1);
459 
460  // Remove the nodes in element 20 from the temporaray node list
461  delete tmp_node_pt[20 * np * np + n * np];
462  tmp_node_pt[20 * np * np + n * np] = 0;
463  }
464 
465 
466  // Edge between Elements 17 and 18
467  for (unsigned n = 0; n < np; n++)
468  {
469  // Set the nodes in element 18 to be the same as in element 17
470  this->finite_element_pt(18)->node_pt(np * (np - 1) + n) =
471  this->finite_element_pt(17)->node_pt(n);
472 
473  // Remove the nodes in element 18 from the temporaray node list
474  delete tmp_node_pt[18 * np * np + np * (np - 1) + n];
475  tmp_node_pt[18 * np * np + np * (np - 1) + n] = 0;
476  }
477 
478 
479  // Edge between Elements 19 and 21
480  for (unsigned n = 0; n < np; n++)
481  {
482  // Set the nodes in element 21 to be the same as in element 19
483  this->finite_element_pt(21)->node_pt(n * np) =
484  this->finite_element_pt(19)->node_pt(np * n + np - 1);
485 
486  // Remove the nodes in element 21 from the temporaray node list
487  delete tmp_node_pt[21 * np * np + n * np];
488  tmp_node_pt[21 * np * np + n * np] = 0;
489  }
490 
491 
492  // Edge between Elements 21 and 22
493  for (unsigned n = 0; n < np; n++)
494  {
495  // Set the nodes in element 22 to be the same as in element 21
496  this->finite_element_pt(22)->node_pt(np * (np - 1) + n) =
497  this->finite_element_pt(21)->node_pt(n);
498 
499  // Remove the nodes in element 22 from the temporaray node list
500  delete tmp_node_pt[22 * np * np + np * (np - 1) + n];
501  tmp_node_pt[22 * np * np + np * (np - 1) + n] = 0;
502  }
503 
504 
505  // Edge between Elements 20 and 23
506  for (unsigned n = 0; n < np; n++)
507  {
508  // Set the nodes in element 23 to be the same as in element 20
509  this->finite_element_pt(23)->node_pt(n * np) =
510  this->finite_element_pt(20)->node_pt(np * n + np - 1);
511 
512  // Remove the nodes in element 23 from the temporaray node list
513  delete tmp_node_pt[23 * np * np + n * np];
514  tmp_node_pt[23 * np * np + n * np] = 0;
515  }
516 
517 
518  // Edge between Elements 23 and 22
519  for (unsigned n = 0; n < np; n++)
520  {
521  // Set the nodes in element 22 to be the same as in element 23
522  this->finite_element_pt(22)->node_pt(n) =
523  this->finite_element_pt(23)->node_pt(np * (np - 1) + n);
524 
525  // Remove the nodes in element 22 from the temporaray node list
526  delete tmp_node_pt[22 * np * np + np * (np - 1) + n];
527  tmp_node_pt[22 * np * np + np * (np - 1) + n] = 0;
528  }
529 
530 
531  // Edge between Elements 21 and 24
532  for (unsigned n = 0; n < np; n++)
533  {
534  // Set the nodes in element 24 to be the same as in element 21
535  this->finite_element_pt(24)->node_pt(n * np) =
536  this->finite_element_pt(21)->node_pt(np * n + np - 1);
537 
538  // Remove the nodes in element 24 from the temporaray node list
539  delete tmp_node_pt[24 * np * np + n * np];
540  tmp_node_pt[24 * np * np + n * np] = 0;
541  }
542 
543 
544  // Edge between Elements 22 and 25
545  for (unsigned n = 0; n < np; n++)
546  {
547  // Set the nodes in element 25 to be the same as in element 22
548  this->finite_element_pt(25)->node_pt(n * np) =
549  this->finite_element_pt(22)->node_pt(np * n + np - 1);
550 
551  // Remove the nodes in element 25 from the temporaray node list
552  delete tmp_node_pt[25 * np * np + n * np];
553  tmp_node_pt[25 * np * np + n * np] = 0;
554  }
555 
556 
557  // Edge between Elements 23 and 26
558  for (unsigned n = 0; n < np; n++)
559  {
560  // Set the nodes in element 26 to be the same as in element 23
561  this->finite_element_pt(26)->node_pt(n * np) =
562  this->finite_element_pt(23)->node_pt(np * n + np - 1);
563 
564  // Remove the nodes in element 26 from the temporaray node list
565  delete tmp_node_pt[26 * np * np + n * np];
566  tmp_node_pt[26 * np * np + n * np] = 0;
567  }
568 
569 
570  // Edge between Elements 24 and 25
571  for (unsigned n = 0; n < np; n++)
572  {
573  // Set the nodes in element 25 to be the same as in element 24
574  this->finite_element_pt(25)->node_pt(np * (np - 1) + n) =
575  this->finite_element_pt(24)->node_pt(n);
576 
577  // Remove the nodes in element 25 from the temporaray node list
578  delete tmp_node_pt[25 * np * np + np * (np - 1) + n];
579  tmp_node_pt[25 * np * np + np * (np - 1) + n] = 0;
580  }
581 
582 
583  // Edge between Elements 25 and 26
584  for (unsigned n = 0; n < np; n++)
585  {
586  // Set the nodes in element 26 to be the same as in element 25
587  this->finite_element_pt(26)->node_pt(np * (np - 1) + n) =
588  this->finite_element_pt(25)->node_pt(n);
589 
590  // Remove the nodes in element 26 from the temporaray node list
591  delete tmp_node_pt[26 * np * np + np * (np - 1) + n];
592  tmp_node_pt[26 * np * np + np * (np - 1) + n] = 0;
593  }
594 
595 
596  // Edge between Element 24 and 27
597  for (unsigned n = 0; n < np; n++)
598  {
599  // Set the nodes in element 27 to be the same as in element 24
600  this->finite_element_pt(27)->node_pt(np * (np - 1) + n) =
601  this->finite_element_pt(24)->node_pt(np * n + np - 1);
602 
603  // Remove the nodes in element 27 from the temporaray node list
604  delete tmp_node_pt[27 * np * np + np * (np - 1) + n];
605  tmp_node_pt[27 * np * np + np * (np - 1) + n] = 0;
606  }
607 
608 
609  // Edge between Elements 25 and 27
610  for (unsigned n = 0; n < np; n++)
611  {
612  // Set the nodes in element 27 to be the same as in element 25
613  this->finite_element_pt(27)->node_pt(n * np) =
614  this->finite_element_pt(25)->node_pt(np * n + np - 1);
615 
616  // Remove the nodes in element 27 from the temporaray node list
617  delete tmp_node_pt[27 * np * np + n * np];
618  tmp_node_pt[27 * np * np + n * np] = 0;
619  }
620 
621 
622  // Edge between Element 26 and 27
623  for (unsigned n = 0; n < np; n++)
624  {
625  // Set the nodes in element 27 to be the same as in element 26
626  this->finite_element_pt(27)->node_pt(n) =
627  this->finite_element_pt(26)->node_pt(np * (np - n - 1) + np - 1);
628 
629  // Remove the nodes in element 27 from the temporaray node list
630  delete tmp_node_pt[27 * np * np + n];
631  tmp_node_pt[27 * np * np + n] = 0;
632  }
633 
634 
635  // Edge between Elements 27 and 28
636  for (unsigned n = 0; n < np; n++)
637  {
638  // Set the nodes in element 28 to be the same as in element 27
639  this->finite_element_pt(28)->node_pt(n * np) =
640  this->finite_element_pt(27)->node_pt(np * n + np - 1);
641 
642  // Remove the nodes in element 28 from the temporaray node list
643  delete tmp_node_pt[28 * np * np + n * np];
644  tmp_node_pt[28 * np * np + n * np] = 0;
645  }
646 
647 
648  // Edge between Elements 28 and 29
649  for (unsigned n = 0; n < np; n++)
650  {
651  // Set the nodes in element 29 to be the same as in element 28
652  this->finite_element_pt(29)->node_pt(n * np) =
653  this->finite_element_pt(28)->node_pt(np * n + np - 1);
654 
655  // Remove the nodes in element 29 from the temporaray node list
656  delete tmp_node_pt[29 * np * np + n * np];
657  tmp_node_pt[29 * np * np + n * np] = 0;
658  }
659 
660 
661  // Edge between Elements 29 and 30
662  for (unsigned n = 0; n < np; n++)
663  {
664  // Set the nodes in element 30 to be the same as in element 29
665  this->finite_element_pt(30)->node_pt(n * np) =
666  this->finite_element_pt(29)->node_pt(np * n + np - 1);
667 
668  // Remove the nodes in element 30 from the temporaray node list
669  delete tmp_node_pt[30 * np * np + n * np];
670  tmp_node_pt[30 * np * np + n * np] = 0;
671  }
672 
673  // Now set the actual true nodes
674  for (unsigned long n = 0; n < node_count; n++)
675  {
676  if (tmp_node_pt[n] != 0)
677  {
678  Node_pt.push_back(tmp_node_pt[n]);
679  }
680  }
681 
682  // Finally set the nodes on the boundaries
683  this->set_nboundary(8);
684 
685  for (unsigned n = 0; n < np; n++)
686  {
687  // Left hand side
688  this->add_boundary_node(3, this->finite_element_pt(0)->node_pt(n * np));
689  // Right hand side
690  this->add_boundary_node(
691  1, this->finite_element_pt(30)->node_pt(n * np + np - 1));
692 
693  // First part of lower boundary
694  this->add_boundary_node(0, this->finite_element_pt(6)->node_pt(n));
695 
696  // First part of upper boundary
697  this->add_boundary_node(
698  2, this->finite_element_pt(1)->node_pt(np * (np - 1) + n));
699 
700  // First part of hole boundary
701  this->add_boundary_node(4, this->finite_element_pt(3)->node_pt(np * n));
702 
703  // First part of lower flag
704  this->add_boundary_node(
705  5, this->finite_element_pt(4)->node_pt(np * (np - 1) + n));
706 
707  // First part of upper flag
708  this->add_boundary_node(6, this->finite_element_pt(3)->node_pt(n));
709 
710  // Right part of flag
711  this->add_boundary_node(7, this->finite_element_pt(22)->node_pt(n * np));
712  }
713 
714  for (unsigned n = 1; n < np; n++)
715  {
716  // Second part of lower boundary
717  this->add_boundary_node(0, this->finite_element_pt(10)->node_pt(n));
718 
719  // Second part of upper boundary
720  this->add_boundary_node(
721  2, this->finite_element_pt(7)->node_pt(np * (np - 1) + n));
722 
723  // Next part of lower flag
724  this->add_boundary_node(
725  5, this->finite_element_pt(9)->node_pt(np * (np - 1) + n));
726 
727  // Next part of upper flag
728  this->add_boundary_node(6, this->finite_element_pt(8)->node_pt(n));
729  }
730 
731  for (unsigned n = np - 2; n > 0; n--)
732  {
733  // Next part of hole
734  this->add_boundary_node(4, this->finite_element_pt(2)->node_pt(n));
735  }
736 
737  for (unsigned n = 1; n < np; n++)
738  {
739  // Next part of lower boundary
740  this->add_boundary_node(0, this->finite_element_pt(14)->node_pt(n));
741 
742  // Next part of upper boundary
743  this->add_boundary_node(
744  2, this->finite_element_pt(11)->node_pt(np * (np - 1) + n));
745 
746  // Next part of lower flag
747  this->add_boundary_node(
748  5, this->finite_element_pt(13)->node_pt(np * (np - 1) + n));
749 
750  // Next part of upper flag
751  this->add_boundary_node(6, this->finite_element_pt(12)->node_pt(n));
752  }
753 
754  for (unsigned n = np - 1; n > 0; n--)
755  {
756  // Next part of hole
757  this->add_boundary_node(4, this->finite_element_pt(1)->node_pt(n));
758  }
759 
760  for (unsigned n = 1; n < np; n++)
761  {
762  // Next part of lower boundary
763  this->add_boundary_node(0, this->finite_element_pt(18)->node_pt(n));
764  // Next part of upper boundary
765  this->add_boundary_node(
766  2, this->finite_element_pt(15)->node_pt(np * (np - 1) + n));
767 
768  // Next part of lower flag
769  this->add_boundary_node(
770  5, this->finite_element_pt(17)->node_pt(np * (np - 1) + n));
771 
772  // Next part of upper flag
773  this->add_boundary_node(6, this->finite_element_pt(16)->node_pt(n));
774  }
775 
776  for (unsigned n = np - 1; n > 0; n--)
777  {
778  // Next part of hole
779  this->add_boundary_node(
780  4, this->finite_element_pt(0)->node_pt(n * np + np - 1));
781  }
782 
783 
784  for (unsigned n = 1; n < np; n++)
785  {
786  // Next part of lower boundary
787  this->add_boundary_node(0, this->finite_element_pt(23)->node_pt(n));
788  // Next part of upper boundary
789  this->add_boundary_node(
790  2, this->finite_element_pt(21)->node_pt(np * (np - 1) + n));
791 
792  // Next part of hole
793  this->add_boundary_node(
794  4, this->finite_element_pt(6)->node_pt(np * (np - 1) + n));
795 
796  // Next part of lower flag
797  this->add_boundary_node(
798  5, this->finite_element_pt(20)->node_pt(np * (np - 1) + n));
799 
800  // Next part of upper flag
801  this->add_boundary_node(6, this->finite_element_pt(19)->node_pt(n));
802  }
803 
804  for (unsigned n = 0; n < np; n++)
805  {
806  // Next part of hole
807  this->add_boundary_node(
808  4, this->finite_element_pt(6)->node_pt(np * (np - 1) + n));
809  }
810 
811 
812  for (unsigned n = 1; n < np; n++)
813  {
814  // Next part of lower boundary
815  this->add_boundary_node(0, this->finite_element_pt(26)->node_pt(n));
816  // Next part of upper boundary
817  this->add_boundary_node(
818  2, this->finite_element_pt(24)->node_pt(np * (np - 1) + n));
819 
820  // Next part of hole
821  this->add_boundary_node(
822  4, this->finite_element_pt(5)->node_pt(np * (np - 1) + n));
823  }
824 
825 
826  for (unsigned n = 1; n < np; n++)
827  {
828  // Next part of lower boundary
829  this->add_boundary_node(0, this->finite_element_pt(28)->node_pt(n));
830  // Next part of upper boundary
831  this->add_boundary_node(
832  2, this->finite_element_pt(28)->node_pt(np * (np - 1) + n));
833 
834  // Next part of hole
835  this->add_boundary_node(4, this->finite_element_pt(4)->node_pt(np * n));
836  }
837 
838  for (unsigned n = 1; n < np; n++)
839  {
840  // Next part of lower boundary
841  this->add_boundary_node(0, this->finite_element_pt(29)->node_pt(n));
842  // Next part of upper boundary
843  this->add_boundary_node(
844  2, this->finite_element_pt(29)->node_pt(np * (np - 1) + n));
845  }
846 
847  for (unsigned n = 1; n < np; n++)
848  {
849  // Next part of lower boundary
850  this->add_boundary_node(0, this->finite_element_pt(30)->node_pt(n));
851  // Next part of upper boundary
852  this->add_boundary_node(
853  2, this->finite_element_pt(30)->node_pt(np * (np - 1) + n));
854  }
855 
856 
857  this->node_update();
858  setup_boundary_element_info();
859 
860  // Set boundary coordinates on the flag
861 
862  // Vector of Lagrangian coordinates used as boundary coordinate
863  Vector<double> zeta(1);
864 
865  // loop on nodes of boundary 5
866  unsigned nnode = this->nboundary_node(5);
867  for (unsigned k = 0; k < nnode; k++)
868  {
869  Node* nod_pt = this->boundary_node_pt(5, k);
870  zeta[0] = double(k) * flag_length / double(nnode - 1);
871  nod_pt->set_coordinates_on_boundary(5, zeta);
872  }
873 
874  // loop on nodes of boundary 6
875  nnode = this->nboundary_node(6);
876  for (unsigned k = 0; k < nnode; k++)
877  {
878  Node* nod_pt = this->boundary_node_pt(6, k);
879  zeta[0] = double(k) * flag_length / double(nnode - 1);
880  nod_pt->set_coordinates_on_boundary(6, zeta);
881  }
882 
883  // loop on nodes of boundary 7
884  nnode = this->nboundary_node(7);
885  for (unsigned k = 0; k < nnode; k++)
886  {
887  Node* nod_pt = this->boundary_node_pt(7, k);
888  zeta[0] = -flag_height / 2. + double(k) / double(nnode - 1) * flag_height;
889  nod_pt->set_coordinates_on_boundary(7, zeta);
890  }
891 
892  // We have parametrised boundary 5,6 and 7
893  this->Boundary_coordinate_exists[5] = true;
894  this->Boundary_coordinate_exists[6] = true;
895  this->Boundary_coordinate_exists[7] = true;
896 
897  // Loop over all elements and set macro element pointer
898  for (unsigned e = 0; e < 31; e++)
899  {
900  dynamic_cast<ELEMENT*>(this->element_pt(e))
901  ->set_macro_elem_pt(this->Domain_pt->macro_element_pt(e));
902  }
903  }
n
const unsigned n
Definition: CG3DPackingUnitTest.cpp:11
e
Array< double, 1, 3 > e(1./3., 0.5, 2.)
oomph::CylinderWithFlagMesh::Domain_pt
CylinderWithFlagDomain * Domain_pt
Pointer to the domain.
Definition: cylinder_with_flag_mesh.template.h:84
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::FiniteElement::construct_boundary_node
virtual Node * construct_boundary_node(const unsigned &n)
Definition: elements.h:2538
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::nboundary_node
unsigned long nboundary_node(const unsigned &ibound) const
Return number of nodes on a particular boundary.
Definition: mesh.h:833
oomph::Mesh::Node_pt
Vector< Node * > Node_pt
Vector of pointers to nodes.
Definition: mesh.h:183
oomph::Mesh::Boundary_coordinate_exists
std::vector< bool > Boundary_coordinate_exists
Definition: mesh.h:190
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::setup_boundary_element_info
virtual void setup_boundary_element_info()
Definition: mesh.h:275
oomph::Mesh::nnode
unsigned long nnode() const
Return number of nodes in the mesh.
Definition: mesh.h:596
oomph::Mesh::node_update
virtual void node_update(const bool &update_all_solid_nodes=false)
Definition: mesh.cc:287
oomph::Mesh::element_pt
const Vector< GeneralisedElement * > & element_pt() const
Return reference to the Vector of elements.
Definition: mesh.h:460
oomph::Mesh::node_pt
Node *& node_pt(const unsigned long &n)
Return pointer to global node n.
Definition: mesh.h:436
oomph::Mesh::boundary_node_pt
Node *& boundary_node_pt(const unsigned &b, const unsigned &n)
Return pointer to node n on boundary b.
Definition: mesh.h:493
oomph::Mesh::Element_pt
Vector< GeneralisedElement * > Element_pt
Vector of pointers to generalised elements.
Definition: mesh.h:186
s
RealScalar s
Definition: level1_cplx_impl.h:130
a
const Scalar * a
Definition: level2_cplx_impl.h:32
k
char char char int int * k
Definition: level2_impl.h:374
Eigen::zeta
EIGEN_STRONG_INLINE const Eigen::CwiseBinaryOp< Eigen::internal::scalar_zeta_op< typename DerivedX::Scalar >, const DerivedX, const DerivedQ > zeta(const Eigen::ArrayBase< DerivedX > &x, const Eigen::ArrayBase< DerivedQ > &q)
Definition: SpecialFunctionsArrayAPI.h:152
Global_Physical_Variables::height
double height(const double &x)
Height of domain.
Definition: simple_spine_channel.cc:429
UniformPSDSelfTest.r
r
Definition: UniformPSDSelfTest.py:20

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

◆ ~CylinderWithFlagMesh()

template<class ELEMENT >
virtual oomph::CylinderWithFlagMesh< ELEMENT >::~CylinderWithFlagMesh ( )
inlinevirtual

Destructor: Kill the domain.

72  {
73  delete Domain_pt;
74  }

References oomph::CylinderWithFlagMesh< ELEMENT >::Domain_pt.

Member Function Documentation

◆ domain_pt()

template<class ELEMENT >
CylinderWithFlagDomain* oomph::CylinderWithFlagMesh< ELEMENT >::domain_pt ( )
inline

Access function to the domain.

78  {
79  return Domain_pt;
80  }

References oomph::CylinderWithFlagMesh< ELEMENT >::Domain_pt.

Referenced by oomph::AlgebraicCylinderWithFlagMesh< ELEMENT >::set_bottom_flag_pt(), oomph::AlgebraicCylinderWithFlagMesh< ELEMENT >::set_tip_flag_pt(), and oomph::AlgebraicCylinderWithFlagMesh< ELEMENT >::set_top_flag_pt().

Member Data Documentation

◆ Domain_pt

template<class ELEMENT >
CylinderWithFlagDomain* oomph::CylinderWithFlagMesh< ELEMENT >::Domain_pt
protected

Pointer to the domain.

Referenced by oomph::CylinderWithFlagMesh< ELEMENT >::domain_pt(), and oomph::CylinderWithFlagMesh< ELEMENT >::~CylinderWithFlagMesh().

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