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$
7 //LIC//
8 //LIC// $LastChangedDate$
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
35 #include "single_layer_spine_mesh.template.h"
36 #include "simple_rectangular_quadmesh.template.h"
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>
50 class BrethertonSpineMesh : public SingleLayerSpineMesh<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=
83  &Mesh::Default_TimeStepper);
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)
103  unsigned nfree_surface_spines()
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
124  void pin_all_spines()
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:
147  spine_node_update_horizontal_transition_lower(spine_node_pt);
148  break;
149 
150  case 2:
151  spine_node_update_vertical_transition_lower(spine_node_pt);
152  break;
153 
154  case 3:
155  spine_node_update_vertical_transition_upper(spine_node_pt);
156  break;
157 
158  case 4:
159  spine_node_update_horizontal_transition_upper(spine_node_pt);
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.
184  ELEMENT* control_element_pt(){return Control_element_pt;}
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
199  void spine_node_update_film_lower(SpineNode *spine_node_pt)
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
222  void spine_node_update_horizontal_transition_lower(SpineNode *spine_node_pt)
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
268  void spine_node_update_vertical_transition_lower(SpineNode *spine_node_pt)
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
325  void spine_node_update_vertical_transition_upper(SpineNode *spine_node_pt)
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
383  void spine_node_update_horizontal_transition_upper(SpineNode *spine_node_pt)
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
430  void spine_node_update_film_upper(SpineNode *spine_node_pt)
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
454  void spine_node_update_channel(SpineNode *spine_node_pt)
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.
483  void initial_element_reorder();
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
505  GeomObject* Upper_wall_pt;
506 
507  /// Pointer to geometric object that represents the lower wall
508  GeomObject* Lower_wall_pt;
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
517  double Zeta_transition_start;
518 
519  /// Wall coordinate of end of transition region
520  double Zeta_transition_end;
521 
522  /// Pointer to vertical fraction of the spine centre
523  double *Spine_centre_fraction_pt;
524 
525  /// Default spine fraction
526  double Default_spine_centre_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
531  ELEMENT* Control_element_pt;
532 
533  /// Vector of pointers to element in the fluid layer
534  Vector <FiniteElement *> Bulk_element_pt;
535 
536  /// Vector of pointers to interface elements
537  Vector<FiniteElement *> Interface_element_pt;
538 
539 
540 };
541 
542 }
543 
544 #endif
545 
oomph::BrethertonSpineMesh::Nhalf
unsigned Nhalf
Number of elements in vertical transition region (there are twice as many elements across the channel...
Definition: bretherton_spine_mesh.template.h:496
oomph::BrethertonSpineMesh::Zeta_end
double Zeta_end
Wall coordinate of end of liquid filled region (inflow)
Definition: bretherton_spine_mesh.template.h:514
oomph::BrethertonSpineMesh::Control_element_pt
ELEMENT * Control_element_pt
Pointer to control element (just under the symmetry line near the bubble tip; the bubble tip is locat...
Definition: bretherton_spine_mesh.template.h:531
oomph::BrethertonSpineMesh::BrethertonSpineMesh
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:
Definition: bretherton_spine_mesh.template.cc:62
oomph::BrethertonSpineMesh::spine_node_update_film_lower
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...
Definition: bretherton_spine_mesh.template.h:199
oomph::BrethertonSpineMesh::Zeta_transition_end
double Zeta_transition_end
Wall coordinate of end of transition region.
Definition: bretherton_spine_mesh.template.h:520
oomph::Mesh::Default_TimeStepper
static Steady< 0 > Default_TimeStepper
Default Steady Timestepper, to be used in default arguments to Mesh constructors. ...
Definition: mesh.h:85
oomph::BrethertonSpineMesh::Spine_centre_fraction_pt
double * Spine_centre_fraction_pt
Pointer to vertical fraction of the spine centre.
Definition: bretherton_spine_mesh.template.h:523
i
cstr elem_len * i
Definition: cfortran.h:607
single_layer_spine_mesh.template.h
oomph::BrethertonSpineMesh::Default_spine_centre_fraction
double Default_spine_centre_fraction
Default spine fraction.
Definition: bretherton_spine_mesh.template.h:526
oomph::BrethertonSpineMesh::bulk_element_pt
FiniteElement *& bulk_element_pt(const unsigned long &i)
Access functions for pointers to elements in bulk.
Definition: bretherton_spine_mesh.template.h:94
oomph::BrethertonSpineMesh::spine_node_update_vertical_transition_lower
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...
Definition: bretherton_spine_mesh.template.h:268
oomph::SpineNode::fraction
double & fraction()
Set reference to fraction along spine.
Definition: spines.h:350
oomph::BrethertonSpineMesh::control_element_pt
ELEMENT * control_element_pt()
Pointer to control element (just under the symmetry line near the bubble tip, so the bubble tip is lo...
Definition: bretherton_spine_mesh.template.h:184
oomph::Spine::geom_parameter
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
oomph::FiniteElement
A general Finite Element class.
Definition: elements.h:1274
oomph::BrethertonSpineMesh::spine_node_update
void spine_node_update(SpineNode *spine_node_pt)
General node update function implements pure virtual function defined in SpineMesh base class and per...
Definition: bretherton_spine_mesh.template.h:136
oomph::SpineNode::node_update_fct_id
unsigned & node_update_fct_id()
Access function to ID of node update function (within specific mesh)
Definition: spines.h:353
oomph::GeomObject::position
virtual void position(const Vector< double > &zeta, Vector< double > &r) const =0
Parametrised position on object at current time: r(zeta).
oomph::BrethertonSpineMesh::reposition_spines
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.
Definition: bretherton_spine_mesh.template.cc:1135
oomph::Data::pin
void pin(const unsigned &i)
Pin the i-th stored variable.
Definition: nodes.h:383
oomph::SpineMesh::spine_pt
Spine *& spine_pt(const unsigned long &i)
Return the i-th spine in the mesh.
Definition: spines.h:578
oomph::BrethertonSpineMesh::Nx3
unsigned Nx3
Number of elements along wall in channel region.
Definition: bretherton_spine_mesh.template.h:492
oomph::BrethertonSpineMesh::spine_node_update_vertical_transition_upper
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...
Definition: bretherton_spine_mesh.template.h:325
oomph::BrethertonSpineMesh::Nx1
unsigned Nx1
Number of elements along wall in deposited film region.
Definition: bretherton_spine_mesh.template.h:486
oomph::BrethertonSpineMesh::H
double H
Thickness of deposited film.
Definition: bretherton_spine_mesh.template.h:502
oomph::BrethertonSpineMesh::spine_node_update_horizontal_transition_lower
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 ...
Definition: bretherton_spine_mesh.template.h:222
oomph::BrethertonSpineMesh::Zeta_transition_start
double Zeta_transition_start
Wall coordinate of start of the transition region.
Definition: bretherton_spine_mesh.template.h:517
oomph::BrethertonSpineMesh::nbulk
unsigned long nbulk() const
Number of elements in bulk.
Definition: bretherton_spine_mesh.template.h:98
oomph::Node::x
double & x(const unsigned &i)
Return the i-th nodal coordinate.
Definition: nodes.h:995
simple_rectangular_quadmesh.template.h
oomph::BrethertonSpineMesh::spine_centre_fraction
double spine_centre_fraction() const
Read the value of the spine centre&#39;s vertical fraction.
Definition: bretherton_spine_mesh.template.h:188
oomph::BrethertonSpineMesh::Nh
unsigned Nh
Number of elements across the deposited film.
Definition: bretherton_spine_mesh.template.h:499
oomph::BrethertonSpineMesh::Nx2
unsigned Nx2
Number of elements along wall in horizontal transition region.
Definition: bretherton_spine_mesh.template.h:489
oomph::BrethertonSpineMesh::spine_node_update_channel
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...
Definition: bretherton_spine_mesh.template.h:454
oomph::BrethertonSpineMesh::Zeta_start
double Zeta_start
Start coordinate on wall.
Definition: bretherton_spine_mesh.template.h:511
oomph::BrethertonSpineMesh::spine_node_update_horizontal_transition_upper
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 ...
Definition: bretherton_spine_mesh.template.h:383
oomph::Mesh::finite_element_pt
FiniteElement * finite_element_pt(const unsigned &e) const
Upcast (downcast?) to FiniteElement (needed to access FiniteElement member functions).
Definition: mesh.h:477
oomph::SpineMesh::nspine
unsigned long nspine() const
Return the number of spines in the mesh.
Definition: spines.h:584
oomph::BrethertonSpineMesh::set_spine_centre_fraction_pt
void set_spine_centre_fraction_pt(double *const &fraction_pt)
Set the pointer to the spine centre&#39;s vertial fraction.
Definition: bretherton_spine_mesh.template.h:192
oomph::FiniteElement::nnode_1d
virtual unsigned nnode_1d() const
Return the number of nodes along one edge of the element Default is to return zero — must be overloa...
Definition: elements.h:2151
oomph::BrethertonSpineMesh::ninterface_element
unsigned long ninterface_element() const
Number of elements on interface.
Definition: bretherton_spine_mesh.template.h:91
oomph::SpineNode::h
double & h()
Access function to spine height.
Definition: spines.h:363
oomph::Spine::geom_object_pt
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
oomph::BrethertonSpineMesh::Interface_element_pt
Vector< FiniteElement * > Interface_element_pt
Vector of pointers to interface elements.
Definition: bretherton_spine_mesh.template.h:537
oomph::BrethertonSpineMesh::interface_element_pt
FiniteElement *& interface_element_pt(const unsigned long &i)
Access functions for pointers to interface elements.
Definition: bretherton_spine_mesh.template.h:87
oomph::BrethertonSpineMesh::Upper_wall_pt
GeomObject * Upper_wall_pt
Pointer to geometric object that represents the upper wall.
Definition: bretherton_spine_mesh.template.h:505
oomph::Spine::spine_height_pt
Data *& spine_height_pt()
Access function to Data object that stores the spine height.
Definition: spines.h:164
oomph::SpineNode::spine_pt
Spine *& spine_pt()
Access function to spine.
Definition: spines.h:347
oomph::BrethertonSpineMesh::Bulk_element_pt
Vector< FiniteElement * > Bulk_element_pt
Vector of pointers to element in the fluid layer.
Definition: bretherton_spine_mesh.template.h:534
oomph::BrethertonSpineMesh::find_distance_to_free_surface
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.
Definition: bretherton_spine_mesh.template.cc:1055
oomph::TimeStepper
Base class for time-stepping schemes. Timestepper provides an approximation of the temporal derivativ...
Definition: timesteppers.h:219
oomph::BrethertonSpineMesh::Lower_wall_pt
GeomObject * Lower_wall_pt
Pointer to geometric object that represents the lower wall.
Definition: bretherton_spine_mesh.template.h:508
oomph::BrethertonSpineMesh::initial_element_reorder
void initial_element_reorder()
Initial reordering elements of the elements – before the channel mesh is added. Vertical stacks of e...
Definition: bretherton_spine_mesh.template.cc:1016
oomph::BrethertonSpineMesh::spine_node_update_film_upper
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...
Definition: bretherton_spine_mesh.template.h:430