#include <algebraic_elements.h>

Inheritance diagram for oomph::AlgebraicNode:

Public Member Functions
	AlgebraicNode ()
	Default Constructor. More...

	AlgebraicNode (const unsigned &n_dim, const unsigned &n_position_type, const unsigned &initial_nvalue)

	AlgebraicNode (TimeStepper *time_stepper_pt, const unsigned &n_dim, const unsigned &n_position_type, const unsigned &initial_nvalue)

virtual	~AlgebraicNode ()
	Destructor (empty) More...

	AlgebraicNode (const AlgebraicNode &)=delete
	Broken copy constructor. More...

void	node_update (const bool &update_all_time_levels_for_new_node=false)
	Broken assignment operator. More...

unsigned	nnode_update_fcts ()
	Number of node update fcts. More...

int	node_update_fct_id ()
	Default (usually first if there are multiple ones) node update fct id. More...

void	node_update_fct_id (Vector< int > &id)

AlgebraicMesh *	mesh_pt ()
	Default (usually first) mesh that implements update function. More...

AlgebraicMesh *	mesh_pt (const int &id)
	Mesh that implements the id-th node update function. More...

unsigned	ngeom_object (const int &id)
	Number of geometric objects involved in id-th update function. More...

unsigned	ngeom_object () const

Vector< GeomObject * > &	vector_geom_object_pt (const int &id)

Vector< GeomObject * > &	vector_geom_object_pt ()

GeomObject **	all_geom_object_pt ()
	Return the vector of all geometric objects. More...

GeomObject *	geom_object_pt (const unsigned &i)

unsigned	nref_value (const int &id)
	Number of reference values involved in id-th update function. More...

unsigned	nref_value ()

Vector< double > &	vector_ref_value ()

Vector< double > &	vector_ref_value (const int &id)

double	ref_value (const unsigned &i)

void	add_node_update_info (const int &id, AlgebraicMesh mesh_pt, const Vector< GeomObject > &geom_object_pt, const Vector< double > &ref_value, const bool &called_from_constructor=false)

void	add_node_update_info (AlgebraicMesh mesh_pt, const Vector< GeomObject > &geom_object_pt, const Vector< double > &ref_value)

void	kill_node_update_info (const int &id=0)

unsigned	self_test ()

Public Member Functions inherited from oomph::Node
	Node ()
	Default constructor. More...

	Node (const unsigned &n_dim, const unsigned &n_position_type, const unsigned &initial_n_value, const bool &allocate_x_position=true)

	Node (TimeStepper *const &time_stepper_pt, const unsigned &n_dim, const unsigned &n_position_type, const unsigned &initial_n_value, const bool &allocate_x_position=true)

virtual	~Node ()
	Destructor: Clean up the memory allocated for nodal position. More...

	Node (const Node &node)=delete
	Broken copy constructor. More...

void	operator= (const Node &)=delete
	Broken assignment operator. More...

unsigned	nposition_type () const

TimeStepper *&	position_time_stepper_pt ()
	Return a pointer to the position timestepper. More...

TimeStepper *const &	position_time_stepper_pt () const
	Return a pointer to the position timestepper (const version). More...

virtual void	set_position_time_stepper (TimeStepper *const &position_time_stepper_pt, const bool &preserve_existing_data)

virtual bool	does_pointer_correspond_to_position_data (double *const &parameter_pt)

virtual void	assign_eqn_numbers (unsigned long &global_ndof, Vector< double * > &dof_pt)

unsigned	ndim () const
	Return (Eulerian) spatial dimension of the node. More...

double &	x (const unsigned &i)
	Return the i-th nodal coordinate. More...

const double &	x (const unsigned &i) const
	Return the i-th nodal coordinate (const version). More...

double &	x (const unsigned &t, const unsigned &i)

const double &	x (const unsigned &t, const unsigned &i) const

double	dx_dt (const unsigned &i) const
	Return the i-th component of nodal velocity: dx/dt. More...

double	dx_dt (const unsigned &j, const unsigned &i) const

virtual Node *	copied_node_pt () const

virtual bool	position_is_a_copy () const
	Return whether any position coordinate has been copied (always false) More...

virtual bool	position_is_a_copy (const unsigned &i) const
	Return whether the position coordinate i has been copied (always false) More...

double &	x_gen (const unsigned &k, const unsigned &i)

const double &	x_gen (const unsigned &k, const unsigned &i) const

double &	x_gen (const unsigned &t, const unsigned &k, const unsigned &i)

const double &	x_gen (const unsigned &t, const unsigned &k, const unsigned &i) const

double	dx_gen_dt (const unsigned &k, const unsigned &i) const

double	dx_gen_dt (const unsigned &j, const unsigned &k, const unsigned &i) const

double *	x_pt (const unsigned &t, const unsigned &i)

void	copy (Node *orig_node_pt)
	Copy all nodal data from specified Node object. More...

virtual void	dump (std::ostream &dump_file) const
	Dump nodal position and associated data to file for restart. More...

void	read (std::ifstream &restart_file)
	Read nodal position and associated data from file for restart. More...

virtual void	pin_all ()

virtual void	unpin_all ()

unsigned	hang_code ()

HangInfo *const &	hanging_pt () const

HangInfo *const &	hanging_pt (const int &i) const
	Return pointer to hanging node data for value i (const version) More...

bool	is_hanging () const
	Test whether the node is geometrically hanging. More...

bool	is_hanging (const int &i) const
	Test whether the i-th value is hanging. More...

void	set_hanging_pt (HangInfo *const &hang_pt, const int &i)
	Set the hanging data for the i-th value. (hang_pt=0 to make non-hanging) More...

void	set_nonhanging ()
	Label node as non-hanging node by removing all hanging node data. More...

void	resize (const unsigned &n_value)
	Resize the number of equations. More...

virtual void	constrain_positions ()

virtual void	unconstrain_positions ()

virtual void	make_periodic (Node *const &node_pt)

virtual void	make_periodic_nodes (const Vector< Node * > &periodic_nodes_pt)

virtual void	get_boundaries_pt (std::set< unsigned > *&boundaries_pt)

virtual bool	is_on_boundary () const

virtual bool	is_on_boundary (const unsigned &b) const

virtual void	add_to_boundary (const unsigned &b)

virtual void	remove_from_boundary (const unsigned &b)

virtual unsigned	ncoordinates_on_boundary (const unsigned &b)

virtual bool	boundary_coordinates_have_been_set_up ()

virtual void	get_coordinates_on_boundary (const unsigned &b, const unsigned &k, Vector< double > &boundary_zeta)

virtual void	set_coordinates_on_boundary (const unsigned &b, const unsigned &k, const Vector< double > &boundary_zeta)

virtual void	get_coordinates_on_boundary (const unsigned &b, Vector< double > &boundary_zeta)

virtual void	set_coordinates_on_boundary (const unsigned &b, const Vector< double > &boundary_zeta)

void	set_obsolete ()
	Mark node as obsolete. More...

void	set_non_obsolete ()
	Mark node as non-obsolete. More...

bool	is_obsolete ()
	Test whether node is obsolete. More...

double	raw_value (const unsigned &i) const

double	raw_value (const unsigned &t, const unsigned &i) const

double	value (const unsigned &i) const

double	value (const unsigned &t, const unsigned &i) const

void	value (Vector< double > &values) const

Vector< double >	value () const
	Return vector of values calculated using value(vector). More...

void	value (const unsigned &t, Vector< double > &values) const

void	position (Vector< double > &pos) const

Vector< double >	position () const
	Return vector of position of node at current time. More...

void	position (const unsigned &t, Vector< double > &pos) const

double	position (const unsigned &i) const

double	position (const unsigned &t, const unsigned &i) const

double	position_gen (const unsigned &k, const unsigned &i) const

double	position_gen (const unsigned &t, const unsigned &k, const unsigned &i) const

double	dposition_dt (const unsigned &i) const

double	dposition_dt (const unsigned &j, const unsigned &i) const

double	dposition_gen_dt (const unsigned &k, const unsigned &i) const

double	dposition_gen_dt (const unsigned &j, const unsigned &k, const unsigned &i) const

void	set_auxiliary_node_update_fct_pt (AuxNodeUpdateFctPt aux_node_update_fct_pt)

bool	has_auxiliary_node_update_fct_pt ()

void	perform_auxiliary_node_update_fct ()

virtual unsigned	ngeom_data () const

virtual Data **	all_geom_data_pt ()

void	output (std::ostream &outfile)
	Output nodal position. More...

Public Member Functions inherited from oomph::Data
virtual void	clear_copied_pointers ()

	Data ()
	Default constructor. More...

	Data (const unsigned &initial_n_value)

	Data (TimeStepper *const &time_stepper_pt, const unsigned &initial_n_value, const bool &allocate_storage=true)

	Data (const Data &data)=delete
	Broken copy constructor. More...

void	operator= (const Data &)=delete
	Broken assignment operator. More...

virtual	~Data ()
	Destructor, deallocates memory assigned for data. More...

void	set_time_stepper (TimeStepper *const &time_stepper_pt, const bool &preserve_existing_data)

TimeStepper *&	time_stepper_pt ()
	Return the pointer to the timestepper. More...

TimeStepper *const &	time_stepper_pt () const
	Return the pointer to the timestepper (const version). More...

virtual bool	is_a_copy () const

virtual bool	is_a_copy (const unsigned &i) const

void	set_value (const unsigned &i, const double &value_)

void	set_value (const unsigned &t, const unsigned &i, const double &value_)

double	value (const unsigned &i) const

double	value (const unsigned &t, const unsigned &i) const

void	value (Vector< double > &values) const
	Compute Vector of values for the Data value. More...

void	value (const unsigned &t, Vector< double > &values) const

double *	value_pt (const unsigned &i) const

double *	value_pt (const unsigned &t, const unsigned &i) const

bool	does_pointer_correspond_to_value (double *const &parameter_pt)
	Check whether the pointer parameter_pt addresses internal data values. More...

void	copy (Data *orig_data_pt)
	Copy Data values from specified Data object. More...

void	dump (std::ostream &dump_file) const
	Dump the data object to a file. More...

void	read (std::ifstream &restart_file)
	Read data object from a file. More...

long *	eqn_number_pt (const unsigned &i)
	Return the pointer to the equation number of the i-th stored variable. More...

long &	eqn_number (const unsigned &i)
	Return the equation number of the i-th stored variable. More...

long	eqn_number (const unsigned &i) const
	Return the equation number of the i-th stored variable. More...

void	pin (const unsigned &i)
	Pin the i-th stored variable. More...

void	unpin (const unsigned &i)
	Unpin the i-th stored variable. More...

void	pin_all ()
	Pin all the stored variables. More...

void	unpin_all ()
	Unpin all the stored variables. More...

bool	is_pinned (const unsigned &i) const
	Test whether the i-th variable is pinned (1: true; 0: false). More...

bool	is_segregated_solve_pinned (const unsigned &i)

void	constrain (const unsigned &i)

void	unconstrain (const unsigned &i)

void	constrain_all ()
	Constrain all the stored variables when the data is made hanging. More...

void	unconstrain_all ()
	Unconstrain all the stored variables when the data is made nonhanging. More...

bool	is_constrained (const unsigned &i)

unsigned	self_test ()

unsigned	nvalue () const
	Return number of values stored in data object (incl pinned ones). More...

unsigned	ntstorage () const

virtual void	describe_dofs (std::ostream &out, const std::string &current_string) const

virtual void	add_value_pt_to_map (std::map< unsigned, double * > &map_of_value_pt)

Private Member Functions
void	set_default_node_update (const int &id)
	Make id-th node update function the default. More...

Private Attributes
std::map< int, AlgebraicMesh * >	Mesh_pt

std::map< int, Vector< GeomObject * > >	Geom_object_pt

std::map< int, Vector< double > >	Ref_value

std::map< int, AlgebraicMesh * >::iterator	Default_it_mesh_pt
	Default iterator for mesh: This mesh performs the default update. More...

std::map< int, Vector< GeomObject * > >::iterator	Default_it_geom_object_pt

std::map< int, Vector< double > >::iterator	Default_it_ref_value

int	Default_node_update_fct_id
	Default node update function ID. More...

Static Private Attributes
static double	Max_allowed_difference_between_node_update_fcts

static int	Dummy_node_update_fct_id = -100

static AlgebraicMesh *	Dummy_mesh_pt = &AlgebraicNode::Dummy_mesh

static DummyAlgebraicMesh	Dummy_mesh
	Static Dummy mesh to which the pointer is addressed. More...

static Vector< GeomObject * >	Dummy_geom_object_pt

static Vector< double >	Dummy_ref_value

Additional Inherited Members
Public Types inherited from oomph::Node
typedef void(*	AuxNodeUpdateFctPt) (Node *)
	Function pointer to auxiliary node update function. More...

Static Public Attributes inherited from oomph::Node
static unsigned	No_independent_position = 10

Static Public Attributes inherited from oomph::Data
static long	Is_pinned = -1
	Static "Magic number" to indicate pinned values. More...

static long	Is_segregated_solve_pinned = -3

static long	Is_unclassified = -10

static long	Is_constrained = -2

Protected Member Functions inherited from oomph::Node
void	x_gen_range_check (const unsigned &t, const unsigned &k, const unsigned &i) const

double *	x_position_pt (const unsigned &i)
	Direct access to the pointer to the i-th stored coordinate data. More...

Protected Member Functions inherited from oomph::Data
virtual void	reset_copied_pointers ()

Protected Attributes inherited from oomph::Node
double **	X_position

TimeStepper *	Position_time_stepper_pt
	Pointer to the timestepper associated with the position data. More...

HangInfo **	Hanging_pt

unsigned	Ndim
	Eulerian dimension of the node. More...

unsigned	Nposition_type

bool	Obsolete

AuxNodeUpdateFctPt	Aux_node_update_fct_pt

Protected Attributes inherited from oomph::Data
Data **	Copy_of_data_pt

unsigned	Ncopies

Static Protected Attributes inherited from oomph::Data
static TimeStepper *	Default_static_time_stepper_pt = new Steady<0>()
	Default (static) timestepper used in steady problems. More...

Detailed Description

//////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// Algebraic nodes are nodes with an algebraic positional update function.

Constructor & Destructor Documentation

◆ AlgebraicNode() [1/4]

oomph::AlgebraicNode::AlgebraicNode ( )

inline

Default Constructor.

58 : Node() {}

oomph::Node::Node

Node()

Default constructor.

Definition: nodes.cc:1574

◆ AlgebraicNode() [2/4]

oomph::AlgebraicNode::AlgebraicNode	(	const unsigned &	n_dim,
		const unsigned &	n_position_type,
		const unsigned &	initial_nvalue
	)

inline

Constructor for steady algebraic node of spatial dimension n_dim, with n_position_type generalised coordinates and with initial_nvalue dofs.

       : Node(n_dim, n_position_type, initial_nvalue)
     {
 #ifdef LEAK_CHECK
       LeakCheckNames::AlgebraicNode_build += 1;
 #endif
  
       // Add default node update info
       add_node_update_info(Dummy_node_update_fct_id, // dummy remesh fct ID
                            Dummy_mesh_pt, // dummy mesh
                            Dummy_geom_object_pt, // dummy geom object vector
                            Dummy_ref_value, // dummy  ref vector
                            true); // flag indicating call from
                                   // constructor
     }

References add_node_update_info(), Dummy_geom_object_pt, Dummy_mesh_pt, Dummy_node_update_fct_id, and Dummy_ref_value.

◆ AlgebraicNode() [3/4]

oomph::AlgebraicNode::AlgebraicNode	(	TimeStepper *	time_stepper_pt,
		const unsigned &	n_dim,
		const unsigned &	n_position_type,
		const unsigned &	initial_nvalue
	)

inline

Constructor for bog-standard algebraic node of spatial dimension n_dim, with n_position_type generalised coordinates, with initial_nvalue dofs and with time dependence.

       : Node(time_stepper_pt, n_dim, n_position_type, initial_nvalue)
     {
 #ifdef LEAK_CHECK
       LeakCheckNames::AlgebraicNode_build += 1;
 #endif
  
       // Add default node update info
       add_node_update_info(Dummy_node_update_fct_id, // dummy remesh fct ID
                            Dummy_mesh_pt, // dummy mesh
                            Dummy_geom_object_pt, // dummy geom object vector
                            Dummy_ref_value, // dummy ref vector
                            true); // flag indicating call from
                                   // constructor
     }

References add_node_update_info(), Dummy_geom_object_pt, Dummy_mesh_pt, Dummy_node_update_fct_id, and Dummy_ref_value.

◆ ~AlgebraicNode()

virtual oomph::AlgebraicNode::~AlgebraicNode ( )

inlinevirtual

Destructor (empty)

     {
 #ifdef LEAK_CHECK
       LeakCheckNames::AlgebraicNode_build -= 1;
 #endif
     }

◆ AlgebraicNode() [4/4]

oomph::AlgebraicNode::AlgebraicNode ( const AlgebraicNode & )

delete

Broken copy constructor.

Member Function Documentation

◆ add_node_update_info() [1/2]

void oomph::AlgebraicNode::add_node_update_info	(	AlgebraicMesh *	mesh_pt,
		const Vector< GeomObject * > &	geom_object_pt,
		const Vector< double > &	ref_value
	)

inline

Add algebraic update information for node: Which Mesh implements the update operation? Also, pass the vector of geometric objects and the vectors of reference values that are needed for the update operation. We're assigning a default node update fct id of 0.

     {
       // No update fct id supplied: Use a default assignment of 0.
       unsigned id = 0;
  
       // If there's just one entry -- check if it's the default dummy one
       if (Mesh_pt.size() == 1)
       {
         // Do we still have dummy default assignment stored as the one
         // and only entry?
         if (Mesh_pt.begin()->second == Dummy_mesh_pt)
         {
           if (Default_it_mesh_pt->second == Dummy_mesh_pt)
           {
             kill_node_update_info(Dummy_node_update_fct_id);
           }
         }
       }
  
       // Now insert the actual info
       Mesh_pt.insert(std::make_pair(id, mesh_pt));
       Geom_object_pt.insert(std::make_pair(id, geom_object_pt));
       Ref_value.insert(std::make_pair(id, ref_value));
  
       // Always use the "first" update fct as default -- can be overwritten
       // outside (usually only done for self test)
       set_default_node_update(Mesh_pt.begin()->first);
     }

References Default_it_mesh_pt, Dummy_mesh_pt, Dummy_node_update_fct_id, geom_object_pt(), Geom_object_pt, kill_node_update_info(), mesh_pt(), Mesh_pt, ref_value(), Ref_value, and set_default_node_update().

◆ add_node_update_info() [2/2]

void oomph::AlgebraicNode::add_node_update_info	(	const int &	id,
		AlgebraicMesh *	mesh_pt,
		const Vector< GeomObject * > &	geom_object_pt,
		const Vector< double > &	ref_value,
		const bool &	called_from_constructor = `false`
	)

inline

Add algebraic update information for node: What's the ID of the mesh update function (typically used within the mesh) Which Mesh implements the update operation? Also, pass the vector of geometric objects and the vectors of reference values that are needed for the update operation. Negative values for ID are only allowed when called from node constructor, as indicated by the final argument which defaults to false.

     {
       // Sanity check
       if (id < 0)
       {
         if (!called_from_constructor)
         {
           std::ostringstream error_message;
           error_message << "\nNegative ID, " << id
                         << ", only allowed if called from constructor and\n"
                         << "indicated as such by optional boolean flag."
                         << std::endl;
           throw OomphLibError(error_message.str(),
                               OOMPH_CURRENT_FUNCTION,
                               OOMPH_EXCEPTION_LOCATION);
         }
       }
  
       // If there's just one entry -- check if it's the default dummy one
       if (Mesh_pt.size() == 1)
       {
         if (Mesh_pt.begin()->second == Dummy_mesh_pt)
         {
           if (Default_it_mesh_pt->second == Dummy_mesh_pt)
           {
             kill_node_update_info(Dummy_node_update_fct_id);
           }
         }
       }
  
       // Now insert the actual info
       Mesh_pt.insert(std::make_pair(id, mesh_pt));
       Geom_object_pt.insert(std::make_pair(id, geom_object_pt));
       Ref_value.insert(std::make_pair(id, ref_value));
  
       // Always use the "first" update fct as default -- can be overwritten
       // outside (usually only done for self test)
       set_default_node_update(Mesh_pt.begin()->first);
     }

References Default_it_mesh_pt, Dummy_mesh_pt, Dummy_node_update_fct_id, geom_object_pt(), Geom_object_pt, kill_node_update_info(), mesh_pt(), Mesh_pt, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, ref_value(), Ref_value, and set_default_node_update().

Referenced by AlgebraicNode(), oomph::MyAlgebraicCollapsibleChannelMesh< ELEMENT >::setup_algebraic_node_update(), oomph::AlgebraicChannelWithLeafletMesh< ELEMENT >::setup_algebraic_node_update(), oomph::AlgebraicCollapsibleChannelMesh< ELEMENT >::setup_algebraic_node_update(), oomph::AlgebraicFSIDrivenCavityMesh< ELEMENT >::setup_algebraic_node_update(), oomph::AlgebraicElementBase::setup_algebraic_node_update(), oomph::RefineableAlgebraicChannelWithLeafletMesh< ELEMENT >::update_node_update(), oomph::RefineableAlgebraicCollapsibleChannelMesh< ELEMENT >::update_node_update(), oomph::RefineableAlgebraicCylinderWithFlagMesh< ELEMENT >::update_node_update(), oomph::RefineableAlgebraicFSIDrivenCavityMesh< ELEMENT >::update_node_update(), oomph::AlgebraicRefineableQuarterCircleSectorMesh< ELEMENT >::update_node_update_in_lower_right_box(), oomph::AlgebraicRefineableQuarterTubeMesh< ELEMENT >::update_node_update_in_region(), and oomph::AlgebraicRefineableQuarterCircleSectorMesh< ELEMENT >::update_node_update_in_upper_left_box().

◆ all_geom_object_pt()

GeomObject** oomph::AlgebraicNode::all_geom_object_pt ( )

inlinevirtual

Return the vector of all geometric objects.

Reimplemented from oomph::Node.

     {
       if (this->ngeom_object() == 0)
       {
         return 0;
       }
       else
       {
         return &(Default_it_geom_object_pt->second[0]);
       }
     }

References Default_it_geom_object_pt, and ngeom_object().

◆ geom_object_pt()

GeomObject* oomph::AlgebraicNode::geom_object_pt ( const unsigned & i )

inline

Return pointer to i-th geometric object involved in default (usually first) update function

     {
       return Default_it_geom_object_pt->second[i];
     }

References Default_it_geom_object_pt, and i.

Referenced by add_node_update_info(), oomph::AlgebraicFishMesh< ELEMENT >::node_update_in_body(), oomph::AlgebraicFishMesh< ELEMENT >::node_update_in_fin(), oomph::AlgebraicRefineableQuarterCircleSectorMesh< ELEMENT >::node_update_in_upper_left_box(), and oomph::AlgebraicRefineableQuarterTubeMesh< ELEMENT >::node_update_upper_left_region().

◆ kill_node_update_info()

void oomph::AlgebraicNode::kill_node_update_info ( const int & id = 0 )

inline

Erase algebraic node update information for id-th node update function. Id defaults to 0.

     {
       Mesh_pt.erase(Mesh_pt.find(id));
       Geom_object_pt.erase(Geom_object_pt.find(id));
       Ref_value.erase(Ref_value.find(id));
     }

References Geom_object_pt, Mesh_pt, and Ref_value.

Referenced by add_node_update_info(), oomph::RefineableAlgebraicChannelWithLeafletMesh< ELEMENT >::update_node_update(), oomph::RefineableAlgebraicCollapsibleChannelMesh< ELEMENT >::update_node_update(), oomph::RefineableAlgebraicCylinderWithFlagMesh< ELEMENT >::update_node_update(), oomph::RefineableAlgebraicFSIDrivenCavityMesh< ELEMENT >::update_node_update(), oomph::AlgebraicRefineableQuarterCircleSectorMesh< ELEMENT >::update_node_update_in_lower_right_box(), oomph::AlgebraicRefineableQuarterTubeMesh< ELEMENT >::update_node_update_in_region(), and oomph::AlgebraicRefineableQuarterCircleSectorMesh< ELEMENT >::update_node_update_in_upper_left_box().

◆ mesh_pt() [1/2]

AlgebraicMesh* oomph::AlgebraicNode::mesh_pt ( )

inline

Default (usually first) mesh that implements update function.

     {
       return Default_it_mesh_pt->second;
     }

References Default_it_mesh_pt.

Referenced by add_node_update_info(), node_update(), and oomph::AlgebraicElementBase::setup_algebraic_node_update().

◆ mesh_pt() [2/2]

AlgebraicMesh* oomph::AlgebraicNode::mesh_pt ( const int & id )

inline

Mesh that implements the id-th node update function.

     {
       return Mesh_pt[id];
     }

References Mesh_pt.

◆ ngeom_object() [1/2]

unsigned oomph::AlgebraicNode::ngeom_object ( ) const

inlinevirtual

Number of geometric objects involved in default (usually first) update function

Reimplemented from oomph::Node.

     {
       return Default_it_geom_object_pt->second.size();
     }

References Default_it_geom_object_pt.

Referenced by all_geom_object_pt().

◆ ngeom_object() [2/2]

unsigned oomph::AlgebraicNode::ngeom_object ( const int & id )

inline

Number of geometric objects involved in id-th update function.

     {
       return Geom_object_pt[id].size();
     }

References Geom_object_pt.

◆ nnode_update_fcts()

unsigned oomph::AlgebraicNode::nnode_update_fcts ( )

inline

Number of node update fcts.

     {
       // Note: We could read this information out from any one of
       // various maps that that store the information for the
       // different node update functions...
       return Mesh_pt.size();
     }

References Mesh_pt.

Referenced by node_update(), and self_test().

◆ node_update()

void oomph::AlgebraicNode::node_update ( const bool & update_all_time_levels_for_new_node = false )

virtual

Broken assignment operator.

Update the current nodal position, using the first (default) update function if there are multiple ones. If required perform the auxiliary update of nodal values. If update_all_time_levels_for_new_node==true, previous positions are also updated – as indicated by the name of this flag, this should only be done for newly created nodes, when this function is called from AlgebraicElementBase::setup_algebraic_node_update(...)

Excute the node update function: Update the current (and if update_all_time_levels_for_new_node==true also the previous) nodal position. Also update the current nodal values if an auxiliary update function is defined. Note: updating of previous positions is only required (and should only be performed for) newly created AlgebraicNodes i.e. when this function is called from AlgebraicElementBase::setup_algebraic_node_update(...). We create the history of its nodal positions from the time-dependent version of the specific AlgebraicMesh's algebraic_node_update(...) function.

Perform auxiliary update of function values?

Reimplemented from oomph::Node.

   {
     // Number of time levels that need to be updated
     unsigned ntime;
     if (update_all_time_levels_for_new_node)
     {
       // Present value plus previous values
       ntime = 1 + Position_time_stepper_pt->nprev_values();
     }
     else
     {
       // Present value only
       ntime = 1;
     }
  
     // Is it a hanging node?
     if (is_hanging())
     {
       // Loop over all master nodes and update their position
       // That's all we need to update the position of hanging nodes!
       // (Recall that for hanging nodes Node::x(...) is not
       // guaranteed to be kept up-to-date; the (constrained!) nodal
       // position of hanging nodes must be determined via
       // Node::position() which determines the position
       // via the hanging node constraints from the position of
       // the master nodes)
       unsigned nmaster = hanging_pt()->nmaster();
       for (unsigned imaster = 0; imaster < nmaster; imaster++)
       {
         dynamic_cast<AlgebraicNode*>(hanging_pt()->master_node_pt(imaster))
           ->node_update();
       }
     }
     // Node isn't hanging --> update it directly
     else
     {
       // If no update function is defined, keep the nodal positions where
       // they were (i.e. don't do anything), else update
       if (nnode_update_fcts() != 0)
       {
         // Loop over time levels
         for (unsigned t = 0; t < ntime; t++)
         {
           // Update nodal position
           AlgebraicMesh* mesh_pt = Mesh_pt.begin()->second;
           // Not sure why I need this intermediate variable....
           AlgebraicNode* node_pt = this;
           mesh_pt->algebraic_node_update(t, node_pt);
         }
       }
     }
  
     if (Aux_node_update_fct_pt != 0)
     {
       Aux_node_update_fct_pt(this);
     }
   }

References oomph::AlgebraicMesh::algebraic_node_update(), oomph::Node::Aux_node_update_fct_pt, oomph::Node::hanging_pt(), oomph::Node::is_hanging(), oomph::HangInfo::master_node_pt(), mesh_pt(), Mesh_pt, oomph::HangInfo::nmaster(), nnode_update_fcts(), oomph::TimeStepper::nprev_values(), oomph::Node::Position_time_stepper_pt, and plotPSD::t.

Referenced by oomph::TreeBasedRefineableMeshBase::adapt_mesh(), oomph::Mesh::delete_all_external_storage(), oomph::AlgebraicMesh::node_update(), oomph::TreeBasedRefineableMeshBase::p_adapt_mesh(), self_test(), and oomph::AlgebraicElementBase::setup_algebraic_node_update().

◆ node_update_fct_id() [1/2]

int oomph::AlgebraicNode::node_update_fct_id ( )

inline

Default (usually first if there are multiple ones) node update fct id.

     {
       return Default_node_update_fct_id;
     }

References Default_node_update_fct_id.

Referenced by oomph::AlgebraicChannelWithLeafletMesh< ELEMENT >::algebraic_node_update(), oomph::AlgebraicCylinderWithFlagMesh< ELEMENT >::algebraic_node_update(), oomph::AlgebraicFishMesh< ELEMENT >::algebraic_node_update(), oomph::AlgebraicRefineableQuarterCircleSectorMesh< ELEMENT >::algebraic_node_update(), oomph::AlgebraicRefineableQuarterTubeMesh< ELEMENT >::algebraic_node_update(), self_test(), oomph::RefineableAlgebraicChannelWithLeafletMesh< ELEMENT >::update_node_update(), oomph::RefineableAlgebraicCylinderWithFlagMesh< ELEMENT >::update_node_update(), oomph::AlgebraicRefineableQuarterCircleSectorMesh< ELEMENT >::update_node_update(), and oomph::AlgebraicRefineableQuarterTubeMesh< ELEMENT >::update_node_update().

◆ node_update_fct_id() [2/2]

void oomph::AlgebraicNode::node_update_fct_id ( Vector< int > & id )

inline

Return vector of node update fct ids (vector is resized to contain the correct number of entries). Somewhat costly to call as map needs to be copied into vector.

     {
       // Resize vector
       id.resize(0);
  
       // Loop over all entries and copy them across (again, we could
       // get this information from any of the maps...)
       typedef std::map<int, AlgebraicMesh*>::iterator IT;
       for (IT it = Mesh_pt.begin(); it != Mesh_pt.end(); it++)
       {
         id.push_back(it->first);
       }
     }

References Mesh_pt.

◆ nref_value() [1/2]

unsigned oomph::AlgebraicNode::nref_value ( )

inline

Number of reference values involved in default (usually first) update function

     {
       return Default_it_ref_value->second.size();
     }

References Default_it_ref_value.

◆ nref_value() [2/2]

unsigned oomph::AlgebraicNode::nref_value ( const int & id )

inline

Number of reference values involved in id-th update function.

     {
       return Ref_value[id].size();
     }

References Ref_value.

Referenced by oomph::AlgebraicElementBase::setup_algebraic_node_update().

◆ ref_value()

double oomph::AlgebraicNode::ref_value ( const unsigned & i )

inline

Return i-th reference value involved in default (usually first) update function

     {
       return Default_it_ref_value->second[i];
     }

References Default_it_ref_value, and i.

Referenced by add_node_update_info(), oomph::AlgebraicFishMesh< ELEMENT >::node_update_in_body(), oomph::AlgebraicFishMesh< ELEMENT >::node_update_in_fin(), and oomph::AlgebraicRefineableQuarterCircleSectorMesh< ELEMENT >::node_update_in_upper_left_box().

◆ self_test()

unsigned oomph::AlgebraicNode::self_test ( )

Perform self test: If the node has multiple node update functions, check that they all give the same result. Return 1/0 for failure/success. (Failure if max. difference between the nodal positions for different update functions exceeds AlgebraicNode::Max_allowed_difference_between_node_update_fcts

Perform self test: If the node has multiple update functions, check that all update functions give the same result (with a tolerance of AlgebraicNode::Max_allowed_difference_between_node_update_fcts

   {
     // Initialise
     bool passed = true;
  
     unsigned test = Node::self_test();
     if (test != 0)
     {
       passed = false;
     }
  
     // Loop over all update functions
     unsigned nnode_update = nnode_update_fcts();
  
     // If there is just one (or no) update function, then no conflict
     // can arise and the error is zero.
     if (nnode_update <= 1)
     {
       // return 0;
     }
     // Multiple update funcions: check consistency
     else
     {
       // Initialise error
       double err_max = 0.0;
  
       // Spatial (Eulerian) position of the node
       unsigned ndim_node = ndim();
       Vector<double> x_0(ndim_node);
       Vector<double> x_new(ndim_node);
  
       // Get vector of update fct ids
       Vector<int> id;
       node_update_fct_id(id);
  
  
       // Quick consistency check
 #ifdef PARANOID
       if (id.size() != nnode_update)
       {
         std::ostringstream error_stream;
         error_stream << "Inconsistency between number of node update ids:"
                      << nnode_update << " and " << id.size() << std::endl;
         throw OomphLibError(
           error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
       }
 #endif
  
  
       // Update with first update function
  
       // Set default update function
       set_default_node_update(id[0]);
  
       // Update the node:
       node_update();
  
       // Store coordinates
       for (unsigned i = 0; i < ndim_node; i++)
       {
         x_0[i] = x(i);
       }
  
  
       // Loop over all other update functions
       for (unsigned iupdate = 1; iupdate < nnode_update; iupdate++)
       {
         // Set default update function
         set_default_node_update(id[iupdate]);
  
         // Update the node:
         node_update();
  
         // Store coordinates
         for (unsigned i = 0; i < ndim_node; i++)
         {
           x_new[i] = x(i);
         }
  
         // Check error
         double err = 0.0;
         for (unsigned i = 0; i < ndim_node; i++)
         {
           err += (x_new[i] - x_0[i]) * (x_new[i] - x_0[i]);
         }
         err = sqrt(err);
         if (err > err_max)
         {
           err_max = err;
         }
  
         // Dump out
         if (err > Max_allowed_difference_between_node_update_fcts)
         {
           oomph_info << "Discrepancy in algebraic update function " << iupdate
                      << ": " << x_0[0] << " " << x_0[1] << " " << x_new[0]
                      << " " << x_new[1] << std::endl;
  
           passed = false;
         }
       }
  
  
       // Update again with first update function to reset
  
       // Set default update function
       set_default_node_update(id[0]);
  
       // Update the node:
       node_update();
  
       // Return verdict
       if (passed)
       {
         return 0;
       }
       else
       {
         return 1;
       }
     }
     // Catch all to remove compiler warning
     return 0;
   }

References i, Max_allowed_difference_between_node_update_fcts, oomph::Node::ndim(), nnode_update_fcts(), node_update(), node_update_fct_id(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::oomph_info, oomph::Data::self_test(), set_default_node_update(), size, sqrt(), and oomph::Node::x().

◆ set_default_node_update()

void oomph::AlgebraicNode::set_default_node_update ( const int & id )

inlineprivate

Make id-th node update function the default.

     {
       // Set default node update fct id
       Default_node_update_fct_id = id;
  
  
       // Set iterators for default entry
  
       // Iterator to default mesh:
       Default_it_mesh_pt = Mesh_pt.find(id);
 #ifdef PARANOID
       if (Default_it_mesh_pt == Mesh_pt.end())
       {
         std::ostringstream error_message;
         error_message << "There is no reference mesh for node update fct id"
                       << id << std::endl;
         throw OomphLibError(error_message.str(),
                             OOMPH_CURRENT_FUNCTION,
                             OOMPH_EXCEPTION_LOCATION);
       }
 #endif
  
       // Iterator to default GeomObject vector
       Default_it_geom_object_pt = Geom_object_pt.find(id);
 #ifdef PARANOID
       if (Default_it_geom_object_pt == Geom_object_pt.end())
       {
         std::ostringstream error_message;
         error_message << "There is no Geom_object_pt for node update fct id"
                       << id << std::endl;
         throw OomphLibError(error_message.str(),
                             OOMPH_CURRENT_FUNCTION,
                             OOMPH_EXCEPTION_LOCATION);
       }
 #endif
  
       // Iterator to default values vector
       Default_it_ref_value = Ref_value.find(id);
 #ifdef PARANOID
       if (Default_it_ref_value == Ref_value.end())
       {
         std::ostringstream error_message;
         error_message << "There is no Ref_value for node update fct id" << id
                       << std::endl;
         throw OomphLibError(error_message.str(),
                             OOMPH_CURRENT_FUNCTION,
                             OOMPH_EXCEPTION_LOCATION);
       }
 #endif
     }

References Default_it_geom_object_pt, Default_it_mesh_pt, Default_it_ref_value, Default_node_update_fct_id, Geom_object_pt, Mesh_pt, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, and Ref_value.

Referenced by add_node_update_info(), and self_test().

◆ vector_geom_object_pt() [1/2]

Vector<GeomObject*>& oomph::AlgebraicNode::vector_geom_object_pt ( )

inline

Return vector of geometric objects involved in default (usually first) update function

     {
       return Default_it_geom_object_pt->second;
     }

References Default_it_geom_object_pt.

◆ vector_geom_object_pt() [2/2]

Vector<GeomObject*>& oomph::AlgebraicNode::vector_geom_object_pt ( const int & id )

inline

Return vector of geometric objects involved in id-th update function

     {
       return Geom_object_pt[id];
     }

References Geom_object_pt.

◆ vector_ref_value() [1/2]

Vector<double>& oomph::AlgebraicNode::vector_ref_value ( )

inline

Return vector of reference values involved in default (usually first) update function

     {
       return Default_it_ref_value->second;
     }

References Default_it_ref_value.

◆ vector_ref_value() [2/2]

Vector<double>& oomph::AlgebraicNode::vector_ref_value ( const int & id )

inline

Return vector of reference values involved in id-th update function

     {
       return Ref_value[id];
     }

References Ref_value.

Member Data Documentation

◆ Default_it_geom_object_pt

std::map<int, Vector<GeomObject*> >::iterator oomph::AlgebraicNode::Default_it_geom_object_pt

private

Default iterator for vector of geom objects. These GeomObjects are involved in the default update.

Referenced by all_geom_object_pt(), geom_object_pt(), ngeom_object(), set_default_node_update(), and vector_geom_object_pt().

◆ Default_it_mesh_pt

std::map<int, AlgebraicMesh*>::iterator oomph::AlgebraicNode::Default_it_mesh_pt

private

Default iterator for mesh: This mesh performs the default update.

Referenced by add_node_update_info(), mesh_pt(), and set_default_node_update().

◆ Default_it_ref_value

std::map<int, Vector<double> >::iterator oomph::AlgebraicNode::Default_it_ref_value

private

Default iterator for vector of ref values. These reference values are involved in the default update.

Referenced by nref_value(), ref_value(), set_default_node_update(), and vector_ref_value().

◆ Default_node_update_fct_id

int oomph::AlgebraicNode::Default_node_update_fct_id

private

Default node update function ID.

Referenced by node_update_fct_id(), and set_default_node_update().

◆ Dummy_geom_object_pt

Vector< GeomObject * > oomph::AlgebraicNode::Dummy_geom_object_pt

staticprivate

Default dummy vector of geom objects to point to for nodes for which no remesh fct is defined

Zero-sized default dummy vector of geom objects to point to for nodes for which no remesh fct is defined

Referenced by AlgebraicNode().

◆ Dummy_mesh

DummyAlgebraicMesh oomph::AlgebraicNode::Dummy_mesh

staticprivate

Static Dummy mesh to which the pointer is addressed.

Set the dummy mesh.

◆ Dummy_mesh_pt

AlgebraicMesh * oomph::AlgebraicNode::Dummy_mesh_pt = &AlgebraicNode::Dummy_mesh

staticprivate

Default dummy mesh to point to for nodes for which no remesh fct is defined

Referenced by add_node_update_info(), and AlgebraicNode().

◆ Dummy_node_update_fct_id

int oomph::AlgebraicNode::Dummy_node_update_fct_id = -100

staticprivate

Default (negative!) remesh fct id for nodes for which no remesh fct is defined

Referenced by add_node_update_info(), and AlgebraicNode().

◆ Dummy_ref_value

Vector< double > oomph::AlgebraicNode::Dummy_ref_value

staticprivate

Default dummy vector of reference values to point to for nodes for which no remesh fct is defined

Zero-sized default dummy vector of reference values to point to for nodes for which no remesh fct is defined

Referenced by AlgebraicNode().

◆ Geom_object_pt

std::map<int, Vector<GeomObject*> > oomph::AlgebraicNode::Geom_object_pt

private

Vector of geometric objects that are involved in the specified node update operation. (Map because this node may only use the Mesh's 116th node update fct. There's no point in wasting an entire vector for the non-existing entries)

Referenced by add_node_update_info(), kill_node_update_info(), ngeom_object(), set_default_node_update(), and vector_geom_object_pt().

◆ Max_allowed_difference_between_node_update_fcts

double oomph::AlgebraicNode::Max_allowed_difference_between_node_update_fcts

staticprivate

Initial value:

=

1.0e-10

What it says: Used in self-test to check if different node update functions produce the same result.

//////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// Assign default value for test if different node update functions produce the same result.

Referenced by self_test().

◆ Mesh_pt

std::map<int, AlgebraicMesh*> oomph::AlgebraicNode::Mesh_pt

private

Pointer to mesh that performs the specified node update operation (Map because this node may only use the Mesh's 116th node update fct. There's no point in wasting an entire vector for the non-existing entries)

Referenced by add_node_update_info(), kill_node_update_info(), mesh_pt(), nnode_update_fcts(), node_update(), node_update_fct_id(), and set_default_node_update().

◆ Ref_value

std::map<int, Vector<double> > oomph::AlgebraicNode::Ref_value

private

Vector of reference values that are required for the specified node update operation. (Map because this node may only use the Mesh's 116th node update fct. There's no point in wasting an entire vector for the non-existing entries)

Referenced by add_node_update_info(), kill_node_update_info(), nref_value(), set_default_node_update(), and vector_ref_value().

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

Public Member Functions

Private Member Functions

Private Attributes

Static Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ AlgebraicNode() [1/4]

◆ AlgebraicNode() [2/4]

◆ AlgebraicNode() [3/4]

◆ ~AlgebraicNode()

◆ AlgebraicNode() [4/4]

Member Function Documentation

◆ add_node_update_info() [1/2]

◆ add_node_update_info() [2/2]

◆ all_geom_object_pt()

◆ geom_object_pt()

◆ kill_node_update_info()

◆ mesh_pt() [1/2]

◆ mesh_pt() [2/2]

◆ ngeom_object() [1/2]

◆ ngeom_object() [2/2]

◆ nnode_update_fcts()

◆ node_update()

◆ node_update_fct_id() [1/2]

◆ node_update_fct_id() [2/2]

◆ nref_value() [1/2]

◆ nref_value() [2/2]

◆ ref_value()

◆ self_test()

◆ set_default_node_update()

◆ vector_geom_object_pt() [1/2]

◆ vector_geom_object_pt() [2/2]

◆ vector_ref_value() [1/2]

◆ vector_ref_value() [2/2]

Member Data Documentation

◆ Default_it_geom_object_pt

◆ Default_it_mesh_pt

◆ Default_it_ref_value

◆ Default_node_update_fct_id

◆ Dummy_geom_object_pt

◆ Dummy_mesh

◆ Dummy_mesh_pt

◆ Dummy_node_update_fct_id

◆ Dummy_ref_value

◆ Geom_object_pt

◆ Max_allowed_difference_between_node_update_fcts

◆ Mesh_pt

◆ Ref_value