fish_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: 1104 $
7 //LIC//
8 //LIC// $LastChangedDate: 2016-01-09 08:06:50 +0000 (Sat, 09 Jan 2016) $
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_FISH_MESH_HEADER
31 #define OOMPH_FISH_MESH_HEADER
32 
33 // Headers
34 #include "../generic/refineable_quad_mesh.h"
35 #include "../generic/macro_element.h"
36 #include "../generic/domain.h"
37 #include "../generic/algebraic_elements.h"
38 #include "../generic/quad_mesh.h"
39 #include "../generic/macro_element_node_update_element.h"
40 
41 //Include algebraic elements
42 #include "../generic/algebraic_elements.h"
43 
44 //Include the macro element node update elements
45 #include "../generic/macro_element_node_update_element.h"
46 
47 
48 //Include the headers file for domain
49 #include "fish_domain.h"
50 
51 namespace oomph
52 {
53 
54 //=================================================================
55 /// \short Fish shaped mesh. The geometry is defined by
56 /// the Domain object FishDomain.
57 //=================================================================
58 template<class ELEMENT>
59 class FishMesh : public virtual QuadMeshBase
60 {
61 
62 public:
63 
64 
65  /// \short Constructor: Pass pointer to timestepper
66  /// (defaults to the (Steady) default timestepper defined in Mesh)
68 
69  /// \short Constructor: Pass pointer GeomObject that defines
70  /// the fish's back and pointer to timestepper
71  /// (defaults to the (Steady) default timestepper defined in Mesh)
72  FishMesh(GeomObject* back_pt,
73  TimeStepper* time_stepper_pt=&Mesh::Default_TimeStepper);
74 
75  /// \short Destructor: Kill the geom object that represents the fish's back
76  /// (if necessary)
77  virtual ~FishMesh()
78  {
80  {
81  delete Back_pt;
82  Back_pt=0;
83  }
84  }
85 
86  /// Access function to geom object that represents the fish's back
88  {
89  return Back_pt;
90  }
91 
92 
93  /// Access function to FishDomain
95  {
96  return Domain_pt;
97  }
98 
99 protected:
100 
101  /// Remesh function ids
103 
104  /// \short Build the mesh, using the geometric object identified by Back_pt
105  void build_mesh(TimeStepper* time_stepper_pt);
106 
107  /// Pointer to fish back
109 
110  /// Pointer to domain
112 
113  /// Do I need to kill the fish back geom object?
115 
116 };
117 
118 
119 
120 
121 ///////////////////////////////////////////////////////////////////////
122 ///////////////////////////////////////////////////////////////////////
123 // Refineable fish-shaped mesh
124 ///////////////////////////////////////////////////////////////////////
125 ///////////////////////////////////////////////////////////////////////
126 
127 
128 
129 //=================================================================
130 /// Refineable fish shaped mesh. The geometry is defined by
131 /// the Domain object FishDomain.
132 //=============================start_adaptive_fish_mesh============
133 template<class ELEMENT>
134 class RefineableFishMesh : public virtual FishMesh<ELEMENT>,
135  public RefineableQuadMesh<ELEMENT>
136 {
137 
138 
139 public:
140 
141 
142  /// \short Constructor: Pass pointer to timestepper -- defaults to (Steady)
143  /// default timestepper defined in the Mesh base class
145  FishMesh<ELEMENT>(time_stepper_pt)
146  {
147  // Nodal positions etc. were created in constructor for
148  // FishMesh<...>. Only need to setup adaptive information.
149 
150  // Do what it says....
152 
153  } // end of constructor
154 
155 
156  /// \short Constructor: Pass pointer GeomObject that defines
157  /// the fish's back and pointer to timestepper
158  /// (defaults to (Steady) default timestepper defined in Mesh)
160  TimeStepper* time_stepper_pt=&Mesh::Default_TimeStepper)
161  : FishMesh<ELEMENT>(back_pt,time_stepper_pt)
162  {
163  // Nodal positions etc. were created in constructor for
164  // FishMesh<...>. Only need to setup adaptive information.
165 
166  // Do what it says....
168  }
169 
170  /// \short Destructor: Empty -- all cleanup gets handled in the base
171  /// classes
172  virtual ~RefineableFishMesh() {}
173 
174 
175 protected:
176 
177  ///\short Setup all the information that's required for spatial adaptivity:
178  /// Set pointers to macro elements and build quadtree forest.
179  /// (contained in separate function as this functionality is common
180  /// to both constructors),
181  void setup_adaptivity();
182 
183 }; // end adaptive fish mesh
184 
185 
186 
187 ////////////////////////////////////////////////////////////////////
188 ////////////////////////////////////////////////////////////////////
189 // MacroElementNodeUpdate-version of RefineableFishMesh
190 ////////////////////////////////////////////////////////////////////
191 ////////////////////////////////////////////////////////////////////
192 
193 // Forward declaration
194 class MacroElementNodeUpdateNode;
195 
196 
197 //========================================================================
198 /// Refineable fish shaped mesh with MacroElement-based node update.
199 /// The fish's back is represented by a specified geometric object.
200 /// Some or all of the geometric Data in that geometric object
201 /// may contain unknowns in the global Problem. The dependency
202 /// on these unknowns is taken into account when setting up
203 /// the Jacobian matrix of the elements. For this purpose,
204 /// the element (whose type is specified by the template parameter)
205 /// must inherit from MacroElementNodeUpdateElementBase.
206 //========================================================================
207 template<class ELEMENT>
209 public virtual MacroElementNodeUpdateMesh,
210 public virtual RefineableFishMesh<ELEMENT>
211 {
212 
213 public:
214 
215  /// \short Constructor: Pass pointer GeomObject that defines
216  /// the fish's back and pointer to timestepper
217  /// (defaults to (Steady) default timestepper defined in Mesh).
219  TimeStepper* time_stepper_pt=&Mesh::Default_TimeStepper) :
220  FishMesh<ELEMENT>(back_pt,time_stepper_pt),
221  RefineableFishMesh<ELEMENT>(time_stepper_pt)
222  {
223 #ifdef PARANOID
224  ELEMENT* el_pt=new ELEMENT;
225  if (dynamic_cast<MacroElementNodeUpdateElementBase*>(el_pt)==0)
226  {
227  std::ostringstream error_message;
228  error_message
229  << "Base class for ELEMENT in "
230  << "MacroElementNodeUpdateRefineableFishMesh needs"
231  << "to be of type MacroElementNodeUpdateElement!\n";
232  error_message << "Whereas it is: typeid(el_pt).name()"
233  << typeid(el_pt).name()
234  << std::endl;
235 
236  std::string function_name =
237  "MacroElementNodeUpdateRefineableFishMesh::\n";
238  function_name +=
239  "MacroElementNodeUpdateRefineableFishMesh()";
240 
241  throw OomphLibError(error_message.str(),
242  OOMPH_CURRENT_FUNCTION,
243  OOMPH_EXCEPTION_LOCATION);
244  }
245  delete el_pt;
246 #endif
247 
248 
249  // Setup all the information that's required for MacroElement-based
250  // node update: Tell the elements that their geometry depends on the
251  // fishback geometric object
252  unsigned n_element = this->nelement();
253  for(unsigned i=0;i<n_element;i++)
254  {
255  // Upcast from FiniteElement to the present element
256  ELEMENT *el_pt = dynamic_cast<ELEMENT*>(this->element_pt(i));
257 
258 #ifdef PARANOID
259  // Check if cast is successful
260  MacroElementNodeUpdateElementBase* m_el_pt=dynamic_cast<
262  if (m_el_pt==0)
263  {
264  std::ostringstream error_message;
265  error_message
266  << "Failed to upcast to MacroElementNodeUpdateElementBase\n";
267  error_message
268  << "Element must be derived from MacroElementNodeUpdateElementBase\n";
269  error_message << "but it is of type " << typeid(el_pt).name();
270 
271  std::string function_name =
272  "MacroElementNodeUpdateRefineableFishMesh::\n";
273  function_name += "MacroElementNodeUpdateRefinableFishMesh()";
274 
275  throw OomphLibError(error_message.str(),
276  OOMPH_CURRENT_FUNCTION,
277  OOMPH_EXCEPTION_LOCATION);
278  }
279 #endif
280  // There's just one GeomObject
281  Vector<GeomObject*> geom_object_pt(1);
282  geom_object_pt[0] = this->Back_pt;
283 
284  // Tell the element which geom objects its macro-element-based
285  // node update depends on
286  el_pt->set_node_update_info(geom_object_pt);
287  }
288 
289  // Add the geometric object(s) for the wall to the mesh's storage
290  Vector<GeomObject*> geom_object_pt(1);
291  geom_object_pt[0] = this->Back_pt;
293 
294  // Fill in the domain pointer to the mesh's storage in the base class
296 
297  }
298 
299  /// \short Destructor: empty
301 
302  /// \short Resolve mesh update: NodeUpdate current nodal
303  /// positions via sparse MacroElement-based update.
304  /// [Doesn't make sense to use this mesh with SolidElements anyway,
305  /// so we buffer the case if update_all_solid_nodes is set to
306  /// true.]
307  void node_update(const bool& update_all_solid_nodes=false)
308  {
309 #ifdef PARANOID
310  if (update_all_solid_nodes)
311  {
312  std::string error_message =
313  "Doesn't make sense to use an MacroElementNodeUpdateMesh with\n";
314  error_message +=
315  "SolidElements so specifying update_all_solid_nodes=true\n";
316  error_message += "doesn't make sense either\n";
317 
318  std::string function_name =
319  "MacroElementNodeUpdateRefineableFishMesh::";
320  function_name += "node_update()";
321 
322  throw OomphLibError(error_message,
323  OOMPH_CURRENT_FUNCTION,
324  OOMPH_EXCEPTION_LOCATION);
325  }
326 #endif
328  }
329 
330 };
331 
332 
333 
334 
335 
336 
337 ///////////////////////////////////////////////////////////////////////
338 ///////////////////////////////////////////////////////////////////////
339 // AlgebraicElement fish-shaped mesh
340 ///////////////////////////////////////////////////////////////////////
341 ///////////////////////////////////////////////////////////////////////
342 
343 
344 
345 //=================================================================
346 /// \short Fish shaped mesh with algebraic node update function for nodes.
347 //=================================================================
348 template<class ELEMENT>
350  public virtual FishMesh<ELEMENT>
351 {
352 
353 public:
354 
355  /// \short Constructor: Pass pointer to timestepper.
356  /// (defaults to (Steady) default timestepper defined in Mesh)
358  FishMesh<ELEMENT>(time_stepper_pt)
359  {
360  // Setup algebraic node update operations
362  }
363 
364  /// \short Constructor: Pass pointer GeomObject that defines
365  /// the fish's back and pointer to timestepper
366  /// (defaults to (Steady) default timestepper defined in Mesh).
368  TimeStepper* time_stepper_pt=&Mesh::Default_TimeStepper) :
369  FishMesh<ELEMENT>(back_pt,time_stepper_pt)
370  {
371  // Add the geometric object to the list associated with this AlgebraicMesh
373 
374  // Setup algebraic node update operations
376  }
377 
378  /// \short Destructor: empty
379  virtual ~AlgebraicFishMesh(){}
380 
381  /// \short Update nodal position at time level t (t=0: present;
382  /// t>0: previous)
383  void algebraic_node_update(const unsigned& t, AlgebraicNode*& node_pt)
384  {
385  // Update with the update function for the node's first (default)
386  // node update fct
387  unsigned id=node_pt->node_update_fct_id();
388 
389  // Upper/lower body
390  if ((id==this->Lower_body)||(id==this->Upper_body))
391  {
392  node_update_in_body(t,node_pt);
393  }
394  // Upper/lower fin
395  else if ((id==this->Lower_fin)||(id==this->Upper_fin))
396  {
397  node_update_in_fin(t,node_pt);
398  }
399  else
400  {
401  std::ostringstream error_message;
402  error_message << "The node update fct id is "
403  << id << ", but it should only be one of "
404  << this->Lower_body << ", "
405  << this->Upper_body << ", "
406  << this->Lower_fin << " or "
407  << this->Upper_fin << std::endl;
408  std::string function_name = "AlgebraicFishMesh::algebraic_node_update()";
409 
410  throw OomphLibError(error_message.str(),
411  OOMPH_CURRENT_FUNCTION,
412  OOMPH_EXCEPTION_LOCATION);
413  }
414  }
415 
416  /// \short Resolve the node update function (we neither want the broken empty
417  /// one in the Mesh base class nor the macro-element-based one
418  /// in the RefineableQuadMesh base class but the AlgebraicElement one).
419  /// [It doesn't make sense to use this mesh with SolidElements
420  /// so we buffer the case if update_all_solid_nodes is set to
421  /// true.]
422  virtual void node_update(const bool& update_all_solid_nodes=false)
423  {
424 #ifdef PARANOID
425  if (update_all_solid_nodes)
426  {
427  std::string error_message =
428  "Doesn't make sense to use an AlgebraicMesh with\n";
429  error_message +=
430  "SolidElements so specifying update_all_solid_nodes=true\n";
431  error_message += "doesn't make sense either\n";
432 
433  std::string function_name =
434  "AlgebraicFishMesh::node_update()";
435 
436  throw OomphLibError(error_message,
437  OOMPH_CURRENT_FUNCTION,
438  OOMPH_EXCEPTION_LOCATION);
439  }
440 #endif
442  }
443 
444  /// \short Update the geometric references that are used
445  /// to update node after mesh adaptation.
446  /// We're assuming that the GeomObject that specifies
447  /// the fish back does not have sub-objects, therefore
448  /// no update is required -- all reference
449  /// values can simply be scaled. We simply
450  /// paranoid-check that this is actually the case,
451  /// by checking if locate_zeta() returns the
452  /// original data.
454  {
455 #ifdef PARANOID
456 
457  // Get the start and end Lagrangian coordinates on the
458  // wall from the domain:
459 
460  /// Start coordinate on wall (near nose)
461  double xi_nose=this->Domain_pt->xi_nose();
462 
463  /// End coordinate on wall (near tail)
464  double xi_tail=this->Domain_pt->xi_tail();
465 
466  /// Check halfway along the object
467  Vector<double> zeta(1);
468  zeta[0]=0.5*(xi_nose+xi_tail);
469 
470  Vector<double> s(1);
471  GeomObject* geom_obj_pt=0;
472  this->Back_pt->locate_zeta(zeta,geom_obj_pt,s);
473 
474  if ((geom_obj_pt!=this->Back_pt)||(s[0]!=zeta[0]))
475  {
476  std::ostringstream error_message;
477  error_message
478  << "AlgebraicFishMesh only works with GeomObjects\n"
479  << "that do not contain sub-elements (e.g. GeomObjects\n"
480  << "that represent a wall finite element mesh!\n"
481  << "Back_pt : " << this->Back_pt << std::endl
482  << "geom_obj_pt: " << geom_obj_pt << std::endl
483  << "s[0] : " << s[0] << std::endl
484  << "zeta[0] : " << zeta[0] << std::endl;
485 
486  throw OomphLibError(error_message.str(),
487  OOMPH_CURRENT_FUNCTION,
488  OOMPH_EXCEPTION_LOCATION);
489  }
490 #endif
491  }
492 
493 
494 protected:
495 
496  /// \short Algebraic update function for nodes in upper/lower body
497  void node_update_in_body(const unsigned& t, AlgebraicNode*& node_pt);
498 
499  /// \short Algebraic update function for nodes in upper/lower fin
500  void node_update_in_fin(const unsigned& t, AlgebraicNode*& node_pt);
501 
502  /// \short Setup algebraic update operation for all nodes
503  /// (separate function because this task needs to be performed by
504  /// both constructors)
506 
507 };
508 
509 
510 
511 ///////////////////////////////////////////////////////////////////////
512 ///////////////////////////////////////////////////////////////////////
513 // Refineable algebraic element fish-shaped mesh
514 ///////////////////////////////////////////////////////////////////////
515 ///////////////////////////////////////////////////////////////////////
516 
517 
518 
519 //=================================================================
520 /// \short Refineable fish shaped mesh with algebraic node update function.
521 //=================================================================
522 template<class ELEMENT>
524  public RefineableFishMesh<ELEMENT>
525 {
526 
527 
528 public:
529 
530 
531  /// Constructor: Pass pointer to timestepper.
532  /// (defaults to (Steady) default timestepper defined in Mesh)
533  // Note: FishMesh is virtual base and its constructor is automatically
534  // called first! --> this is where we need to build the mesh;
535  // the constructors of the derived meshes don't call the
536  // base constructor again and simply add the extra functionality.
539  FishMesh<ELEMENT>(time_stepper_pt),
540  AlgebraicFishMesh<ELEMENT>(time_stepper_pt),
541  RefineableFishMesh<ELEMENT>(time_stepper_pt)
542  {}
543 
544 
545 
546  /// \short Constructor: Pass pointer GeomObject that defines
547  /// the fish's back and pointer to timestepper.
548  /// (defaults to (Steady) default timestepper defined in Mesh)
549  // Note: FishMesh is virtual base and its constructor is automatically
550  // called first! --> this is where we need to build the mesh;
551  // the constructors of the derived meshes don't call the
552  // base constructor again and simply add the extra functionality.
554  TimeStepper* time_stepper_pt=
556  FishMesh<ELEMENT>(back_pt,time_stepper_pt),
557  AlgebraicFishMesh<ELEMENT>(back_pt,time_stepper_pt),
558  RefineableFishMesh<ELEMENT>(back_pt,time_stepper_pt)
559  {}
560 
561 
562  /// \short Destructor: empty
564 
565  /// \short Resolve node update function: Use the one defined
566  /// in the AlgebraicFishMesh (where the bool flag is explained)
567  void node_update(const bool& update_all_solid_nodes=false)
568  {
569  AlgebraicFishMesh<ELEMENT>::node_update(update_all_solid_nodes);
570  }
571 
572 };
573 
574 }
575 
576 #endif
AlgebraicNode * node_pt(const unsigned long &n)
Return a pointer to the n-th global AlgebraicNode.
GeomObject * Back_pt
Pointer to fish back.
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...
RefineableFishMesh(TimeStepper *time_stepper_pt=&Mesh::Default_TimeStepper)
Constructor: Pass pointer to timestepper – defaults to (Steady) default timestepper defined in the Me...
static Steady< 0 > Default_TimeStepper
Default Steady Timestepper, to be used in default arguments to Mesh constructors. ...
Definition: mesh.h:85
Fish shaped mesh with algebraic node update function for nodes.
AlgebraicFishMesh(TimeStepper *time_stepper_pt=&Mesh::Default_TimeStepper)
Constructor: Pass pointer to timestepper. (defaults to (Steady) default timestepper defined in Mesh) ...
cstr elem_len * i
Definition: cfortran.h:607
Fish shaped mesh. The geometry is defined by the Domain object FishDomain.
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
RefineableFishMesh(GeomObject *back_pt, TimeStepper *time_stepper_pt=&Mesh::Default_TimeStepper)
Constructor: Pass pointer GeomObject that defines the fish's back and pointer to timestepper (default...
virtual ~AlgebraicRefineableFishMesh()
Destructor: empty.
void build_mesh(TimeStepper *time_stepper_pt)
Build the mesh, using the geometric object identified by Back_pt.
virtual ~MacroElementNodeUpdateRefineableFishMesh()
Destructor: empty.
int node_update_fct_id()
Default (usually first if there are multiple ones) node update fct id.
bool Must_kill_fish_back
Do I need to kill the fish back geom object?
unsigned long nelement() const
Return number of elements in the mesh.
Definition: mesh.h:587
double & xi_tail()
End coordinate on wall (near tail)
Definition: fish_domain.h:114
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...
void node_update(const bool &update_all_solid_nodes=false)
Resolve node update function: Use the one defined in the AlgebraicFishMesh (where the bool flag is ex...
virtual void node_update(const bool &update_all_solid_nodes=false)
Resolve the node update function (we neither want the broken empty one in the Mesh base class nor the...
static char t char * s
Definition: cfortran.h:572
AlgebraicRefineableFishMesh(GeomObject *back_pt, TimeStepper *time_stepper_pt=&Mesh::Default_TimeStepper)
Constructor: Pass pointer GeomObject that defines the fish's back and pointer to timestepper. (defaults to (Steady) default timestepper defined in Mesh)
Domain *& macro_domain_pt()
Broken assignment operator.
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: NodeUpdate current nodal positions via sparse MacroElement-based update...
void node_update_in_body(const unsigned &t, AlgebraicNode *&node_pt)
Algebraic update function for nodes in upper/lower body.
void update_node_update(AlgebraicNode *&node_pt)
Update the geometric references that are used to update node after mesh adaptation. We're assuming that the GeomObject that specifies the fish back does not have sub-objects, therefore no update is required – all reference values can simply be scaled. We simply paranoid-check that this is actually the case, by checking if locate_zeta() returns the original data.
virtual ~FishMesh()
Destructor: Kill the geom object that represents the fish's back (if necessary)
virtual ~RefineableFishMesh()
Destructor: Empty – all cleanup gets handled in the base classes.
FishDomain * Domain_pt
Pointer to domain.
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 setup_adaptivity()
Setup all the information that's required for spatial adaptivity: Set pointers to macro elements and ...
std::string string(const unsigned &i)
Return the i-th string or "" if the relevant string hasn't been defined.
GeomObject *& fish_back_pt()
Access function to geom object that represents the fish's back.
Fish shaped domain, represented by four MacroElements. Shape is parametrised by GeomObject that repre...
Definition: fish_domain.h:49
void setup_algebraic_node_update()
Setup algebraic update operation for all nodes (separate function because this task needs to be perfo...
AlgebraicRefineableFishMesh(TimeStepper *time_stepper_pt=&Mesh::Default_TimeStepper)
virtual ~AlgebraicFishMesh()
Destructor: empty.
FishDomain *& domain_pt()
Access function to FishDomain.
Refineable fish shaped mesh with algebraic node update function.
AlgebraicFishMesh(GeomObject *back_pt, TimeStepper *time_stepper_pt=&Mesh::Default_TimeStepper)
Constructor: Pass pointer GeomObject that defines the fish's back and pointer to timestepper (default...
FishMesh(TimeStepper *time_stepper_pt=&Mesh::Default_TimeStepper)
Constructor: Pass pointer to timestepper (defaults to the (Steady) default timestepper defined in Mes...
virtual void locate_zeta(const Vector< double > &zeta, GeomObject *&sub_geom_object_pt, Vector< double > &s, const bool &use_coordinate_as_initial_guess=false)
A geometric object may be composed of may sub-objects (e.g. a finite-element representation of a boun...
Definition: geom_objects.h:352
void node_update_in_fin(const unsigned &t, AlgebraicNode *&node_pt)
Algebraic update function for nodes in upper/lower fin.
MacroElementNodeUpdateRefineableFishMesh(GeomObject *back_pt, TimeStepper *time_stepper_pt=&Mesh::Default_TimeStepper)
Constructor: Pass pointer GeomObject that defines the fish's back and pointer to timestepper (default...
void algebraic_node_update(const unsigned &t, AlgebraicNode *&node_pt)
Update nodal position at time level t (t=0: present; t>0: previous)
Base class for time-stepping schemes. Timestepper provides an approximation of the temporal derivativ...
Definition: timesteppers.h:219
double & xi_nose()
Start coordinate on wall (near nose)
Definition: fish_domain.h:111