bretherton_spine_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_BRETHERTON_SPINE_MESH_HEADER
31 #define OOMPH_BRETHERTON_SPINE_MESH_HEADER
32 
33 
34 // The mesh
37 
38 namespace oomph
39 {
40 
41 //============================================================================
42 /// Mesh for 2D Bretherton problem -- based on single layer mesh. Templated
43 /// by spine-ified Navier-Stokes element type (e.g.
44 /// SpineElement<QCrouzeixRaviartElement<2> > and the corresponding
45 /// interface element (e.g.
46 /// SpineLineFluidInterfaceElement<SpineElement<QCrouzeixRaviartElement<2> > >
47 ///
48 //============================================================================
49 template <class ELEMENT, class INTERFACE_ELEMENT>
51 {
52 
53 
54 public:
55 
56  /// \short Constructor. Arguments:
57 /// - nx1: Number of elements along wall in deposited film region
58 /// - nx2: Number of elements along wall in horizontal transition region
59 /// - nx3: Number of elements along wall in channel region
60 /// - nhalf: Number of elements in vertical transition region (there are
61 /// twice as many elements across the channel)
62 /// - nh: Number of elements across the deposited film
63 /// - h: Thickness of deposited film
64 /// - zeta0: Start coordinate on wall
65 /// - zeta1: Wall coordinate of start of transition region
66 /// - zeta2: Wall coordinate of end of liquid filled region (inflow)
67 /// - lower_wall_pt: Pointer to geometric object that represents the lower wall
68 /// - upper_wall_pt: Pointer to geometric object that represents the upper wall
69 /// - time_stepper_pt: Pointer to timestepper; defaults to Steady
70  BrethertonSpineMesh(const unsigned &nx1,
71  const unsigned &nx2,
72  const unsigned &nx3,
73  const unsigned &nh,
74  const unsigned &nhalf,
75  const double& h,
76  GeomObject* lower_wall_pt,
77  GeomObject* upper_wall_pt,
78  const double& zeta_start,
79  const double& zeta_transition_start,
80  const double& zeta_transition_end,
81  const double& zeta_end,
82  TimeStepper* time_stepper_pt=
84 
85 
86  /// Access functions for pointers to interface elements
87  FiniteElement* &interface_element_pt(const unsigned long &i)
88  {return Interface_element_pt[i];}
89 
90  /// Number of elements on interface
91  unsigned long ninterface_element() const {return Interface_element_pt.size();}
92 
93  ///Access functions for pointers to elements in bulk
94  FiniteElement* &bulk_element_pt(const unsigned long &i)
95  {return Bulk_element_pt[i];}
96 
97  ///Number of elements in bulk
98  unsigned long nbulk() const {return Bulk_element_pt.size();}
99 
100 
101  /// Number of free-surface spines (i.e. excluding the dummy spines
102  /// in the channel region)
104  {
105  unsigned np=this->finite_element_pt(0)->nnode_1d();
106  return 2*(Nx1+Nx2+Nhalf)*(np-1);
107  }
108 
109 
110  /// Recalculate the spine lengths after repositioning
111  double find_distance_to_free_surface(GeomObject* const &fs_geom_object_pt,
112  Vector<double> &initial_zeta,
113  const Vector<double> &spine_base,
114  const Vector<double> &spine_end);
115 
116  /// Reposition the spines in response to changes in geometry
117  void reposition_spines(const double &zeta_lo_transition_start,
118  const double &zeta_lo_transition_end,
119  const double &zeta_up_transition_start,
120  const double &zeta_up_transition_end);
121 
122  /// Pin all spines so the mesh can be used for computation
123  /// without free surfaces
125  {
126  unsigned n_spine = this->nspine();
127  for (unsigned i=0;i<n_spine;i++)
128  {
129  this->spine_pt(i)->spine_height_pt()->pin(0);
130  }
131  }
132 
133  /// \short General node update function implements pure virtual function
134  /// defined in SpineMesh base class and performs specific update
135  /// actions, depending on the node update fct id stored for each node.
136  void spine_node_update(SpineNode* spine_node_pt)
137  {
138 
139  unsigned id=spine_node_pt->node_update_fct_id();
140  switch(id)
141  {
142  case 0:
143  spine_node_update_film_lower(spine_node_pt);
144  break;
145 
146  case 1:
148  break;
149 
150  case 2:
152  break;
153 
154  case 3:
156  break;
157 
158  case 4:
160  break;
161 
162  case 5:
163  spine_node_update_film_upper(spine_node_pt);
164  break;
165 
166  case 6:
167  spine_node_update_channel(spine_node_pt);
168  break;
169 
170  default:
171  std::ostringstream error_message;
172  error_message << "Incorrect spine update id " << id << std::endl;
173 
174  throw OomphLibError(error_message.str(),
175  OOMPH_CURRENT_FUNCTION,
176  OOMPH_EXCEPTION_LOCATION);
177  }
178  }
179 
180 
181  /// \short Pointer to control element (just under the symmetry line
182  /// near the bubble tip, so the bubble tip is located at
183  /// s=[1.0,1.0] in this element.
185 
186 
187  /// \short Read the value of the spine centre's vertical fraction
188  double spine_centre_fraction() const
189  {return *Spine_centre_fraction_pt;}
190 
191  /// \short Set the pointer to the spine centre's vertial fraction
192  void set_spine_centre_fraction_pt(double* const &fraction_pt)
193  {Spine_centre_fraction_pt = fraction_pt;}
194 
195 protected:
196 
197  /// \short Update function for the deposited film region in the
198  /// lower part of the domain: Vertical spines
200  {
201  //Get fraction along the spine
202  double w = spine_node_pt->fraction();
203  //Get spine height
204  double h = spine_node_pt->h();
205 
206  // Get wall coordinate
207  Vector<double> s_lo(1);
208  s_lo[0] = spine_node_pt->spine_pt()->geom_parameter(0);
209 
210  // Get position vector to wall
211  Vector<double> r_wall_lo(2);
212  spine_node_pt->spine_pt()->geom_object_pt(0)->position(s_lo,r_wall_lo);
213 
214  //Update the nodal position
215  spine_node_pt->x(0) = r_wall_lo[0];
216  spine_node_pt->x(1) = r_wall_lo[1] + w*h;
217  }
218 
219 
220  /// \short Update function for the horizontal transitition region in the
221  /// lower part of the domain: Spine points from wall to origin
223  {
224  //Get fraction along the spine
225  double w = spine_node_pt->fraction();
226  //Get spine height
227  double h = spine_node_pt->h();
228 
229  // Get wall coordinate
230  Vector<double> s_lo(1);
231  s_lo[0] = spine_node_pt->spine_pt()->geom_parameter(0);
232 
233  // Get position vector to wall
234  Vector<double> r_wall_lo(2);
235  spine_node_pt->spine_pt()->geom_object_pt(0)->position(s_lo,r_wall_lo);
236 
237  // Get the spine centre
238  Vector<double> s_transition_lo(1), s_transition_up(1);
239  s_transition_lo[0] = spine_node_pt->spine_pt()->geom_parameter(1);
240  s_transition_up[0] = spine_node_pt->spine_pt()->geom_parameter(2);
241  Vector<double> r_transition_lo(2), r_transition_up(2);
242  spine_node_pt->spine_pt()->geom_object_pt(1)->
243  position(s_transition_lo,r_transition_lo);
244  spine_node_pt->spine_pt()->geom_object_pt(2)->
245  position(s_transition_up,r_transition_up);
246 
247  Vector<double> spine_centre(2);
248  //Horizontal position is always halfway between the walls
249  spine_centre[0] = 0.5*(r_transition_lo[0] + r_transition_up[0]);
250  //Vertical spine centre is given by fraction between the walls
251  spine_centre[1] = r_transition_lo[1] +
252  spine_centre_fraction()*(r_transition_up[1] - r_transition_lo[1]);
253 
254  // Get vector twoards spine origin
255  Vector<double> N(2);
256  N[0] = spine_centre[0] - r_wall_lo[0];
257  N[1] = spine_centre[1] - r_wall_lo[1];
258  double inv_length=1.0/sqrt(N[0]*N[0]+N[1]*N[1]);
259  //Update the nodal position
260  spine_node_pt->x(0) = r_wall_lo[0] + w*h*N[0]*inv_length;
261  spine_node_pt->x(1) = r_wall_lo[1] + w*h*N[1]*inv_length;
262  }
263 
264 
265 
266  /// \short Update function for the vertical transitition region in the
267  /// lower part of the domain: Spine points to origin
269  {
270  //Get fraction along the spine
271  double w = spine_node_pt->fraction();
272  //Get spine height
273  double h = spine_node_pt->h();
274 
275  // Get local coordinates
276  Vector<double> s_lo(1), s_up(1);
277  s_lo[0] = spine_node_pt->spine_pt()->geom_parameter(0);
278  s_up[0] = spine_node_pt->spine_pt()->geom_parameter(1);
279 
280  // Get position vector to wall
281  Vector<double> r_lo(2), r_up(2);
282  spine_node_pt->spine_pt()->geom_object_pt(0)->position(s_lo,r_lo);
283  spine_node_pt->spine_pt()->geom_object_pt(1)->position(s_up,r_up);
284 
285  // Get fraction along vertical line across
286  double vertical_fraction = spine_node_pt->spine_pt()->geom_parameter(2);
287 
288  // Origin of spine
289  Vector<double> S0(2);
290  S0[0] = r_lo[0] + vertical_fraction*(r_up[0]-r_lo[0]);
291  S0[1] = r_lo[1] + vertical_fraction*(r_up[1]-r_lo[1]);
292 
293 
294  // Get the spine centre
295  Vector<double> s_transition_lo(1), s_transition_up(1);
296  s_transition_lo[0] = spine_node_pt->spine_pt()->geom_parameter(3);
297  s_transition_up[0] = spine_node_pt->spine_pt()->geom_parameter(4);
298  Vector<double> r_transition_lo(2), r_transition_up(2);
299  spine_node_pt->spine_pt()->geom_object_pt(2)->
300  position(s_transition_lo,r_transition_lo);
301  spine_node_pt->spine_pt()->geom_object_pt(3)->
302  position(s_transition_up,r_transition_up);
303 
304  Vector<double> spine_centre(2);
305  //Horizontal position is always halfway between the walls
306  spine_centre[0] = 0.5*(r_transition_lo[0] + r_transition_up[0]);
307  //Vertical spine centre is given by fraction between the walls
308  spine_centre[1] = r_transition_lo[1] +
309  spine_centre_fraction()*(r_transition_up[1] - r_transition_lo[1]);
310 
311  // Get vector towards origin
312  Vector<double> N(2);
313  N[0] = spine_centre[0] - S0[0];
314  N[1] = spine_centre[1] - S0[1];
315 
316  double inv_length=1.0/sqrt(N[0]*N[0]+N[1]*N[1]);
317  //Update the nodal position
318  spine_node_pt->x(0) = S0[0] + w*h*N[0]*inv_length;
319  spine_node_pt->x(1) = S0[1] + w*h*N[1]*inv_length;
320  }
321 
322 
323  /// \short Update function for the vertical transitition region in the
324  /// upper part of the domain: Spine points to origin
326  {
327  //Get fraction along the spine
328  double w = spine_node_pt->fraction();
329  //Get spine height
330  double h = spine_node_pt->h();
331 
332  // Get local coordinates
333  Vector<double> s_lo(1), s_up(1);
334  s_lo[0] = spine_node_pt->spine_pt()->geom_parameter(0);
335  s_up[0] = spine_node_pt->spine_pt()->geom_parameter(1);
336 
337  // Get position vector to wall
338  Vector<double> r_lo(2), r_up(2);
339  spine_node_pt->spine_pt()->geom_object_pt(0)->position(s_lo,r_lo);
340  spine_node_pt->spine_pt()->geom_object_pt(1)->position(s_up,r_up);
341 
342  // Get fraction along vertical line across
343  double vertical_fraction = spine_node_pt->spine_pt()->geom_parameter(2);
344 
345  // Origin of spine
346  Vector<double> S0(2);
347  S0[0] = r_lo[0] + vertical_fraction*(r_up[0]-r_lo[0]);
348  S0[1] = r_lo[1] + vertical_fraction*(r_up[1]-r_lo[1]);
349 
350 
351  // Get the spine centre
352  Vector<double> s_transition_lo(1), s_transition_up(1);
353  s_transition_lo[0] = spine_node_pt->spine_pt()->geom_parameter(3);
354  s_transition_up[0] = spine_node_pt->spine_pt()->geom_parameter(4);
355  Vector<double> r_transition_lo(2), r_transition_up(2);
356  spine_node_pt->spine_pt()->geom_object_pt(2)->
357  position(s_transition_lo,r_transition_lo);
358  spine_node_pt->spine_pt()->geom_object_pt(3)->
359  position(s_transition_up,r_transition_up);
360 
361  Vector<double> spine_centre(2);
362  //Horizontal position is always halfway between the walls
363  spine_centre[0] = 0.5*(r_transition_lo[0] + r_transition_up[0]);
364  //Vertical spine centre is given by fraction between the walls
365  spine_centre[1] = r_transition_lo[1] +
366  spine_centre_fraction()*(r_transition_up[1] - r_transition_lo[1]);
367 
368  // Get vector towards origin
369  Vector<double> N(2);
370  N[0] = spine_centre[0] - S0[0];
371  N[1] = spine_centre[1] - S0[1];
372 
373  double inv_length=1.0/sqrt(N[0]*N[0]+N[1]*N[1]);
374  //Update the nodal position
375  spine_node_pt->x(0) = S0[0] + w*h*N[0]*inv_length;
376  spine_node_pt->x(1) = S0[1] + w*h*N[1]*inv_length;
377  }
378 
379 
380 
381  /// \short Update function for the horizontal transitition region in the
382  /// upper part of the domain: Spine points towards origin
384  {
385  //Get fraction along the spine
386  double w = spine_node_pt->fraction();
387  //Get spine height
388  double h = spine_node_pt->h();
389 
390  // Get wall coordinate
391  Vector<double> s_up(1);
392  s_up[0] = spine_node_pt->spine_pt()->geom_parameter(0);
393 
394  // Get position vector to wall
395  Vector<double> r_wall_up(2);
396  spine_node_pt->spine_pt()->geom_object_pt(0)->position(s_up,r_wall_up);
397 
398  // Get the spine centre
399  Vector<double> s_transition_lo(1), s_transition_up(1);
400  s_transition_lo[0] = spine_node_pt->spine_pt()->geom_parameter(1);
401  s_transition_up[0] = spine_node_pt->spine_pt()->geom_parameter(2);
402  Vector<double> r_transition_lo(2), r_transition_up(2);
403  spine_node_pt->spine_pt()->geom_object_pt(1)->
404  position(s_transition_lo,r_transition_lo);
405  spine_node_pt->spine_pt()->geom_object_pt(2)->
406  position(s_transition_up,r_transition_up);
407 
408  Vector<double> spine_centre(2);
409  //Horizontal position is always halfway between the walls
410  spine_centre[0] = 0.5*(r_transition_lo[0] + r_transition_up[0]);
411  //Vertical spine centre is given by fraction between the walls
412  spine_centre[1] = r_transition_lo[1] +
413  spine_centre_fraction()*(r_transition_up[1] - r_transition_lo[1]);
414 
415  // Get vector towards origin
416  Vector<double> N(2);
417  N[0]= spine_centre[0] - r_wall_up[0];
418  N[1]= spine_centre[1] - r_wall_up[1];
419  double inv_length=1.0/sqrt(N[0]*N[0]+N[1]*N[1]);
420 
421  //Update the nodal position
422  spine_node_pt->x(0) = r_wall_up[0] + w*h*N[0]*inv_length;
423  spine_node_pt->x(1) = r_wall_up[1] + w*h*N[1]*inv_length;
424  }
425 
426 
427 
428  /// \short Update function for the deposited film region in the
429  /// upper part of the domain: Vertical spines
431  {
432  //Get fraction along the spine
433  double w = spine_node_pt->fraction();
434  //Get spine height
435  double h = spine_node_pt->h();
436 
437  // Get wall coordinate
438  Vector<double> s_up(1);
439  s_up[0] = spine_node_pt->spine_pt()->geom_parameter(0);
440 
441  // Get position vector to wall
442  Vector<double> r_wall_up(2);
443  spine_node_pt->spine_pt()->geom_object_pt(0)->position(s_up,r_wall_up);
444 
445  //Update the nodal position
446  spine_node_pt->x(0) = r_wall_up[0];
447  spine_node_pt->x(1) = r_wall_up[1] - w*h;
448  }
449 
450 
451  /// \short Update function for the nodes in the channel region ahead
452  /// of the finger tip: Nodes are evenly distributed along vertical
453  /// lines between the top and bottom walls
455  {
456  //Get fraction along the spine
457  double w = spine_node_pt->fraction();
458 
459  // Get upper and lower local coordinates
460  Vector<double> s_lo(1), s_up(1);
461  s_lo[0]=spine_node_pt->spine_pt()->geom_parameter(0);
462  s_up[0]=spine_node_pt->spine_pt()->geom_parameter(1);
463 
464  // Get position vector to lower wall
465  Vector<double> r_lo(2), r_up(2);
466  spine_node_pt->spine_pt()->geom_object_pt(0)->position(s_lo,r_lo);
467  spine_node_pt->spine_pt()->geom_object_pt(1)->position(s_up,r_up);
468 
469  //Update the nodal position
470  spine_node_pt->x(0) = r_lo[0] + w*(r_up[0]-r_lo[0]);
471  spine_node_pt->x(1) = r_lo[1] + w*(r_up[1]-r_lo[1]);
472  }
473 
474 
475 
476  /// \short Initial reordering elements of the elements -- before
477  /// the channel mesh is added. Vertical stacks of elements, each topped by
478  /// their interface element -- this is (currently) identical to the
479  /// version in the SingleLayerSpineMesh but it's important
480  /// that the element reordering is maintained in exactly this form
481  /// for the rest of the mesh generation process to work properly.
482  /// Therefore we keep a copy of the function in here.
484 
485  /// Number of elements along wall in deposited film region
486  unsigned Nx1;
487 
488  /// Number of elements along wall in horizontal transition region
489  unsigned Nx2;
490 
491  /// Number of elements along wall in channel region
492  unsigned Nx3;
493 
494  /// \short Number of elements in vertical transition region (there are
495  /// twice as many elements across the channel)
496  unsigned Nhalf;
497 
498  /// Number of elements across the deposited film
499  unsigned Nh;
500 
501  /// Thickness of deposited film
502  double H;
503 
504  /// Pointer to geometric object that represents the upper wall
506 
507  /// Pointer to geometric object that represents the lower wall
509 
510  /// Start coordinate on wall
511  double Zeta_start;
512 
513  ///Wall coordinate of end of liquid filled region (inflow)
514  double Zeta_end;
515 
516  ///Wall coordinate of start of the transition region
518 
519  /// Wall coordinate of end of transition region
521 
522  /// Pointer to vertical fraction of the spine centre
524 
525  /// Default spine fraction
527 
528  /// \short Pointer to control element (just under the symmetry line
529  /// near the bubble tip; the bubble tip is located at s=[1.0,1.0]
530  /// in this element
532 
533  /// Vector of pointers to element in the fluid layer
535 
536  /// Vector of pointers to interface elements
538 
539 
540 };
541 
542 }
543 
544 #endif
545 
unsigned Nhalf
Number of elements in vertical transition region (there are twice as many elements across the channel...
double Zeta_end
Wall coordinate of end of liquid filled region (inflow)
ELEMENT * Control_element_pt
Pointer to control element (just under the symmetry line near the bubble tip; the bubble tip is locat...
BrethertonSpineMesh(const unsigned &nx1, const unsigned &nx2, const unsigned &nx3, const unsigned &nh, const unsigned &nhalf, const double &h, GeomObject *lower_wall_pt, GeomObject *upper_wall_pt, const double &zeta_start, const double &zeta_transition_start, const double &zeta_transition_end, const double &zeta_end, TimeStepper *time_stepper_pt=&Mesh::Default_TimeStepper)
Constructor. Arguments:
void spine_node_update_film_lower(SpineNode *spine_node_pt)
Update function for the deposited film region in the lower part of the domain: Vertical spines...
double Zeta_transition_end
Wall coordinate of end of transition region.
static Steady< 0 > Default_TimeStepper
Default Steady Timestepper, to be used in default arguments to Mesh constructors. ...
Definition: mesh.h:85
double * Spine_centre_fraction_pt
Pointer to vertical fraction of the spine centre.
cstr elem_len * i
Definition: cfortran.h:607
FiniteElement * finite_element_pt(const unsigned &e) const
Upcast (downcast?) to FiniteElement (needed to access FiniteElement member functions).
Definition: mesh.h:477
double Default_spine_centre_fraction
Default spine fraction.
FiniteElement *& bulk_element_pt(const unsigned long &i)
Access functions for pointers to elements in bulk.
void spine_node_update_vertical_transition_lower(SpineNode *spine_node_pt)
Update function for the vertical transitition region in the lower part of the domain: Spine points to...
double & fraction()
Set reference to fraction along spine.
Definition: spines.h:350
ELEMENT * control_element_pt()
Pointer to control element (just under the symmetry line near the bubble tip, so the bubble tip is lo...
double & geom_parameter(const unsigned &i)
Return i-th geometric parameter that is involved in the node update operations for this Spine...
Definition: spines.h:267
A general Finite Element class.
Definition: elements.h:1271
void spine_node_update(SpineNode *spine_node_pt)
General node update function implements pure virtual function defined in SpineMesh base class and per...
unsigned & node_update_fct_id()
Access function to ID of node update function (within specific mesh)
Definition: spines.h:353
virtual void position(const Vector< double > &zeta, Vector< double > &r) const =0
Parametrised position on object at current time: r(zeta).
double spine_centre_fraction() const
Read the value of the spine centre's vertical fraction.
void reposition_spines(const double &zeta_lo_transition_start, const double &zeta_lo_transition_end, const double &zeta_up_transition_start, const double &zeta_up_transition_end)
Reposition the spines in response to changes in geometry.
virtual unsigned nnode_1d() const
Return the number of nodes along one edge of the element Default is to return zero — must be overload...
Definition: elements.h:2139
void pin(const unsigned &i)
Pin the i-th stored variable.
Definition: nodes.h:383
Spine *& spine_pt(const unsigned long &i)
Return the i-th spine in the mesh.
Definition: spines.h:578
unsigned Nx3
Number of elements along wall in channel region.
void spine_node_update_vertical_transition_upper(SpineNode *spine_node_pt)
Update function for the vertical transitition region in the upper part of the domain: Spine points to...
unsigned Nx1
Number of elements along wall in deposited film region.
double H
Thickness of deposited film.
void spine_node_update_horizontal_transition_lower(SpineNode *spine_node_pt)
Update function for the horizontal transitition region in the lower part of the domain: Spine points ...
double Zeta_transition_start
Wall coordinate of start of the transition region.
double & x(const unsigned &i)
Return the i-th nodal coordinate.
Definition: nodes.h:995
unsigned long ninterface_element() const
Number of elements on interface.
unsigned long nbulk() const
Number of elements in bulk.
unsigned Nh
Number of elements across the deposited film.
unsigned Nx2
Number of elements along wall in horizontal transition region.
unsigned long nspine() const
Return the number of spines in the mesh.
Definition: spines.h:584
void spine_node_update_channel(SpineNode *spine_node_pt)
Update function for the nodes in the channel region ahead of the finger tip: Nodes are evenly distrib...
double Zeta_start
Start coordinate on wall.
void spine_node_update_horizontal_transition_upper(SpineNode *spine_node_pt)
Update function for the horizontal transitition region in the upper part of the domain: Spine points ...
void set_spine_centre_fraction_pt(double *const &fraction_pt)
Set the pointer to the spine centre's vertial fraction.
double & h()
Access function to spine height.
Definition: spines.h:363
GeomObject *& geom_object_pt(const unsigned &i)
Return i-th geometric object that is involved in the node update operations for this Spine...
Definition: spines.h:237
Vector< FiniteElement * > Interface_element_pt
Vector of pointers to interface elements.
FiniteElement *& interface_element_pt(const unsigned long &i)
Access functions for pointers to interface elements.
GeomObject * Upper_wall_pt
Pointer to geometric object that represents the upper wall.
Data *& spine_height_pt()
Access function to Data object that stores the spine height.
Definition: spines.h:164
Spine *& spine_pt()
Access function to spine.
Definition: spines.h:347
Vector< FiniteElement * > Bulk_element_pt
Vector of pointers to element in the fluid layer.
double find_distance_to_free_surface(GeomObject *const &fs_geom_object_pt, Vector< double > &initial_zeta, const Vector< double > &spine_base, const Vector< double > &spine_end)
Recalculate the spine lengths after repositioning.
Base class for time-stepping schemes. Timestepper provides an approximation of the temporal derivativ...
Definition: timesteppers.h:219
GeomObject * Lower_wall_pt
Pointer to geometric object that represents the lower wall.
void initial_element_reorder()
Initial reordering elements of the elements – before the channel mesh is added. Vertical stacks of el...
void spine_node_update_film_upper(SpineNode *spine_node_pt)
Update function for the deposited film region in the upper part of the domain: Vertical spines...