Public Member Functions | Protected Member Functions | Protected Attributes | List of all members
oomph::AlgebraicChannelWithLeafletMesh< ELEMENT > Class Template Reference

#include <channel_with_leaflet_mesh.template.h>

+ Inheritance diagram for oomph::AlgebraicChannelWithLeafletMesh< ELEMENT >:

Public Member Functions

 AlgebraicChannelWithLeafletMesh (GeomObject *leaflet_pt, const double &lleft, const double &lright, const double &hleaflet, const double &htot, const unsigned &nleft, const unsigned &nright, const unsigned &ny1, const unsigned &ny2, TimeStepper *time_stepper_pt=&Mesh::Default_TimeStepper)
 
virtual ~AlgebraicChannelWithLeafletMesh ()
 Destructor: empty. More...
 
void update_node_update (AlgebraicNode *&node_pt)
 
void algebraic_node_update (const unsigned &t, AlgebraicNode *&node_pt)
 Perform algebraic node update. More...
 
- Public Member Functions inherited from oomph::AlgebraicMesh
 AlgebraicMesh ()
 
 AlgebraicMesh (const AlgebraicMesh &)=delete
 Broken copy constructor. More...
 
 ~AlgebraicMesh ()
 Broken assignment operator. More...
 
AlgebraicNode * node_pt (const unsigned long &n)
 Return a pointer to the n-th global AlgebraicNode. More...
 
void node_update (const bool &update_all_solid_nodes=false)
 
unsigned self_test ()
 Self test: check consistentency of multiple node updates. More...
 
void add_geom_object_list_pt (GeomObject *geom_object_pt)
 
unsigned ngeom_object_list_pt ()
 Return number of geometric objects associated with AlgebraicMesh. More...
 
GeomObject * geom_object_list_pt (const unsigned &i)
 Access function to the ith GeomObject. More...
 
- Public Member Functions inherited from oomph::Mesh
 Mesh ()
 Default constructor. More...
 
 Mesh (const Vector< Mesh * > &sub_mesh_pt)
 
void merge_meshes (const Vector< Mesh * > &sub_mesh_pt)
 
virtual void reset_boundary_element_info (Vector< unsigned > &ntmp_boundary_elements, Vector< Vector< unsigned >> &ntmp_boundary_elements_in_region, Vector< FiniteElement * > &deleted_elements)
 Virtual function to perform the reset boundary elements info rutines. More...
 
template<class BULK_ELEMENT >
void doc_boundary_coordinates (const unsigned &b, std::ofstream &the_file)
 
virtual void scale_mesh (const double &factor)
 
 Mesh (const Mesh &dummy)=delete
 Broken copy constructor. More...
 
void operator= (const Mesh &)=delete
 Broken assignment operator. More...
 
virtual ~Mesh ()
 Virtual Destructor to clean up all memory. More...
 
void flush_element_and_node_storage ()
 
void flush_element_storage ()
 
void flush_node_storage ()
 
Node *& node_pt (const unsigned long &n)
 Return pointer to global node n. More...
 
Node * node_pt (const unsigned long &n) const
 Return pointer to global node n (const version) More...
 
GeneralisedElement *& element_pt (const unsigned long &e)
 Return pointer to element e. More...
 
GeneralisedElement * element_pt (const unsigned long &e) const
 Return pointer to element e (const version) More...
 
const Vector< GeneralisedElement * > & element_pt () const
 Return reference to the Vector of elements. More...
 
Vector< GeneralisedElement * > & element_pt ()
 Return reference to the Vector of elements. More...
 
FiniteElement * finite_element_pt (const unsigned &e) const
 
Node *& boundary_node_pt (const unsigned &b, const unsigned &n)
 Return pointer to node n on boundary b. More...
 
Node * boundary_node_pt (const unsigned &b, const unsigned &n) const
 Return pointer to node n on boundary b. More...
 
void set_nboundary (const unsigned &nbound)
 Set the number of boundaries in the mesh. More...
 
void remove_boundary_nodes ()
 Clear all pointers to boundary nodes. More...
 
void remove_boundary_nodes (const unsigned &b)
 
void remove_boundary_node (const unsigned &b, Node *const &node_pt)
 Remove a node from the boundary b. More...
 
void add_boundary_node (const unsigned &b, Node *const &node_pt)
 Add a (pointer to) a node to the b-th boundary. More...
 
void copy_boundary_node_data_from_nodes ()
 
bool boundary_coordinate_exists (const unsigned &i) const
 Indicate whether the i-th boundary has an intrinsic coordinate. More...
 
unsigned long nelement () const
 Return number of elements in the mesh. More...
 
unsigned long nnode () const
 Return number of nodes in the mesh. More...
 
unsigned ndof_types () const
 Return number of dof types in mesh. More...
 
unsigned elemental_dimension () const
 Return number of elemental dimension in mesh. More...
 
unsigned nodal_dimension () const
 Return number of nodal dimension in mesh. More...
 
void add_node_pt (Node *const &node_pt)
 Add a (pointer to a) node to the mesh. More...
 
void add_element_pt (GeneralisedElement *const &element_pt)
 Add a (pointer to) an element to the mesh. More...
 
virtual void reorder_nodes (const bool &use_old_ordering=true)
 
virtual void get_node_reordering (Vector< Node * > &reordering, const bool &use_old_ordering=true) const
 
template<class BULK_ELEMENT , template< class > class FACE_ELEMENT>
void build_face_mesh (const unsigned &b, Mesh *const &face_mesh_pt)
 
unsigned self_test ()
 Self-test: Check elements and nodes. Return 0 for OK. More...
 
void max_and_min_element_size (double &max_size, double &min_size)
 
double total_size ()
 
void check_inverted_elements (bool &mesh_has_inverted_elements, std::ofstream &inverted_element_file)
 
void check_inverted_elements (bool &mesh_has_inverted_elements)
 
unsigned check_for_repeated_nodes (const double &epsilon=1.0e-12)
 
Vector< Node * > prune_dead_nodes ()
 
unsigned nboundary () const
 Return number of boundaries. More...
 
unsigned long nboundary_node (const unsigned &ibound) const
 Return number of nodes on a particular boundary. More...
 
FiniteElement * boundary_element_pt (const unsigned &b, const unsigned &e) const
 Return pointer to e-th finite element on boundary b. More...
 
Node * get_some_non_boundary_node () const
 
unsigned nboundary_element (const unsigned &b) const
 Return number of finite elements that are adjacent to boundary b. More...
 
int face_index_at_boundary (const unsigned &b, const unsigned &e) const
 
virtual void dump (std::ofstream &dump_file, const bool &use_old_ordering=true) const
 Dump the data in the mesh into a file for restart. More...
 
void dump (const std::string &dump_file_name, const bool &use_old_ordering=true) const
 Dump the data in the mesh into a file for restart. More...
 
virtual void read (std::ifstream &restart_file)
 Read solution from restart file. More...
 
void output_paraview (std::ofstream &file_out, const unsigned &nplot) const
 
void output_fct_paraview (std::ofstream &file_out, const unsigned &nplot, FiniteElement::SteadyExactSolutionFctPt exact_soln_pt) const
 
void output_fct_paraview (std::ofstream &file_out, const unsigned &nplot, const double &time, FiniteElement::UnsteadyExactSolutionFctPt exact_soln_pt) const
 
void output (std::ostream &outfile)
 Output for all elements. More...
 
void output (std::ostream &outfile, const unsigned &n_plot)
 Output at f(n_plot) points in each element. More...
 
void output (FILE *file_pt)
 Output for all elements (C-style output) More...
 
void output (FILE *file_pt, const unsigned &nplot)
 Output at f(n_plot) points in each element (C-style output) More...
 
void output (const std::string &output_filename)
 Output for all elements. More...
 
void output (const std::string &output_filename, const unsigned &n_plot)
 Output at f(n_plot) points in each element. More...
 
void output_fct (std::ostream &outfile, const unsigned &n_plot, FiniteElement::SteadyExactSolutionFctPt)
 Output a given Vector function at f(n_plot) points in each element. More...
 
void output_fct (std::ostream &outfile, const unsigned &n_plot, const double &time, FiniteElement::UnsteadyExactSolutionFctPt)
 
void output_boundaries (std::ostream &outfile)
 Output the nodes on the boundaries (into separate tecplot zones) More...
 
void output_boundaries (const std::string &output_filename)
 
void assign_initial_values_impulsive ()
 Assign initial values for an impulsive start. More...
 
void shift_time_values ()
 
void calculate_predictions ()
 
void set_nodal_and_elemental_time_stepper (TimeStepper *const &time_stepper_pt, const bool &preserve_existing_data)
 
virtual void set_mesh_level_time_stepper (TimeStepper *const &time_stepper_pt, const bool &preserve_existing_data)
 
void set_consistent_pinned_values_for_continuation (ContinuationStorageScheme *const &continuation_stepper_pt)
 Set consistent values for pinned data in continuation. More...
 
bool does_pointer_correspond_to_mesh_data (double *const &parameter_pt)
 Does the double pointer correspond to any mesh data. More...
 
void set_nodal_time_stepper (TimeStepper *const &time_stepper_pt, const bool &preserve_existing_data)
 Set the timestepper associated with the nodal data in the mesh. More...
 
void set_elemental_internal_time_stepper (TimeStepper *const &time_stepper_pt, const bool &preserve_existing_data)
 
virtual void compute_norm (double &norm)
 
virtual void compute_norm (Vector< double > &norm)
 
virtual void compute_error (std::ostream &outfile, FiniteElement::UnsteadyExactSolutionFctPt exact_soln_pt, const double &time, double &error, double &norm)
 
virtual void compute_error (std::ostream &outfile, FiniteElement::SteadyExactSolutionFctPt exact_soln_pt, double &error, double &norm)
 
virtual void compute_error (FiniteElement::SteadyExactSolutionFctPt exact_soln_pt, double &error, double &norm)
 
virtual void compute_error (FiniteElement::SteadyExactSolutionFctPt exact_soln_pt, Vector< double > &error, Vector< double > &norm)
 
virtual void compute_error (std::ostream &outfile, FiniteElement::UnsteadyExactSolutionFctPt exact_soln_pt, const double &time, Vector< double > &error, Vector< double > &norm)
 
virtual void compute_error (std::ostream &outfile, FiniteElement::SteadyExactSolutionFctPt exact_soln_pt, Vector< double > &error, Vector< double > &norm)
 
virtual void compute_error (FiniteElement::UnsteadyExactSolutionFctPt exact_soln_pt, const double &time, double &error, double &norm)
 Returns the norm of the error and that of the exact solution. More...
 
virtual void compute_error (FiniteElement::UnsteadyExactSolutionFctPt exact_soln_pt, const double &time, Vector< double > &error, Vector< double > &norm)
 
bool is_mesh_distributed () const
 Boolean to indicate if Mesh has been distributed. More...
 
OomphCommunicator * communicator_pt () const
 
void delete_all_external_storage ()
 Wipe the storage for all externally-based elements. More...
 
- Public Member Functions inherited from oomph::ChannelWithLeafletMesh< ELEMENT >
 ChannelWithLeafletMesh (GeomObject *leaflet_pt, const double &lleft, const double &lright, const double &hleaflet, const double &htot, const unsigned &nleft, const unsigned &nright, const unsigned &ny1, const unsigned &ny2, TimeStepper *time_stepper_pt=&Mesh::Default_TimeStepper)
 
virtual ~ChannelWithLeafletMesh ()
 Destructor : empty. More...
 
ChannelWithLeafletDomain * domain_pt ()
 Access function to domain. More...
 
- Public Member Functions inherited from oomph::SimpleRectangularQuadMesh< ELEMENT >
 SimpleRectangularQuadMesh (const unsigned &Nx, const unsigned &Ny, const double &Lx, const double &Ly, TimeStepper *time_stepper_pt=&Mesh::Default_TimeStepper)
 
const unsigned & nx () const
 Access function for number of elements in x directions. More...
 
const unsigned & ny () const
 Access function for number of elements in y directions. More...
 
- Public Member Functions inherited from oomph::QuadMeshBase
 QuadMeshBase ()
 Constructor (empty) More...
 
 QuadMeshBase (const QuadMeshBase &node)=delete
 Broken copy constructor. More...
 
void operator= (const QuadMeshBase &)=delete
 Broken assignment operator. More...
 
virtual ~QuadMeshBase ()
 Destructor (empty) More...
 
void setup_boundary_element_info ()
 
void setup_boundary_element_info (std::ostream &outfile)
 

Protected Member Functions

void setup_algebraic_node_update ()
 Function to setup the algebraic node update. More...
 
void node_update_I (const unsigned &t, AlgebraicNode *&node_pt)
 Update function for nodes in lower left region (I) More...
 
void node_update_II (const unsigned &t, AlgebraicNode *&node_pt)
 Update function for nodes in lower right region (II) More...
 
void node_update_III (const unsigned &t, AlgebraicNode *&node_pt)
 Update function for nodes in upper left region (III) More...
 
void node_update_IV (const unsigned &t, AlgebraicNode *&node_pt)
 Update function for nodes in upper right region (IV) More...
 
void slanted_bound_up (const unsigned &t, const Vector< double > &zeta, Vector< double > &r)
 Helper function. More...
 
- Protected Member Functions inherited from oomph::Mesh
unsigned long assign_global_eqn_numbers (Vector< double * > &Dof_pt)
 Assign (global) equation numbers to the nodes. More...
 
void describe_dofs (std::ostream &out, const std::string &current_string) const
 
void describe_local_dofs (std::ostream &out, const std::string &current_string) const
 
void assign_local_eqn_numbers (const bool &store_local_dof_pt)
 Assign local equation numbers in all elements. More...
 
void convert_to_boundary_node (Node *&node_pt, const Vector< FiniteElement * > &finite_element_pt)
 
void convert_to_boundary_node (Node *&node_pt)
 

Protected Attributes

double X_0
 
double Hleaflet
 
- Protected Attributes inherited from oomph::Mesh
Vector< Vector< Node * > > Boundary_node_pt
 
bool Lookup_for_elements_next_boundary_is_setup
 
Vector< Vector< FiniteElement * > > Boundary_element_pt
 
Vector< Vector< int > > Face_index_at_boundary
 
Vector< Node * > Node_pt
 Vector of pointers to nodes. More...
 
Vector< GeneralisedElement * > Element_pt
 Vector of pointers to generalised elements. More...
 
std::vector< bool > Boundary_coordinate_exists
 
- Protected Attributes inherited from oomph::ChannelWithLeafletMesh< ELEMENT >
ChannelWithLeafletDomain * Domain_pt
 Pointer to domain. More...
 
GeomObject * Leaflet_pt
 Pointer to GeomObject that represents the leaflet. More...
 

Additional Inherited Members

- Public Types inherited from oomph::Mesh
typedef void(FiniteElement::* SteadyExactSolutionFctPt) (const Vector< double > &x, Vector< double > &soln)
 
typedef void(FiniteElement::* UnsteadyExactSolutionFctPt) (const double &time, const Vector< double > &x, Vector< double > &soln)
 
- Static Public Attributes inherited from oomph::Mesh
static Steady< 0 > Default_TimeStepper
 The Steady Timestepper. More...
 
static bool Suppress_warning_about_empty_mesh_level_time_stepper_function
 Static boolean flag to control warning about mesh level timesteppers. More...
 

Detailed Description

template<class ELEMENT>
class oomph::AlgebraicChannelWithLeafletMesh< ELEMENT >

//////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// Algebraic version of ChannelWithLeafletMesh. Leaflet is assumed to be in its undeformed (straight vertical) position when the algebraic node update is set up.

Constructor & Destructor Documentation

◆ AlgebraicChannelWithLeafletMesh()

template<class ELEMENT >
oomph::AlgebraicChannelWithLeafletMesh< ELEMENT >::AlgebraicChannelWithLeafletMesh ( GeomObject *  leaflet_pt,
const double &  lleft,
const double &  lright,
const double &  hleaflet,
const double &  htot,
const unsigned &  nleft,
const unsigned &  nright,
const unsigned &  ny1,
const unsigned &  ny2,
TimeStepper *  time_stepper_pt = &Mesh::Default_TimeStepper 
)
inline

Constructor: Pass pointer to GeomObject that represents the leaflet, the length of the domain to left and right of the leaflet, the height of the leaflet and the overall height of the channel, the number of element columns to the left and right of the leaflet, the number of rows of elements from the bottom of the channel to the end of the leaflet, the number of rows of elements above the end of the leaflet. Timestepper defaults to Steady default Timestepper defined in the Mesh base class

385  : ChannelWithLeafletMesh<ELEMENT>(leaflet_pt,
386  lleft,
387  lright,
388  hleaflet,
389  htot,
390  nleft,
391  nright,
392  ny1,
393  ny2,
394  time_stepper_pt)
395  {
396  // Store origin of leaflet for fast reference
397  Vector<double> zeta(1);
398  zeta[0] = 0.0;
399  Vector<double> r(2);
400  this->Leaflet_pt->position(zeta, r);
401  X_0 = r[0];
402 
403  // Store length of the leaflet for fast access (it's also available
404  // through the domain, of course)
405  Hleaflet = hleaflet;
406 
407  // Add the geometric object to the list associated with this AlgebraicMesh
408  AlgebraicMesh::add_geom_object_list_pt(leaflet_pt);
409 
410  // Setup algebraic node update operations
411  setup_algebraic_node_update();
412  }
oomph::AlgebraicChannelWithLeafletMesh::setup_algebraic_node_update
void setup_algebraic_node_update()
Function to setup the algebraic node update.
Definition: channel_with_leaflet_mesh.template.cc:242
oomph::AlgebraicChannelWithLeafletMesh::X_0
double X_0
Definition: channel_with_leaflet_mesh.template.h:452
oomph::AlgebraicChannelWithLeafletMesh::Hleaflet
double Hleaflet
Definition: channel_with_leaflet_mesh.template.h:457
oomph::AlgebraicMesh::add_geom_object_list_pt
void add_geom_object_list_pt(GeomObject *geom_object_pt)
Definition: algebraic_elements.h:823
oomph::ChannelWithLeafletMesh::Leaflet_pt
GeomObject * Leaflet_pt
Pointer to GeomObject that represents the leaflet.
Definition: channel_with_leaflet_mesh.template.h:92
oomph::GeomObject::position
virtual void position(const Vector< double > &zeta, Vector< double > &r) const =0
Parametrised position on object at current time: r(zeta).
Eigen::zeta
EIGEN_STRONG_INLINE const Eigen::CwiseBinaryOp< Eigen::internal::scalar_zeta_op< typename DerivedX::Scalar >, const DerivedX, const DerivedQ > zeta(const Eigen::ArrayBase< DerivedX > &x, const Eigen::ArrayBase< DerivedQ > &q)
Definition: SpecialFunctionsArrayAPI.h:152
UniformPSDSelfTest.r
r
Definition: UniformPSDSelfTest.py:20

References oomph::AlgebraicMesh::add_geom_object_list_pt(), oomph::AlgebraicChannelWithLeafletMesh< ELEMENT >::Hleaflet, oomph::ChannelWithLeafletMesh< ELEMENT >::Leaflet_pt, oomph::GeomObject::position(), UniformPSDSelfTest::r, oomph::AlgebraicChannelWithLeafletMesh< ELEMENT >::setup_algebraic_node_update(), oomph::AlgebraicChannelWithLeafletMesh< ELEMENT >::X_0, and Eigen::zeta().

◆ ~AlgebraicChannelWithLeafletMesh()

template<class ELEMENT >
virtual oomph::AlgebraicChannelWithLeafletMesh< ELEMENT >::~AlgebraicChannelWithLeafletMesh ( )
inlinevirtual

Destructor: empty.

416 {}

Member Function Documentation

◆ algebraic_node_update()

template<class ELEMENT >
void oomph::AlgebraicChannelWithLeafletMesh< ELEMENT >::algebraic_node_update ( const unsigned &  t,
AlgebraicNode *&  node_pt 
)
virtual

Perform algebraic node update.

Update nodal position at time level t (t=0: present; t>0: previous)

Implements oomph::AlgebraicMesh.

414  {
415  unsigned id = node_pt->node_update_fct_id();
416 
417  switch (id)
418  {
419  case 1:
420  node_update_I(t, node_pt);
421  break;
422 
423  case 2:
424  node_update_II(t, node_pt);
425  break;
426 
427  case 3:
428  node_update_III(t, node_pt);
429  break;
430 
431  case 4:
432  node_update_IV(t, node_pt);
433  break;
434 
435  default:
436  std::ostringstream error_message;
437  error_message << "The node update fct id is " << id
438  << ", but it should only be one of " << 1 << ", " << 2
439  << ", " << 3 << " or " << 4 << std::endl;
440  std::string function_name =
441  "AlgebraicChannelWithLeafletMesh::algebraic_node_update()";
442 
443  throw OomphLibError(error_message.str(),
444  OOMPH_CURRENT_FUNCTION,
445  OOMPH_EXCEPTION_LOCATION);
446  }
447 
448  } // end of algebraic_node_update()
oomph::AlgebraicChannelWithLeafletMesh::node_update_I
void node_update_I(const unsigned &t, AlgebraicNode *&node_pt)
Update function for nodes in lower left region (I)
Definition: channel_with_leaflet_mesh.template.cc:455
oomph::AlgebraicChannelWithLeafletMesh::node_update_III
void node_update_III(const unsigned &t, AlgebraicNode *&node_pt)
Update function for nodes in upper left region (III)
Definition: channel_with_leaflet_mesh.template.cc:564
oomph::AlgebraicChannelWithLeafletMesh::node_update_II
void node_update_II(const unsigned &t, AlgebraicNode *&node_pt)
Update function for nodes in lower right region (II)
Definition: channel_with_leaflet_mesh.template.cc:500
oomph::AlgebraicChannelWithLeafletMesh::node_update_IV
void node_update_IV(const unsigned &t, AlgebraicNode *&node_pt)
Update function for nodes in upper right region (IV)
Definition: channel_with_leaflet_mesh.template.cc:598
oomph::AlgebraicMesh::node_pt
AlgebraicNode * node_pt(const unsigned long &n)
Return a pointer to the n-th global AlgebraicNode.
Definition: algebraic_elements.h:620
oomph::AlgebraicNode::node_update_fct_id
int node_update_fct_id()
Default (usually first if there are multiple ones) node update fct id.
Definition: algebraic_elements.h:146
oomph::Global_string_for_annotation::string
std::string string(const unsigned &i)
Definition: oomph_definitions.cc:286
plotPSD.t
t
Definition: plotPSD.py:36
OOMPH_EXCEPTION_LOCATION
#define OOMPH_EXCEPTION_LOCATION
Definition: oomph_definitions.h:61
OOMPH_CURRENT_FUNCTION
#define OOMPH_CURRENT_FUNCTION
Definition: oomph_definitions.h:86

References oomph::AlgebraicNode::node_update_fct_id(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::Global_string_for_annotation::string(), and plotPSD::t.

◆ node_update_I()

template<class ELEMENT >
void oomph::AlgebraicChannelWithLeafletMesh< ELEMENT >::node_update_I ( const unsigned &  t,
AlgebraicNode *&  node_pt 
)
protected

Update function for nodes in lower left region (I)

Node update for region I.

457  {
458  // relevant data of the domain for part I
459  double lleft = this->domain_pt()->lleft();
460 
461  // Extract reference values for update by copy construction
462  Vector<double> ref_value(node_pt->vector_ref_value());
463 
464  // Extract geometric objects for update by copy construction
465  Vector<GeomObject*> geom_object_pt(node_pt->vector_geom_object_pt());
466 
467  // Pointer to wall geom object
468  GeomObject* leaflet_pt = geom_object_pt[0];
469 
470  // Coordinates of the steady node on the left boundary
471  // corresponding to the current node
472  double y0 = ref_value[0];
473  double x0 = -lleft + X_0;
474 
475  // second reference value: local coordinate on wall
476  Vector<double> s(1);
477  s[0] = ref_value[1];
478 
479 
480  // Get position vector to wall at timestep t
481  Vector<double> r_wall(2);
482  leaflet_pt->position(t, s, r_wall);
483 
484 
485  // Third reference value : fraction of the horizontal line
486  // between the edge and the wall
487  double r = ref_value[2];
488 
489 
490  // Assign new nodal coordinates
491  node_pt->x(t, 0) = x0 + r * (r_wall[0] - x0);
492  node_pt->x(t, 1) = y0 + r * (r_wall[1] - y0);
493  }
oomph::AlgebraicNode::vector_geom_object_pt
Vector< GeomObject * > & vector_geom_object_pt(const int &id)
Definition: algebraic_elements.h:200
oomph::AlgebraicNode::vector_ref_value
Vector< double > & vector_ref_value()
Definition: algebraic_elements.h:251
oomph::ChannelWithLeafletDomain::lleft
double lleft()
Length of domain to the left of leaflet.
Definition: channel_with_leaflet_domain.h:107
oomph::ChannelWithLeafletMesh::domain_pt
ChannelWithLeafletDomain * domain_pt()
Access function to domain.
Definition: channel_with_leaflet_mesh.template.h:82
oomph::Node::x
double & x(const unsigned &i)
Return the i-th nodal coordinate.
Definition: nodes.h:1060
s
RealScalar s
Definition: level1_cplx_impl.h:130
Global::x0
Vector< double > x0(2, 0.0)

References oomph::GeomObject::position(), UniformPSDSelfTest::r, s, plotPSD::t, oomph::AlgebraicNode::vector_geom_object_pt(), oomph::AlgebraicNode::vector_ref_value(), oomph::Node::x(), Global::x0, and TanhSolnForPoisson::X_0.

◆ node_update_II()

template<class ELEMENT >
void oomph::AlgebraicChannelWithLeafletMesh< ELEMENT >::node_update_II ( const unsigned &  t,
AlgebraicNode *&  node_pt 
)
protected

Update function for nodes in lower right region (II)

Node update for region II.

502  {
503  // relevant data of the domain for part II
504  double lright = this->domain_pt()->lright();
505 
506  // Extract reference values for update by copy construction
507  Vector<double> ref_value(node_pt->vector_ref_value());
508 
509  // Extract geometric objects for update by copy construction
510  Vector<GeomObject*> geom_object_pt(node_pt->vector_geom_object_pt());
511 
512  // Pointer to wall geom object
513  GeomObject* leaflet_pt = geom_object_pt[0];
514 
515  // Coordinates of the steady node on the right boundary
516  // corresponding to the current node
517  double y0 = ref_value[0];
518  double x0 = X_0 + lright;
519 
520  // Second reference value: Zeta coordinate on wall
521  Vector<double> s(1);
522  s[0] = ref_value[1];
523 
524  // Get position vector to wall at timestep t
525  Vector<double> r_wall(2);
526  leaflet_pt->position(t, s, r_wall);
527 
528  // Third reference value : fraction of the horizontal line
529  // between the wall and the right edge
530  double r = ref_value[2];
531 
532  // Assign new nodal coordinates
533  node_pt->x(t, 0) = r_wall[0] + r * (x0 - r_wall[0]);
534  node_pt->x(t, 1) = r_wall[1] + r * (y0 - r_wall[1]);
535  }
oomph::ChannelWithLeafletDomain::lright
double lright()
Length of domain to the right of leaflet.
Definition: channel_with_leaflet_domain.h:113

References oomph::GeomObject::position(), UniformPSDSelfTest::r, s, plotPSD::t, oomph::AlgebraicNode::vector_geom_object_pt(), oomph::AlgebraicNode::vector_ref_value(), oomph::Node::x(), Global::x0, and TanhSolnForPoisson::X_0.

◆ node_update_III()

template<class ELEMENT >
void oomph::AlgebraicChannelWithLeafletMesh< ELEMENT >::node_update_III ( const unsigned &  t,
AlgebraicNode *&  node_pt 
)
protected

Update function for nodes in upper left region (III)

Node update for region III.

566  {
567  // relevant data of the domain for part I
568  double lleft = this->domain_pt()->lleft();
569 
570  // Extract reference values for update by copy construction
571  Vector<double> ref_value(node_pt->vector_ref_value());
572 
573  // Coordinates of the steady node on the left boundary
574  // corresponding to the current node
575  double y0 = ref_value[0];
576  double x0 = -lleft + X_0;
577 
578  Vector<double> s(1);
579  s[0] = ref_value[1];
580 
581  // Get position vector
582  Vector<double> r_line(2);
583  slanted_bound_up(t, s, r_line);
584 
585  // Third reference value : fraction of the horizontal line
586  // between the edge and the middle line
587  double r = ref_value[2];
588 
589  // Assign new nodal coordinates
590  node_pt->x(t, 0) = x0 + r * (r_line[0] - x0);
591  node_pt->x(t, 1) = y0 + r * (r_line[1] - y0);
592  }
oomph::AlgebraicChannelWithLeafletMesh::slanted_bound_up
void slanted_bound_up(const unsigned &t, const Vector< double > &zeta, Vector< double > &r)
Helper function.
Definition: channel_with_leaflet_mesh.template.cc:542

References UniformPSDSelfTest::r, s, plotPSD::t, oomph::AlgebraicNode::vector_ref_value(), oomph::Node::x(), Global::x0, and TanhSolnForPoisson::X_0.

◆ node_update_IV()

template<class ELEMENT >
void oomph::AlgebraicChannelWithLeafletMesh< ELEMENT >::node_update_IV ( const unsigned &  t,
AlgebraicNode *&  node_pt 
)
protected

Update function for nodes in upper right region (IV)

Node update for region IV.

600  {
601  // relevant data of the domain for part I
602  double lright = this->domain_pt()->lright();
603 
604  // Extract reference values for update by copy construction
605  Vector<double> ref_value(node_pt->vector_ref_value());
606 
607  // Coordinates of the steady node on the left boundary
608  // corresponding to the current node
609  double y0 = ref_value[0];
610  double x0 = X_0 + lright;
611 
612  // Second reference value: Zeta coordinate on the middle line
613  Vector<double> s(1);
614  s[0] = ref_value[1];
615 
616  // Get position vector at timestep t
617  Vector<double> r_line(2);
618  slanted_bound_up(t, s, r_line);
619 
620  // Third reference value : fraction of the horizontal line
621  // between the middle line and the right edge
622  double r = ref_value[2];
623 
624  // Assign new nodal coordinates
625  node_pt->x(t, 0) = r_line[0] + r * (x0 - r_line[0]);
626  node_pt->x(t, 1) = r_line[1] + r * (y0 - r_line[1]);
627  }

References UniformPSDSelfTest::r, s, plotPSD::t, oomph::AlgebraicNode::vector_ref_value(), oomph::Node::x(), Global::x0, and TanhSolnForPoisson::X_0.

◆ setup_algebraic_node_update()

template<class ELEMENT >
void oomph::AlgebraicChannelWithLeafletMesh< ELEMENT >::setup_algebraic_node_update
protected

Function to setup the algebraic node update.

//////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// Setup algebraic node update. Leaflet is assumed to be in its undeformed (straight vertical) position!

243  {
244  // Extract some reference lengths from the Domain.
245  double hleaflet = this->domain_pt()->hleaflet();
246  double htot = this->domain_pt()->htot();
247  double lleft = this->domain_pt()->lleft();
248  double lright = this->domain_pt()->lright();
249 
250  // Loop over all nodes in mesh
251  unsigned nnod = this->nnode();
252  for (unsigned j = 0; j < nnod; j++)
253  {
254  // Get pointer to node
255  AlgebraicNode* nod_pt = node_pt(j);
256 
257  // Get coordinates
258  double x = nod_pt->x(0);
259  double y = nod_pt->x(1);
260 
261  // Quick check to know if the wall is in its undeformed position
262  // It actually checks that the top of the wall is in (x_0,hleaflet)
263  Vector<double> zeta(1);
264  Vector<double> r(2);
265  zeta[0] = Hleaflet;
266  this->Leaflet_pt->position(zeta, r);
267  if ((r[0] != X_0) || (r[1] != hleaflet))
268  {
269  std::ostringstream error_stream;
270  error_stream << "Wall must be in its undeformed position when\n"
271  << "algebraic node update information is set up!\n "
272  << r[0] << " " << X_0 << " " << r[1] << " " << hleaflet
273  << std::endl;
274  throw OomphLibError(
275  error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
276  }
277 
278 
279  // The update function requires four parameters:
280  Vector<double> ref_value(4);
281 
282  // Part I
283  if ((x <= X_0) && (y <= hleaflet))
284  {
285  // First reference value: y0
286  ref_value[0] = y;
287 
288  // zeta coordinate on wall : fourth reference value
289  //(needed for adaptativity)
290  Vector<double> zeta(1);
291  zeta[0] = y;
292  ref_value[3] = zeta[0];
293 
294  // Sub-geomobject corresponding to the zeta coordinate on the wall
295  GeomObject* geom_obj_pt;
296  Vector<double> s(1);
297  this->Leaflet_pt->locate_zeta(zeta, geom_obj_pt, s);
298 
299  // Create vector of geomobject for add_node_update_info()
300  Vector<GeomObject*> geom_object_pt(1);
301  geom_object_pt[0] = geom_obj_pt;
302 
303  // Second reference value: Reference local coordinate
304  // in the sub-geomobject
305  ref_value[1] = s[0];
306 
307  // Third reference value:fraction of the horizontal line
308  // between the edge and the wall
309  ref_value[2] = (lleft + x - X_0) / lleft;
310 
311 
312  // Setup algebraic update for node: Pass update information
313  // to AlgebraicNode:
314  nod_pt->add_node_update_info(1, // ID
315  this, // mesh
316  geom_object_pt, // vector of geom objects
317  ref_value); // vector of ref. values
318  }
319  // Part II
320  if ((x >= X_0) && (y <= hleaflet))
321  {
322  // First reference value: y0
323  ref_value[0] = y;
324 
325  // zeta coordinate on wall: fourth reference value
326  //(needed for adaptativity)
327  Vector<double> zeta(1);
328  zeta[0] = y;
329  ref_value[3] = zeta[0];
330 
331  // Sub-geomobject corresponding to the zeta coordinate on the wall
332  GeomObject* geom_obj_pt;
333  Vector<double> s(1);
334  this->Leaflet_pt->locate_zeta(zeta, geom_obj_pt, s);
335 
336  // Create vector of geomobject for add_node_update_info()
337  Vector<GeomObject*> geom_object_pt(1);
338  geom_object_pt[0] = geom_obj_pt;
339 
340  // Second reference value: Reference local coordinate
341  // in the sub-geomobject
342  ref_value[1] = s[0];
343 
344  // Third reference value:fraction of the horizontal line
345  // between the edge and the wall
346  ref_value[2] = (x - X_0) / lright;
347 
348  // Setup algebraic update for node: Pass update information
349  // to AlgebraicNode:
350  nod_pt->add_node_update_info(2, // ID
351  this, // mesh
352  geom_object_pt, // vector of geom objects
353  ref_value); // vector of ref. values
354  }
355  // Part III
356  if ((x <= X_0) && (y >= hleaflet))
357  {
358  // First reference value: y0
359  ref_value[0] = y;
360 
361  // Second reference value: zeta coordinate on the middle line
362  ref_value[1] = (y - hleaflet) / (htot - hleaflet);
363 
364  // Third reference value:fraction of the horizontal line
365  // between the edge and the middle line
366  ref_value[2] = (lleft + x - X_0) / lleft;
367 
368  // geomobject
369  Vector<GeomObject*> geom_object_pt(1);
370  geom_object_pt[0] = this->Leaflet_pt;
371 
372  // Setup algebraic update for node: Pass update information
373  // to AlgebraicNode:
374  nod_pt->add_node_update_info(3, // ID
375  this, // mesh
376  geom_object_pt, // vector of geom objects
377  ref_value); // vector of ref. values
378  }
379  // Part IV
380  if ((x >= X_0) && (y >= hleaflet))
381  {
382  // First reference value: y0
383  ref_value[0] = y;
384 
385  // Second reference value: zeta coordinate on wall
386  ref_value[1] = (y - hleaflet) / (htot - hleaflet);
387 
388  // Third reference value:fraction of the horizontal line
389  // between the edge and the wall
390  ref_value[2] = (x - X_0) / lright;
391 
392  // geomobject
393  Vector<GeomObject*> geom_object_pt(1);
394  geom_object_pt[0] = this->Leaflet_pt;
395 
396  // Setup algebraic update for node: Pass update information
397  // to AlgebraicNode:
398  nod_pt->add_node_update_info(4, // ID
399  this, // mesh
400  geom_object_pt, // vector of geom objects
401  ref_value); // vector of ref. values
402  }
403  }
404 
405  } // end of setup_algebraic_node_update
oomph::ChannelWithLeafletDomain::htot
double htot()
Total height of domain (width of channel)
Definition: channel_with_leaflet_domain.h:95
oomph::ChannelWithLeafletDomain::hleaflet
double hleaflet()
Height of leaflet.
Definition: channel_with_leaflet_domain.h:101
oomph::GeomObject::locate_zeta
virtual void locate_zeta(const Vector< double > &zeta, GeomObject *&sub_geom_object_pt, Vector< double > &s, const bool &use_coordinate_as_initial_guess=false)
Definition: geom_objects.h:381
oomph::Mesh::nnode
unsigned long nnode() const
Return number of nodes in the mesh.
Definition: mesh.h:596
y
Scalar * y
Definition: level1_cplx_impl.h:128
plotDoE.x
list x
Definition: plotDoE.py:28
j
std::ptrdiff_t j
Definition: tut_arithmetic_redux_minmax.cpp:2

References oomph::AlgebraicNode::add_node_update_info(), j, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, UniformPSDSelfTest::r, s, plotDoE::x, oomph::Node::x(), TanhSolnForPoisson::X_0, y, and Eigen::zeta().

Referenced by oomph::AlgebraicChannelWithLeafletMesh< ELEMENT >::AlgebraicChannelWithLeafletMesh().

◆ slanted_bound_up()

template<class ELEMENT >
void oomph::AlgebraicChannelWithLeafletMesh< ELEMENT >::slanted_bound_up ( const unsigned &  t,
const Vector< double > &  zeta,
Vector< double > &  r 
)
protected

Helper function.

Slanted bound : helper function.

Coordinates of the point on the boundary beetween the upper and the lower part, in the same column, at the east.

544  {
547  double htot = this->domain_pt()->htot();
548 
549  Vector<double> xi(1);
550  xi[0] = Hleaflet;
551 
552  Vector<double> r_join(2);
553 
554  this->Leaflet_pt->position(t, xi, r_join);
555 
556  r[0] = r_join[0] + zeta[0] * (X_0 - r_join[0]);
557  r[1] = r_join[1] + zeta[0] * (htot - r_join[1]);
558  }

References UniformPSDSelfTest::r, plotPSD::t, TanhSolnForPoisson::X_0, and Eigen::zeta().

◆ update_node_update()

template<class ELEMENT >
void oomph::AlgebraicChannelWithLeafletMesh< ELEMENT >::update_node_update ( AlgebraicNode *&  node_pt)
inlinevirtual

Update the geometric references that are used to update node after mesh adaptation. Empty – no update of node update required without adaptivity

Implements oomph::AlgebraicMesh.

Reimplemented in oomph::RefineableAlgebraicChannelWithLeafletMesh< ELEMENT >.

422 {}

Member Data Documentation

◆ Hleaflet

template<class ELEMENT >
double oomph::AlgebraicChannelWithLeafletMesh< ELEMENT >::Hleaflet
protected

Length of the leaflet (stored explicitly for reference in algebraic node update – it's also stored independently in domain....)

Referenced by oomph::AlgebraicChannelWithLeafletMesh< ELEMENT >::AlgebraicChannelWithLeafletMesh().

◆ X_0

template<class ELEMENT >
double oomph::AlgebraicChannelWithLeafletMesh< ELEMENT >::X_0
protected

Origin of the wall (stored explicitly for reference in algebraic node update – it's also stored independently in domain....)

Referenced by oomph::AlgebraicChannelWithLeafletMesh< ELEMENT >::AlgebraicChannelWithLeafletMesh().

The documentation for this class was generated from the following files: