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