quarter_circle_sector_mesh.template.h
Go to the documentation of this file.
1// LIC// ====================================================================
2// LIC// This file forms part of oomph-lib, the object-oriented,
3// LIC// multi-physics finite-element library, available
4// LIC// at http://www.oomph-lib.org.
5// LIC//
6// LIC// Copyright (C) 2006-2022 Matthias Heil and Andrew Hazel
7// LIC//
8// LIC// This library is free software; you can redistribute it and/or
9// LIC// modify it under the terms of the GNU Lesser General Public
10// LIC// License as published by the Free Software Foundation; either
11// LIC// version 2.1 of the License, or (at your option) any later version.
12// LIC//
13// LIC// This library is distributed in the hope that it will be useful,
14// LIC// but WITHOUT ANY WARRANTY; without even the implied warranty of
15// LIC// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16// LIC// Lesser General Public License for more details.
17// LIC//
18// LIC// You should have received a copy of the GNU Lesser General Public
19// LIC// License along with this library; if not, write to the Free Software
20// LIC// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
21// LIC// 02110-1301 USA.
22// LIC//
23// LIC// The authors may be contacted at oomph-lib@maths.man.ac.uk.
24// LIC//
25// LIC//====================================================================
26#ifndef OOMPH_QUARTER_CIRCLE_SECTOR_MESH_HEADER
27#define OOMPH_QUARTER_CIRCLE_SECTOR_MESH_HEADER
28
29#include "../generic/refineable_quad_mesh.h"
30#include "../generic/macro_element.h"
31#include "../generic/domain.h"
32#include "../generic/algebraic_elements.h"
33#include "../generic/quad_mesh.h"
34#include "../generic/macro_element_node_update_element.h"
35
36// Include the headers file for domain
38
39
40namespace oomph
41{
42 /// /////////////////////////////////////////////////////////////////
43 /// /////////////////////////////////////////////////////////////////
44 /// /////////////////////////////////////////////////////////////////
45
46
47 class GeomObject;
48
49
50 //====================================================================
51 /// 2D quarter ring mesh class.
52 /// The domain is specified by the GeomObject that identifies boundary 1.
53 ///
54 ///
55 /// \code
56 /// ---___
57 /// | ---____
58 /// | - BOUNDARY 1
59 /// | /
60 /// | [2] / |
61 /// | / |
62 /// | N / |
63 /// | |_ E / |
64 /// BOUNDARY 2 |----------- |
65 /// | | [1] |
66 /// | [0] | | ^
67 /// | | | / \ direction of
68 /// | N | N | | Lagrangian
69 /// | |_ E | |_ E | | coordinate
70 /// |__________|___________| | along wall GeomObject
71 ///
72 /// BOUNDARY 0
73 ///
74 /// Within the elements (MacroElements), the local coordinates
75 /// are such that the (E)astern direction coincides with the positive
76 /// s_0 direction, while the (N)orther direction coincides with the positive
77 /// s_1 direction.
78 ///
79 /// \endcode
80 ///
81 /// Domain is parametrised by three macro elements as sketched.
82 /// Nodal positions are determined via macro-element-based representation
83 /// of the Domain (as a QuarterCircleSectorDomain).
84 //====================================================================
85 template<class ELEMENT>
87 {
88 public:
89 /// Constructor: Pass pointer to geometric object that
90 /// specifies the wall, start and end coordinates on the
91 /// geometric object, and the fraction along
92 /// which the dividing line is to be placed, and the timestepper
93 /// (defaults to (Steady) default timestepper defined in Mesh)
96 const double& xi_lo,
97 const double& fract_mid,
98 const double& xi_hi,
99 TimeStepper* time_stepper_pt = &Mesh::Default_TimeStepper);
100
101 /// Destructor:
103
104 /// Access function to GeomObject representing wall
106 {
107 return Wall_pt;
108 }
109
110 /// Access function to domain
112 {
113 return Domain_pt;
114 }
115
116 /// Function pointer for function that squashes
117 /// the outer two macro elements towards
118 /// the wall by mapping the input value of the "radial" macro element
119 /// coordinate to the return value (defined in the underlying Domain object)
121 {
122 return Domain_pt->bl_squash_fct_pt();
123 }
124
125
126 protected:
127 /// Pointer to Domain
129
130 /// Pointer to the geometric object that represents the curved wall
131 /// (mesh boundary 1)
133
134 /// Lower limit for the (1D) coordinates along the wall
135 double Xi_lo;
136
137 /// Fraction along wall where outer ring is to be divided
138 double Fract_mid;
139
140 /// Upper limit for the (1D) coordinates along the wall
141 double Xi_hi;
142 };
143
144
145 /// /////////////////////////////////////////////////////////////////
146 /// /////////////////////////////////////////////////////////////////
147 /// /////////////////////////////////////////////////////////////////
148
149
150 //====================================================================
151 /// 2D quarter ring mesh class inherited from RefineableQuadMesh.
152 /// The domain is specified by the GeomObject that identifies boundary 1.
153 ///
154 ///
155 /// \code
156 /// ---___
157 /// | ---____
158 /// | - BOUNDARY 1
159 /// | /
160 /// | [2] / |
161 /// | / |
162 /// | N / |
163 /// | |_ E / |
164 /// BOUNDARY 2 |----------- |
165 /// | | [1] |
166 /// | [0] | | ^
167 /// | | | / \ direction of
168 /// | N | N | | Lagrangian
169 /// | |_ E | |_ E | | coordinate
170 /// |__________|___________| | along wall GeomObject
171 ///
172 /// BOUNDARY 0
173 ///
174 /// Within the elements (MacroElements), the local coordinates
175 /// are such that the (E)astern direction coincides with the positive
176 /// s_0 direction, while the (N)orther direction coincides with the positive
177 /// s_1 direction.
178 ///
179 /// \endcode
180 ///
181 /// Domain is parametrised by three macro elements as sketched.
182 ///
183 //====================================================================
184 template<class ELEMENT>
186 : public QuarterCircleSectorMesh<ELEMENT>,
187 public virtual RefineableQuadMesh<ELEMENT>
188 {
189 public:
190 /// Constructor: Pass pointer to geometric object that
191 /// specifies the wall, start and end coordinates on the
192 /// geometric object, and the fraction along
193 /// which the dividing line is to be placed, and the timestepper
194 /// (defaults to (Steady) default timestepper defined in Mesh).
195 /// Adds refinement data to elements of QuarterCircleSectorMesh.
198 const double& xi_lo,
199 const double& fract_mid,
200 const double& xi_hi,
201 TimeStepper* time_stepper_pt = &Mesh::Default_TimeStepper)
202 : QuarterCircleSectorMesh<ELEMENT>(
203 wall_pt, xi_lo, fract_mid, xi_hi, time_stepper_pt)
204 {
205 // Basic mesh has been built -- just need to setup the
206 // adaptivity information:
207
208 // Setup quadtree forest
209 this->setup_quadtree_forest();
210 }
211
212 /// Destructor: Empty
214 };
215
216
217 /// /////////////////////////////////////////////////////////////////
218 /// /////////////////////////////////////////////////////////////////
219 // MacroElementNodeUpdate-version of RefineableQuarterCircleSectorMesh
220 /// /////////////////////////////////////////////////////////////////
221 /// /////////////////////////////////////////////////////////////////
222
223 class MacroElementNodeUpdateNode;
224
225 //========================================================================
226 /// MacroElementNodeUpdate version of RefineableQuarterCircleSectorMesh
227 ///
228 /// \code
229 /// ---___
230 /// | ---____
231 /// | - BOUNDARY 1
232 /// | /
233 /// | [2] / |
234 /// | / |
235 /// | N / |
236 /// | |_ E / |
237 /// BOUNDARY 2 |----------- |
238 /// | | [1] |
239 /// | [0] | | ^
240 /// | | | / \ direction of
241 /// | N | N | | Lagrangian
242 /// | |_ E | |_ E | | coordinate
243 /// |__________|___________| | along wall GeomObject
244 ///
245 /// BOUNDARY 0
246 ///
247 /// Within the elements (MacroElements), the local coordinates
248 /// are such that the (E)astern direction coincides with the positive
249 /// s_0 direction, while the (N)orther direction coincides with the positive
250 /// s_1 direction.
251 ///
252 /// \endcode
253 ///
254 /// Domain is parametrised by three macro elements as sketched. Elements
255 /// need to be derived from MacroElementNodeUpdateElementBase.
256 //========================================================================
257 template<class ELEMENT>
259 : public virtual MacroElementNodeUpdateMesh,
260 public virtual RefineableQuarterCircleSectorMesh<ELEMENT>
261 {
262 public:
263 /// Constructor: Pass pointer to geometric object, start and
264 /// end coordinates on the geometric object and the fraction along
265 /// which the dividing line is to be placed when updating the nodal
266 /// positions, and timestepper (defaults to (Steady) default timestepper
267 /// defined in Mesh). Setup the refineable mesh (by calling the
268 /// constructor for the underlying RefineableQuarterCircleSectorMesh)
269 /// and the algebraic node update functions for nodes.
272 const double& xi_lo,
273 const double& fract_mid,
274 const double& xi_hi,
275 TimeStepper* time_stepper_pt = &Mesh::Default_TimeStepper)
278 wall_pt, xi_lo, fract_mid, xi_hi, time_stepper_pt)
279 {
280#ifdef PARANOID
281 ELEMENT* el_pt = new ELEMENT;
282 if (dynamic_cast<MacroElementNodeUpdateElementBase*>(el_pt) == 0)
283 {
284 std::ostringstream error_message;
285 error_message
286 << "Base class for ELEMENT in "
287 << "MacroElementNodeUpdateRefineableQuarterCircleSectorMesh needs"
288 << "to be of type MacroElementNodeUpdateElement!\n";
289 error_message << "Whereas it is: typeid(el_pt).name()"
290 << typeid(el_pt).name() << std::endl;
291
292 std::string function_name =
293 "MacroElementNodeUpdateRefineableQuaterCircleSectorMesh::\n";
294 function_name +=
295 "MacroElementNodeUpdateRefineableQuaterCircleSectorMesh()";
296
297 throw OomphLibError(error_message.str(),
298 OOMPH_CURRENT_FUNCTION,
299 OOMPH_EXCEPTION_LOCATION);
300 }
301 delete el_pt;
302#endif
303
304 // Setup all the information that's required for MacroElement-based
305 // node update: Tell the elements that their geometry depends on the
306 // fishback geometric object
308 }
309
310 /// Destructor: empty
312
313 /// Resolve mesh update: Update current nodal
314 /// positions via sparse MacroElement-based update.
315 /// [Doesn't make sense to use this mesh with SolidElements anyway,
316 /// so we buffer the case if update_all_solid_nodes is set to
317 /// true.]
318 void node_update(const bool& update_all_solid_nodes = false)
319 {
320#ifdef PARANOID
321 if (update_all_solid_nodes)
322 {
323 std::string error_message =
324 "Doesn't make sense to use an MacroElementNodeUpdateMesh with\n";
325 error_message +=
326 "SolidElements so specifying update_all_solid_nodes=true\n";
327 error_message += "doesn't make sense either\n";
328
329 std::string function_name =
330 "MacroElementNodeUpdateRefineableQuaterCircleSectorMesh::\n";
331 function_name += "node_update()";
332
333 throw OomphLibError(
334 error_message, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
335 }
336#endif
338 }
339
340 private:
341 /// Setup all the information that's required for MacroElement-based
342 /// node update: Tell the elements that their geometry depends on the
343 /// geometric object that parametrises the wall
345 {
346 unsigned n_element = this->nelement();
347 for (unsigned i = 0; i < n_element; i++)
348 {
349 // Upcast from FiniteElement to the present element
350 ELEMENT* el_pt = dynamic_cast<ELEMENT*>(this->element_pt(i));
351
352#ifdef PARANOID
353 // Check if cast is successful
355 dynamic_cast<MacroElementNodeUpdateElementBase*>(el_pt);
356 if (m_el_pt == 0)
357 {
358 std::ostringstream error_message;
359 error_message
360 << "Failed to upcast to MacroElementNodeUpdateElementBase\n";
361 error_message << "Element must be derived from "
362 "MacroElementNodeUpdateElementBase\n";
363 error_message << "but it is of type " << typeid(el_pt).name();
364
365 std::string function_name =
366 "MacroElementNodeUpdateRefineableQuaterCircleSectorMesh::\n";
367 function_name += "setup_macro_element_node_update()";
368
369 throw OomphLibError(error_message.str(),
370 OOMPH_CURRENT_FUNCTION,
371 OOMPH_EXCEPTION_LOCATION);
372 }
373#endif
374 // There's just one GeomObject
375 Vector<GeomObject*> geom_object_pt(1);
376 geom_object_pt[0] = this->Wall_pt;
377
378 // Tell the element which geom objects its macro-element-based
379 // node update depends on
380 el_pt->set_node_update_info(geom_object_pt);
381 }
382
383 // Add the geometric object(s) for the wall to the mesh's storage
384 Vector<GeomObject*> geom_object_pt(1);
385 geom_object_pt[0] = this->Wall_pt;
387
388 // Fill in the domain pointer to the mesh's storage in the base class
390 }
391 };
392
393
394 /// ////////////////////////////////////////////////////////////////////
395 /// ////////////////////////////////////////////////////////////////////
396 // Algebraic-mesh-version of RefineableQuarterCircleSectorMesh
397 /// ////////////////////////////////////////////////////////////////////
398 /// ////////////////////////////////////////////////////////////////////
399
400
401 class AlgebraicNode;
402
403 //========================================================================
404 /// Algebraic version of RefineableQuarterCircleSectorMesh
405 ///
406 /// \code
407 /// ---___
408 /// | ---____
409 /// | - BOUNDARY 1
410 /// | /
411 /// | [2] / |
412 /// | / |
413 /// | N / |
414 /// | |_ E / |
415 /// BOUNDARY 2 |----------- |
416 /// | | [1] |
417 /// | [0] | | ^
418 /// | | | / \ direction of
419 /// | N | N | | Lagrangian
420 /// | |_ E | |_ E | | coordinate
421 /// |__________|___________| | along wall GeomObject
422 ///
423 /// BOUNDARY 0
424 ///
425 /// Within the elements (MacroElements), the local coordinates
426 /// are such that the (E)astern direction coincides with the positive
427 /// s_0 direction, while the (N)orther direction coincides with the positive
428 /// s_1 direction.
429 ///
430 /// \endcode
431 ///
432 /// Domain is parametrised by three macro elements as sketched. Elements
433 /// need to be derived from AlgebraicElementBase. In addition
434 /// to all the refinement procedures available for
435 /// RefineableQuarterCircleSectorMesh which forms the basis for
436 /// this mesh, we implement algebraic node update functions for the nodes.
437 //========================================================================
438 template<class ELEMENT>
440 : public virtual AlgebraicMesh,
442 {
443 public:
444 /// Constructor: Pass pointer to geometric object, start and
445 /// end coordinates on the geometric object and the fraction along
446 /// which the dividing line is to be placed when updating the nodal
447 /// positions, and timestepper (defaults to (Steady) default timestepper
448 /// defined in Mesh). Setup the refineable mesh (by calling the
449 /// constructor for the underlying RefineableQuarterCircleSectorMesh)
450 /// and the algebraic update functions for nodes.
453 const double& xi_lo,
454 const double& fract_mid,
455 const double& xi_hi,
456 TimeStepper* time_stepper_pt = &Mesh::Default_TimeStepper)
458 wall_pt, xi_lo, fract_mid, xi_hi, time_stepper_pt)
459 {
460#ifdef PARANOID
461 ELEMENT* el_pt = new ELEMENT;
462 if (dynamic_cast<AlgebraicElementBase*>(el_pt) == 0)
463 {
464 std::ostringstream error_message;
465
466 error_message << "Base class for ELEMENT in "
467 << "AlgebraicRefineableQuarterCircleSectorMesh needs"
468 << "to be of type AlgebraicElement!\n";
469 error_message << "Whereas it is: typeid(el_pt).name()"
470 << typeid(el_pt).name() << std::endl;
471
472 std::string function_name =
473 " AlgebraicRefineableQuarterCircleSectorMesh::\n";
474 function_name += "AlgebraicRefineableQuarterCircleSectorMesh()";
475
476 throw OomphLibError(error_message.str(),
477 OOMPH_CURRENT_FUNCTION,
478 OOMPH_EXCEPTION_LOCATION);
479 }
480 delete el_pt;
481#endif
482
483 // Add the geometric object to the list associated with this AlgebraicMesh
485
486 // Setup algebraic node update operations
488 }
489
490 /// Run self-test for algebraic mesh -- return 0/1 for OK/failure
491 unsigned self_test()
492 {
494 }
495
496 /// Resolve mesh update: Update current nodal
497 /// positions via algebraic node update.
498 /// [Doesn't make sense to use this mesh with SolidElements anyway,
499 /// so we buffer the case if update_all_solid_nodes is set to
500 /// true.]
501 void node_update(const bool& update_all_solid_nodes = false)
502 {
503#ifdef PARANOID
504 if (update_all_solid_nodes)
505 {
506 std::string error_message =
507 "Doesn't make sense to use an AlgebraicMesh with\n";
508 error_message +=
509 "SolidElements so specifying update_all_solid_nodes=true\n";
510 error_message += "doesn't make sense either\n";
511
512 std::string function_name =
513 " AlgebraicRefineableQuarterCircleSectorMesh::";
514 function_name += "node_update()";
515
516 throw OomphLibError(
517 error_message, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
518 }
519#endif
521 }
522
523
524 /// Implement the algebraic node update function for a node
525 /// at time level t (t=0: present; t>0: previous): Update with
526 /// the node's first (default) update function.
528 {
529 // Update with the update function for the node's first (default)
530 // node update fct
531 unsigned id = node_pt->node_update_fct_id();
532
533 switch (id)
534 {
535 case Central_box:
536
537 // Central box
539 break;
540
541
542 case Lower_right_box:
543
544 // Lower right box
546 break;
547
548 case Upper_left_box:
549
550 // Upper left box
552 break;
553
554 default:
555
556 std::ostringstream error_message;
557 error_message << "The node update fct id is " << id
558 << ", but it should only be one of " << Central_box
559 << ", " << Lower_right_box << " or " << Upper_left_box
560 << std::endl;
561 std::string function_name =
562 " AlgebraicRefineableQuarterCircleSectorMesh::";
563 function_name += "algebraic_node_update()";
564
565 throw OomphLibError(error_message.str(),
566 OOMPH_CURRENT_FUNCTION,
567 OOMPH_EXCEPTION_LOCATION);
568 }
569 }
570
571 /// Update the node update info for specified algebraic node
572 /// following any spatial mesh adaptation.
574 {
575 // Get all node update fct for this node (resizes internally)
576 Vector<int> id;
578
579 // Loop over all update fcts
580 unsigned n_update = id.size();
581 for (unsigned i = 0; i < n_update; i++)
582 {
583 switch (id[i])
584 {
585 case Central_box:
586
587 // Central box: no update
588 break;
589
590
591 case Lower_right_box:
592
593 // Lower right box
595 break;
596
597 case Upper_left_box:
598
599 // Upper left box
601 break;
602
603 default:
604
605 // Never get here....
606 std::ostringstream error_message;
607 error_message << "Node update fct id is " << id[i]
608 << ", but it should only be one of" << Central_box
609 << ", " << Lower_right_box << " or " << Upper_left_box
610 << std::endl;
611
612 std::string function_name =
613 " AlgebraicRefineableQuarterCircleSectorMesh::";
614 function_name += "update_node_update()";
615
616 throw OomphLibError(error_message.str(),
617 OOMPH_CURRENT_FUNCTION,
618 OOMPH_EXCEPTION_LOCATION);
619 }
620 }
621 }
622
623 private:
624 /// Remesh function ids
625 enum
626 {
630 };
631
632
633 /// Fractional width of central box
634 double Lambda_x;
635
636 /// Fractional height of central box
637 double Lambda_y;
638
639 /// Algebraic update function for a node that is located
640 /// in the central box
641 void node_update_in_central_box(const unsigned& t, AlgebraicNode*& node_pt);
642
643 /// Algebraic update function for a node that is located
644 /// in the lower right box
645 void node_update_in_lower_right_box(const unsigned& t,
647
648 /// Algebraic update function for a node that is located
649 /// in the upper left box
650 void node_update_in_upper_left_box(const unsigned& t,
652
653 /// Setup algebraic update operation for all nodes
655
656
657 /// Update algebraic node update function for nodes in
658 /// lower right box
660
661 /// Update algebraic node update function for nodes
662 /// in upper left box
664 };
665
666
667} // namespace oomph
668
669#endif
cstr elem_len * i
Definition: cfortran.h:603
char t
Definition: cfortran.h:568
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
void node_update(const bool &update_all_solid_nodes=false)
Update all nodal positions via algebraic node update functions [Doesn't make sense to use this mesh w...
unsigned self_test()
Self test: check consistentency of multiple node updates.
void add_geom_object_list_pt(GeomObject *geom_object_pt)
Add the specified GeomObject to the list of geometric objects associated with this AlgebraicMesh; rem...
AlgebraicNode * node_pt(const unsigned long &n)
Return a pointer to the n-th global AlgebraicNode.
////////////////////////////////////////////////////////////////////
int node_update_fct_id()
Default (usually first if there are multiple ones) node update fct id.
Algebraic version of RefineableQuarterCircleSectorMesh.
void update_node_update(AlgebraicNode *&node_pt)
Update the node update info for specified algebraic node following any spatial mesh adaptation.
void node_update(const bool &update_all_solid_nodes=false)
Resolve mesh update: Update current nodal positions via algebraic node update. [Doesn't make sense to...
void setup_algebraic_node_update()
Setup algebraic update operation for all nodes.
AlgebraicRefineableQuarterCircleSectorMesh(GeomObject *wall_pt, const double &xi_lo, const double &fract_mid, const double &xi_hi, TimeStepper *time_stepper_pt=&Mesh::Default_TimeStepper)
Constructor: Pass pointer to geometric object, start and end coordinates on the geometric object and ...
unsigned self_test()
Run self-test for algebraic mesh – return 0/1 for OK/failure.
void update_node_update_in_lower_right_box(AlgebraicNode *&node_pt)
Update algebraic node update function for nodes in lower right box.
void node_update_in_central_box(const unsigned &t, AlgebraicNode *&node_pt)
Algebraic update function for a node that is located in the central box.
void node_update_in_lower_right_box(const unsigned &t, AlgebraicNode *&node_pt)
Algebraic update function for a node that is located in the lower right box.
void update_node_update_in_upper_left_box(AlgebraicNode *&node_pt)
Update algebraic node update function for nodes in upper left box.
void algebraic_node_update(const unsigned &t, AlgebraicNode *&node_pt)
Implement the algebraic node update function for a node at time level t (t=0: present; t>0: previous)...
void node_update_in_upper_left_box(const unsigned &t, AlgebraicNode *&node_pt)
Algebraic update function for a node that is located in the upper left box.
/////////////////////////////////////////////////////////////////////
Definition: geom_objects.h:101
////////////////////////////////////////////////////////////////////
MacroElementNodeUpdateMeshes contain MacroElementNodeUpdateNodes which have their own node update fun...
void set_geom_object_vector_pt(Vector< GeomObject * > geom_object_vector_pt)
Set geometric objects associated with MacroElementNodeUpdateMesh; this must also be called from the c...
Domain *& macro_domain_pt()
Broken assignment operator.
void node_update(const bool &update_all_solid_nodes=false)
Update all nodal positions via sparse MacroElement-based update functions. If a Node is hanging its p...
MacroElementNodeUpdate version of RefineableQuarterCircleSectorMesh.
void setup_macro_element_node_update()
Setup all the information that's required for MacroElement-based node update: Tell the elements that ...
void node_update(const bool &update_all_solid_nodes=false)
Resolve mesh update: Update current nodal positions via sparse MacroElement-based update....
MacroElementNodeUpdateRefineableQuarterCircleSectorMesh(GeomObject *wall_pt, const double &xi_lo, const double &fract_mid, const double &xi_hi, TimeStepper *time_stepper_pt=&Mesh::Default_TimeStepper)
Constructor: Pass pointer to geometric object, start and end coordinates on the geometric object and ...
static Steady< 0 > Default_TimeStepper
Default Steady Timestepper, to be used in default arguments to Mesh constructors.
Definition: mesh.h:75
const Vector< GeneralisedElement * > & element_pt() const
Return reference to the Vector of elements.
Definition: mesh.h:460
unsigned long nelement() const
Return number of elements in the mesh.
Definition: mesh.h:590
An OomphLibError object which should be thrown when an run-time error is encountered....
//////////////////////////////////////////////////////////////////// ////////////////////////////////...
Definition: quad_mesh.h:57
Circular sector as domain. Domain is bounded by curved boundary which is represented by a GeomObject....
double(* BLSquashFctPt)(const double &s)
Typedef for function pointer for function that squashes the outer two macro elements towards the wall...
BLSquashFctPt & bl_squash_fct_pt()
Function pointer for function that squashes the outer two macro elements towards the wall by mapping ...
2D quarter ring mesh class. The domain is specified by the GeomObject that identifies boundary 1.
double Fract_mid
Fraction along wall where outer ring is to be divided.
GeomObject *& wall_pt()
Access function to GeomObject representing wall.
double Xi_hi
Upper limit for the (1D) coordinates along the wall.
GeomObject * Wall_pt
Pointer to the geometric object that represents the curved wall (mesh boundary 1)
QuarterCircleSectorMesh(GeomObject *wall_pt, const double &xi_lo, const double &fract_mid, const double &xi_hi, TimeStepper *time_stepper_pt=&Mesh::Default_TimeStepper)
Constructor: Pass pointer to geometric object that specifies the wall, start and end coordinates on t...
QuarterCircleSectorDomain * Domain_pt
Pointer to Domain.
QuarterCircleSectorDomain * domain_pt()
Access function to domain.
double Xi_lo
Lower limit for the (1D) coordinates along the wall.
QuarterCircleSectorDomain::BLSquashFctPt & bl_squash_fct_pt()
Function pointer for function that squashes the outer two macro elements towards the wall by mapping ...
Intermediate mesh class that implements the mesh adaptation functions specified in the TreeBasedRefin...
void setup_quadtree_forest()
Set up QuadTreeForest. Wipes any existing tree structure below the minimum refinement level and regar...
///////////////////////////////////////////////////////////////// ///////////////////////////////////...
RefineableQuarterCircleSectorMesh(GeomObject *wall_pt, const double &xi_lo, const double &fract_mid, const double &xi_hi, TimeStepper *time_stepper_pt=&Mesh::Default_TimeStepper)
Constructor: Pass pointer to geometric object that specifies the wall, start and end coordinates on t...
////////////////////////////////////////////////////////////////////// //////////////////////////////...
Definition: timesteppers.h:231
A slight extension to the standard template vector class so that we can include "graceful" array rang...
Definition: Vector.h:58
std::string string(const unsigned &i)
Return the i-th string or "" if the relevant string hasn't been defined.
//////////////////////////////////////////////////////////////////// ////////////////////////////////...