#include <nodes.h>

Inheritance diagram for oomph::Node:

Public Types
typedef void(*	AuxNodeUpdateFctPt) (Node *)
	Function pointer to auxiliary node update function. More...

Public Member Functions
	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

virtual void	node_update (const bool &update_all_time_levels_for_new_node=false)

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 ()

virtual unsigned	ngeom_object () const

virtual GeomObject **	all_geom_object_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)

Static Public Attributes
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
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
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

Friends
class	BoundaryNodeBase
	to construct periodic Nodes More...

std::ostream &	operator<< (std::ostream &out, const Node &d)

Additional Inherited Members
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

Nodes are derived from Data, but, in addition, have a definite (Eulerian) position in a space of a given dimension.

The nodal coordinates are used in the elements' mapping between local and global coordinates and in the simplest case (stationary nodes in Lagrange-type elements) this mapping is given by

\[ x_i = \sum_{j=1}^{N_{node}} X_{ij} \psi_{j}(s_k) \]

so we need only access to the nodal coordinates \( X_{ij}\ (i=1..DIM) \) of all nodes \( j \) : provided by the Node member function

Node::x(i)

i

int i

Definition: BiCGSTAB_step_by_step.cpp:9

oomph::Node::x

double & x(const unsigned &i)

Return the i-th nodal coordinate.

Definition: nodes.h:1060

If the nodal positions are time-dependent, the mapping becomes

\[ x_i(t) = \sum_{j=1}^{N_{node}} X_{ij}(t) \ \psi_{j}(s_k). \]

Within the computation (where time is only evaluated at discrete levels) this becomes

\[ x_{ti} = \sum_{j=1}^{N_{node}} X_{ijt} \ \psi_{j}(s_k). \]

and we need access to the nodal coordinates \( X_{ijt} \ (i=1..DIM) \) of all nodes \( j \) at the present (t=0) and previous (t>0) timesteps: provided by the Node member function

Node::x(t,i)

plotPSD.t

t

Definition: plotPSD.py:36

Note: The interpretation of the history values is slightly more subtle than that. Depending on the positional TimeStepper used, only a limited number of the positional history values accessed Node::x(t,i) represent previous nodal positions; the others are generalised history values that the TimeStepper uses to determine approximations for the time-derivatives of the nodal positions.

Finally, some elements employ mappings that involve additional, generalised coordinates. For instance, in Hermite elements the mapping between local and global coordinates is based on an independent interpolation for the global coordinates and their derivative w.r.t. to the local coordinates. In such elements, the mapping becomes

\[ x_i = \sum_{j=1}^{N_{node}} \sum_{k=1}^{N_{type}} X_{ijk} \psi_{jk}(s_k) \]

where \( N_{type} \) is the number of the different types of generalised coordinates involved in the mapping. For instance, in 1D Hermite elements \( N_{type}=2 \) and k=0 corresponds to the global coordinates while k=1 corresponds to the derivative of the global coordinates w.r.t. to the local coordinate. In such cases we need access to the generalised nodal coordinates \( X_{ijk} \ (i=1..DIM, \ k=1..N_{type}) \) of all nodes \( j \). Access is provided by the Node member function

Node::x_gen(k,i)

oomph::Node::x_gen

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

Definition: nodes.h:1126

k

char char char int int * k

Definition: level2_impl.h:374

and the corresponding time-dependent version

Node::x_gen(t,k,i)

While this is all pretty straightforward, it does make the argument list of the Node constructors rather lengthy.

Member Typedef Documentation

◆ AuxNodeUpdateFctPt

typedef void(* oomph::Node::AuxNodeUpdateFctPt) (Node *)

Function pointer to auxiliary node update function.

Constructor & Destructor Documentation

◆ Node() [1/4]

oomph::Node::Node ( )

Default constructor.

     : Data(),
       Position_time_stepper_pt(Data::Default_static_time_stepper_pt),
       Hanging_pt(0),
       Ndim(0),
       Nposition_type(0),
       Obsolete(false),
       Aux_node_update_fct_pt(0)
   {
 #ifdef LEAK_CHECK
     LeakCheckNames::Node_build += 1;
 #endif
   }

◆ Node() [2/4]

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

Steady constructor, for a Node of spatial dimension n_dim. Allocates storage for initial_n_value values. NPosition_type is the number of coordinate types needed in the mapping between local and global coordinates (e.g. 1 for Lagrange-type elements; 2 for 1D Hermite elements; 4 for 2D Hermite elements, etc).

Steady Constructor, allocates storage for initial_n_value values at a node of spatial dimension NDim. nposition_type: # of coordinate types needed in the mapping between local and global coordinates (e.g. 1 for Lagrange-type elements; 2 for 1D Hermite elements; 4 for 2D Hermite elements, etc).

     : Data(initial_n_value),
       X_position(0),
       Position_time_stepper_pt(Data::Default_static_time_stepper_pt),
       Hanging_pt(0),
       Ndim(n_dim),
       Nposition_type(n_position_type),
       Obsolete(false),
       Aux_node_update_fct_pt(0)
   {
 #ifdef LEAK_CHECK
     LeakCheckNames::Node_build += 1;
 #endif
  
     // Determine the total amount of storage required for position variables
     const unsigned n_storage = n_dim * n_position_type;
  
     // If we are in charge of the x coordinates (non-solid node)
     // the allocate storage
     if (allocate_x_position)
     {
       // Allocate the pointers to each coordinate and coordinate type
       X_position = new double*[n_storage];
  
       // Create one big array of positions
       double* x_positions = new double[n_storage];
  
       // Set pointers from the contiguous array
       for (unsigned j = 0; j < n_storage; j++)
       {
         X_position[j] = &x_positions[j];
         // Initialise value to zero
         X_position[j][0] = 0.0;
       }
     }
   }

References j, and X_position.

◆ Node() [3/4]

oomph::Node::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`
	)

Unsteady constructor for a node of spatial dimension n_dim. Allocates storage for initial_n_value values with history values as required by the timestepper. n_position_type: # of coordinate types needed in the mapping between local and global coordinates (e.g. 1 for Lagrange-type elements; 2 for 1D Hermite elements; 4 for 2D Hermite elements).

Unsteady Constructor for a node of spatial dimension n_dim. Allocates storage for initial_n_value values with history values as required by timestepper. n_position_type: # of coordinate types needed in the mapping between local and global coordinates (e.g. 1 for Lagrange-type elements; 2 for 1D Hermite elements; 4 for 2D Hermite elements)

     : Data(time_stepper_pt_, initial_n_value),
       X_position(0),
       Position_time_stepper_pt(time_stepper_pt_),
       Hanging_pt(0),
       Ndim(n_dim),
       Nposition_type(n_position_type),
       Obsolete(false),
       Aux_node_update_fct_pt(0)
   {
 #ifdef LEAK_CHECK
     LeakCheckNames::Node_build += 1;
 #endif
  
     // Determine the total amount of storage required for position variables
     const unsigned n_storage = n_dim * n_position_type;
  
     // If we are allocating the storage (non-solid node)
     if (allocate_x_position)
     {
       // Amount of storage required for history values
       const unsigned n_tstorage = Position_time_stepper_pt->ntstorage();
  
       // Allocate the pointers to each coordinate and coordinate type
       X_position = new double*[n_storage];
  
       // Allocate the positions in one big array
       double* x_positions = new double[n_storage * n_tstorage];
  
       // Set the pointers to the contiguous memory
       for (unsigned j = 0; j < n_storage; j++)
       {
         // Set the pointer from the bug array
         X_position[j] = &x_positions[j * n_tstorage];
         // Initialise all values to zero
         for (unsigned t = 0; t < n_tstorage; t++)
         {
           X_position[j][t] = 0.0;
         }
       }
     }
   }

References j, oomph::TimeStepper::ntstorage(), Position_time_stepper_pt, plotPSD::t, and X_position.

◆ ~Node()

oomph::Node::~Node ( )

virtual

Destructor: Clean up the memory allocated for nodal position.

Destructor to clean up the memory allocated for nodal position.

   {
 #ifdef LEAK_CHECK
     LeakCheckNames::Node_build -= 1;
 #endif
  
     // Clean up memory allocated to hanging nodes
     if (Hanging_pt != 0)
     {
       // The number of hanging pointers is the number of values plus one
       const unsigned nhang = nvalue() + 1;
       for (unsigned ival = 1; ival < nhang; ival++)
       {
         // If the ival-th HangInfo object is not the same as the geometrical
         // one, delete it
         if (Hanging_pt[ival] != Hanging_pt[0])
         {
           delete Hanging_pt[ival];
         }
         // Always NULL out the HangInfo pointer
         Hanging_pt[ival] = 0;
       }
  
       // Delete the Geometrical HangInfo pointer
       delete Hanging_pt[0];
       Hanging_pt[0] = 0;
  
       // Delete the Hanging_pt
       delete[] Hanging_pt;
       Hanging_pt = 0;
     }
  
     // Free the memory allocated
  
     // If we did not allocate then the memory must have been freed by the
     // destructor of the object that did the allocating and X_position MUST
     // have been set back to zero
     // Test this and if so, we're done
     if (X_position == 0)
     {
       return;
     }
  
     // If we're still here we must free our own memory which was allocated
     // in one block
     delete[] X_position[0];
  
     // Now delete the pointer
     delete[] X_position;
     X_position = 0;
   }

References Hanging_pt, oomph::Data::nvalue(), and X_position.

◆ Node() [4/4]

oomph::Node::Node ( const Node & node )

delete

Broken copy constructor.

Member Function Documentation

◆ add_to_boundary()

void oomph::Node::add_to_boundary ( const unsigned & b )

virtual

Broken interface for adding the node to the mesh boundary b Essentially here for error reporting.

Interface for function to add the node to the mesh boundary b. Broken here in order to report run-time errors. Must be overloaded by all boundary nodes

   {
     std::stringstream ss;
     ss << "Cannot add non BoundaryNode<NODE> to boundary " << b << "\n";
     throw OomphLibError(
       ss.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
   }

References b, OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

Referenced by oomph::Mesh::add_boundary_node(), oomph::BackupMeshForProjection< GEOMETRIC_ELEMENT >::BackupMeshForProjection(), and oomph::RefineableSolidCubicMesh< ELEMENT >::RefineableSolidCubicMesh().

◆ all_geom_data_pt()

virtual Data** oomph::Node::all_geom_data_pt ( )

inlinevirtual

Return a pointer to an array of all (geometric) data that affect the nodal position. The default value is zero (node is stationary)

Reimplemented in oomph::SpineNode, and oomph::PerturbedSpineNode.

     {
       return 0;
     }

Referenced by oomph::ElementWithMovingNodes::assemble_set_of_all_geometric_data().

◆ all_geom_object_pt()

virtual GeomObject** oomph::Node::all_geom_object_pt ( )

inlinevirtual

Return a pointer to an array of all (geometric) objects that affect the nodal position. The default value is zero (node is stationary)

Reimplemented in oomph::SpineNode, oomph::MacroElementNodeUpdateNode, oomph::AlgebraicNode, and oomph::PerturbedSpineNode.

     {
       return 0;
     }

Referenced by oomph::ElementWithMovingNodes::assemble_set_of_all_geometric_data().

◆ assign_eqn_numbers()

void oomph::Node::assign_eqn_numbers	(	unsigned long &	global_number,
		Vector< double * > &	dof_pt
	)

virtual

Assign global equation numbers; increment global number of unknowns, global_ndof; and add any new dofs to the dof_pt.

Assign (global) equation number. Overloaded version for nodes. Checks if a hanging value has a non-negative equation number and if so shouts and then sets it to Is_constrained. Then drops down to Data version which does the actual work

Reimplemented from oomph::Data.

Reimplemented in oomph::SolidNode.

   {
     // Loop over the number of values
     const unsigned eqn_number_range = nvalue();
     for (unsigned i = 0; i < eqn_number_range; i++)
     {
       // Is it hanging and not constrained or pinned? If so shout and constrain
       // it
       if ((is_hanging(i)) && (!is_constrained(i)) && (!is_pinned(i)))
       {
 #ifdef PARANOID
         std::ostringstream warn_message;
         warn_message
           << "Node::assign_eqn_numbers(...) noticed that " << i
           << " -th value\n"
           << "is hanging but not constrained. This shouldn't happen and is\n"
           << "probably because a hanging value was unpinned manually\n"
           << "Rectifying this now...\n";
         OomphLibWarning(
           warn_message.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
 #endif
         constrain(i);
       }
     }
     // Now descend
     Data::assign_eqn_numbers(global_number, dof_pt);
   }

References oomph::Data::assign_eqn_numbers(), oomph::Data::constrain(), i, oomph::Data::is_constrained(), is_hanging(), oomph::Data::is_pinned(), oomph::Data::nvalue(), OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

◆ boundary_coordinates_have_been_set_up()

bool oomph::Node::boundary_coordinates_have_been_set_up ( )

virtual

Have boundary coordinates been set up? Broken virtual interface provides run-time error checking

Interface for function to report if boundary coordinates have been set up for this node Broken here in order to report run-time errors. Must be overloaded by all boundary nodes

   {
     std::stringstream ss;
     ss << "Node (bas class) can't have boundary coordinates\n";
     throw OomphLibError(
       ss.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
   }

References OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

◆ constrain_positions()

virtual void oomph::Node::constrain_positions ( )

inlinevirtual

Constrain the positions when the node is made hanging Empty virtual function that is overloaded in SolidNodes

Reimplemented in oomph::SolidNode.

1345 {}

Referenced by set_hanging_pt().

◆ copied_node_pt()

virtual Node* oomph::Node::copied_node_pt ( ) const

inlinevirtual

Return pointer to copied node (null if the current node is not a copy – always the case here; it's overloaded for boundary nodes)

     {
       return 0;
     }

Referenced by oomph::FourierDecomposedHelmholtzDtNBoundaryElement< ELEMENT >::complete_setup_of_dependencies(), oomph::HelmholtzDtNBoundaryElement< ELEMENT >::complete_setup_of_dependencies(), SurfactantProblem< ELEMENT, INTERFACE_ELEMENT >::create_dependent_position_elements(), SurfactantProblem< ELEMENT, INTERFACE_ELEMENT >::create_slave_position_elements(), and oomph::BoundaryNodeBase::make_node_periodic().

◆ copy()

void oomph::Node::copy ( Node * orig_node_pt )

Copy all nodal data from specified Node object.

   {
     // Number of positional values
     const unsigned npos_storage = Ndim * Nposition_type;
  
     // Check # of values:
     const unsigned long npos_storage_orig =
       orig_node_pt->ndim() * orig_node_pt->nposition_type();
     if (npos_storage != npos_storage_orig)
     {
       std::ostringstream error_stream;
       error_stream << "The allocated positional storage " << npos_storage
                    << " is not the same as the original Node "
                    << npos_storage_orig << std::endl;
  
       throw OomphLibError(
         error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
  
     // Number of time values (incl present)
     const unsigned n_time = Position_time_stepper_pt->ntstorage();
  
     // Check # of values:
     const unsigned long n_time_orig =
       orig_node_pt->position_time_stepper_pt()->ntstorage();
     if (n_time != n_time_orig)
     {
       std::ostringstream error_stream;
       error_stream << "The number of positional time history values, " << n_time
                    << " is not the same of those in the original node "
                    << n_time_orig << std::endl;
  
       throw OomphLibError(
         error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
  
     // Copy fixed nodal positions
     for (unsigned t = 0; t < n_time; t++)
     {
       for (unsigned j = 0; j < npos_storage; j++)
       {
         X_position[j][t] = orig_node_pt->X_position[j][t];
       }
     }
  
     //  Read associated data
     Data::copy(orig_node_pt);
   }

References oomph::Data::copy(), j, Ndim, ndim(), Nposition_type, nposition_type(), oomph::TimeStepper::ntstorage(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, Position_time_stepper_pt, position_time_stepper_pt(), plotPSD::t, and X_position.

Referenced by oomph::Mesh::convert_to_boundary_node(), and oomph::Problem::copy().

◆ does_pointer_correspond_to_position_data()

virtual bool oomph::Node::does_pointer_correspond_to_position_data ( double *const & parameter_pt )

inlinevirtual

Check whether the pointer parameter_pt addresses position data values. It never does for a standard node, because the positions are not data

Reimplemented in oomph::SolidNode.

     {
       return false;
     }

◆ dposition_dt() [1/2]

double oomph::Node::dposition_dt ( const unsigned & i ) const

Return the i-th component of nodal velocity: dx/dt, either directly or via hanging node representation.

Return the i-th component of nodal velocity: dx/dt / Use the hanging node representation if required.

   {
     // Number of timsteps (past & present)
     const unsigned n_time = Position_time_stepper_pt->ntstorage();
  
     double dxdt = 0.0;
  
     // If the timestepper is not steady
     if (!Position_time_stepper_pt->is_steady())
     {
       // Loop over the additional storage and add the appropriate contributions
       for (unsigned t = 0; t < n_time; t++)
       {
         dxdt += Position_time_stepper_pt->weight(1, t) * position(t, i);
       }
     }
  
     return dxdt;
   }

References i, oomph::TimeStepper::is_steady(), oomph::TimeStepper::ntstorage(), position(), Position_time_stepper_pt, plotPSD::t, and oomph::TimeStepper::weight().

Referenced by oomph::FSI_functions::apply_no_slip_on_moving_wall(), oomph::FiniteElement::dnodal_position_dt(), and FSIChannelWithLeafletProblem< ELEMENT >::doc_solution().

◆ dposition_dt() [2/2]

double oomph::Node::dposition_dt	(	const unsigned &	j,
		const unsigned &	i
	)		const

Return the i-th component of j-th derivative of nodal position: d^jx/dt^j either directly or via hanging node representation

Return the i-th component of j-th derivative of nodal position: d^jx/dt^j. Use the hanging node representation.

   {
     // Number of timsteps (past & present)
     const unsigned n_time = Position_time_stepper_pt->ntstorage();
  
     double dxdt = 0.0;
  
     // If the timestepper is not steady
     if ((!Position_time_stepper_pt->is_steady()) || (j == 0))
     {
       // Loop over the additional storage and add the appropriate contributions
       for (unsigned t = 0; t < n_time; t++)
       {
         dxdt += Position_time_stepper_pt->weight(j, t) * position(t, i);
       }
     }
  
     return dxdt;
   }

References i, oomph::TimeStepper::is_steady(), j, oomph::TimeStepper::ntstorage(), position(), Position_time_stepper_pt, plotPSD::t, and oomph::TimeStepper::weight().

◆ dposition_gen_dt() [1/2]

double oomph::Node::dposition_gen_dt	(	const unsigned &	j,
		const unsigned &	k,
		const unsigned &	i
	)		const

i-th component of j-th time derivative (velocity) of the generalised position, d^jx(k,i)/dt^j. ‘Type’: k; Coordinate direction: i. This function uses the hanging node representation if necessary

i-th component of j-th time derivative (velocity) of the generalised position, d^jx(k,i)/dt^j. ‘Type’: k; Coordinate direction: i. Use the hanging node representation.

   {
     // Number of timsteps (past & present)
     const unsigned n_time = Position_time_stepper_pt->ntstorage();
  
     double dxdt = 0.0;
  
     // If the timestepper is not steady
     if ((!Position_time_stepper_pt->is_steady()) || (j == 0))
     {
       // Loop over the additional storage and add the appropriate contributions
       for (unsigned t = 0; t < n_time; t++)
       {
         dxdt += Position_time_stepper_pt->weight(j, t) * position_gen(t, k, i);
       }
     }
  
     return dxdt;
   }

References i, oomph::TimeStepper::is_steady(), j, k, oomph::TimeStepper::ntstorage(), position_gen(), Position_time_stepper_pt, plotPSD::t, and oomph::TimeStepper::weight().

◆ dposition_gen_dt() [2/2]

double oomph::Node::dposition_gen_dt	(	const unsigned &	k,
		const unsigned &	i
	)		const

i-th component of time derivative (velocity) of the generalised position, dx(k,i)/dt. ‘Type’: k; Coordinate direction: i. This function uses the hanging node representation if necessary.

i-th component of time derivative (velocity) of the generalised position, dx(k,i)/dt. ‘Type’: k; Coordinate direction: i. Use the hanging node representation

   {
     // Number of timsteps (past & present)
     const unsigned n_time = Position_time_stepper_pt->ntstorage();
  
     double dxdt = 0.0;
  
     // If the timestepper is not steady
     if (!Position_time_stepper_pt->is_steady())
     {
       // Loop over the additional time storage and add the appropriate
       // contributions
       for (unsigned t = 0; t < n_time; t++)
       {
         dxdt += Position_time_stepper_pt->weight(1, t) * position_gen(t, k, i);
       }
     }
  
     return dxdt;
   }

References i, oomph::TimeStepper::is_steady(), k, oomph::TimeStepper::ntstorage(), position_gen(), Position_time_stepper_pt, plotPSD::t, and oomph::TimeStepper::weight().

Referenced by oomph::FiniteElement::dnodal_position_gen_dt().

◆ dump()

void oomph::Node::dump ( std::ostream & dump_file ) const

virtual

Dump nodal position and associated data to file for restart.

Dump nodal positions and associated data to file for restart.

Reimplemented in oomph::SolidNode.

   {
     // Number of positional values
     const unsigned npos_storage = Ndim * Nposition_type;
     dump_file << npos_storage << " # number of fixed position variables"
               << std::endl;
  
     const unsigned Time_steps_range = Position_time_stepper_pt->ntstorage();
     dump_file << Time_steps_range
               << " # total number of doubles for time history (incl present)"
               << std::endl;
  
     for (unsigned t = 0; t < Time_steps_range; t++)
     {
       for (unsigned j = 0; j < npos_storage; j++)
       {
         dump_file << X_position[j][t] << std::endl;
       }
     }
  
     // Dump out data
     Data::dump(dump_file);
   }

References oomph::Data::dump(), j, Ndim, Nposition_type, oomph::TimeStepper::ntstorage(), Position_time_stepper_pt, plotPSD::t, and X_position.

Referenced by oomph::SolidNode::dump().

◆ dx_dt() [1/2]

double oomph::Node::dx_dt ( const unsigned & i ) const

Return the i-th component of nodal velocity: dx/dt.

   {
     // Number of timsteps (past & present)
     const unsigned n_time = Position_time_stepper_pt->ntstorage();
  
     double dxdt = 0.0;
  
     // If the timestepper is not steady
     if (!Position_time_stepper_pt->is_steady())
     {
       // Loop over the additional storage and add the appropriate contributions
       for (unsigned t = 0; t < n_time; t++)
       {
         dxdt += Position_time_stepper_pt->weight(1, t) * x(t, i);
       }
     }
  
     return dxdt;
   }

References i, oomph::TimeStepper::is_steady(), oomph::TimeStepper::ntstorage(), Position_time_stepper_pt, plotPSD::t, oomph::TimeStepper::weight(), and x().

Referenced by oomph::FiniteElement::raw_dnodal_position_dt().

◆ dx_dt() [2/2]

double oomph::Node::dx_dt	(	const unsigned &	j,
		const unsigned &	i
	)		const

Return the i-th component of j-th derivative of nodal position: d^jx/dt^j.

   {
     // Number of timsteps (past & present)
     const unsigned n_time = Position_time_stepper_pt->ntstorage();
  
     double dxdt = 0.0;
  
     // If the timestepper is not steady
     if ((!Position_time_stepper_pt->is_steady()) || (j == 0))
     {
       // Loop over the additional storage and add the appropriate contributions
       for (unsigned t = 0; t < n_time; t++)
       {
         dxdt += Position_time_stepper_pt->weight(j, t) * x(t, i);
       }
     }
  
     return dxdt;
   }

References i, oomph::TimeStepper::is_steady(), j, oomph::TimeStepper::ntstorage(), Position_time_stepper_pt, plotPSD::t, oomph::TimeStepper::weight(), and x().

◆ dx_gen_dt() [1/2]

double oomph::Node::dx_gen_dt	(	const unsigned &	j,
		const unsigned &	k,
		const unsigned &	i
	)		const

i-th component of j-th time derivative (velocity) of the generalised position, d^jx(k,i)/dt^j. ‘Type’: k; Coordinate direction: i.

   {
     // Number of timsteps (past & present)
     const unsigned n_time = Position_time_stepper_pt->ntstorage();
  
     double dxdt = 0.0;
  
     // If the timestepper is not steady
     if ((!Position_time_stepper_pt->is_steady()) || (j == 0))
     {
       // Loop over the additional storage and add the appropriate contributions
       for (unsigned t = 0; t < n_time; t++)
       {
         dxdt += Position_time_stepper_pt->weight(j, t) * x_gen(t, k, i);
       }
     }
  
     return dxdt;
   }

References i, oomph::TimeStepper::is_steady(), j, k, oomph::TimeStepper::ntstorage(), Position_time_stepper_pt, plotPSD::t, oomph::TimeStepper::weight(), and x_gen().

◆ dx_gen_dt() [2/2]

double oomph::Node::dx_gen_dt	(	const unsigned &	k,
		const unsigned &	i
	)		const

i-th component of time derivative (velocity) of the generalised position, dx(k,i)/dt. ‘Type’: k; Coordinate direction: i.

   {
     // Number of timsteps (past & present)
     const unsigned n_time = Position_time_stepper_pt->ntstorage();
  
     double dxdt = 0.0;
  
     // If the timestepper is not steady
     if (!Position_time_stepper_pt->is_steady())
     {
       // Loop over the additional time storage and add the appropriate
       // contributions
       for (unsigned t = 0; t < n_time; t++)
       {
         dxdt += Position_time_stepper_pt->weight(1, t) * x_gen(t, k, i);
       }
     }
  
     return dxdt;
   }

References i, oomph::TimeStepper::is_steady(), k, oomph::TimeStepper::ntstorage(), Position_time_stepper_pt, plotPSD::t, oomph::TimeStepper::weight(), and x_gen().

Referenced by oomph::FiniteElement::raw_dnodal_position_gen_dt().

◆ get_boundaries_pt()

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

inlinevirtual

Return a pointer to set of mesh boundaries that this node occupies; this will be overloaded by BoundaryNodes. The default behaviour is that the Node does not lie on any boundaries so the pointer to the set of boundaries is NULL

     {
       boundaries_pt = 0;
     }

Referenced by oomph::TreeBasedRefineableMeshBase::adapt_mesh(), oomph::GmshTetMesh< ELEMENT >::build_from_scaffold(), oomph::GeompackQuadMesh< ELEMENT >::build_from_scaffold(), oomph::SimpleCubicTetMesh< ELEMENT >::build_from_scaffold(), oomph::TetgenMesh< ELEMENT >::build_from_scaffold(), oomph::TriangleMesh< ELEMENT >::build_from_scaffold(), oomph::QuadFromTriangleMesh< ELEMENT >::build_from_scaffold(), oomph::ExtrudedCubeMeshFromQuadMesh< ELEMENT >::build_mesh(), oomph::Mesh::copy_boundary_node_data_from_nodes(), FpTestProblem::FpTestProblem(), oomph::TFace::get_boundaries_pt(), MortaringHelpers::MergedSolidMesh::MergedSolidMesh(), oomph::TreeBasedRefineableMeshBase::p_adapt_mesh(), oomph::BrickMeshBase::setup_boundary_element_info(), oomph::LineMeshBase::setup_boundary_element_info(), oomph::QuadMeshBase::setup_boundary_element_info(), oomph::TetMeshBase::setup_boundary_element_info(), oomph::TriangleMeshBase::setup_boundary_element_info(), oomph::HermiteQuadMesh< ELEMENT >::setup_boundary_element_info(), and oomph::ThinLayerBrickOnTetMesh< ELEMENT >::ThinLayerBrickOnTetMesh().

◆ get_coordinates_on_boundary() [1/2]

void oomph::Node::get_coordinates_on_boundary	(	const unsigned &	b,
		const unsigned &	k,
		Vector< double > &	boundary_zeta
	)

virtual

Return the vector of the k-th generalised boundary coordinates on mesh boundary b. Broken virtual interface provides run-time error checking

Interface for function to get the k-th generalised boundary coordinate of the node on boundary b. Broken here in order to provide run-time error reporting. Must be overloaded by all boundary nodes.

   {
     throw OomphLibError("Non-boundary Node cannot have boundary coordinates",
                         OOMPH_CURRENT_FUNCTION,
                         OOMPH_EXCEPTION_LOCATION);
   }

References OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

Referenced by UnstructuredTorusProblem< ELEMENT >::actions_after_adapt(), PrescribedBoundaryDisplacementProblem< ELEMENT >::actions_before_newton_solve(), AxisymmetricVibratingShellProblem< ELEMENT >::AxisymmetricVibratingShellProblem(), oomph::BackupMeshForProjection< GEOMETRIC_ELEMENT >::BackupMeshForProjection(), oomph::TwoLayerSpineMesh< BASE_ELEMENT >::build_two_layer_mesh(), ContactProblem< ELEMENT >::create_displ_imposition_elements(), oomph::DiskTetMeshFacetedSurface::DiskTetMeshFacetedSurface(), oomph::DiskWithTorusAroundEdgeTetMeshFacetedSurface::DiskWithTorusAroundEdgeTetMeshFacetedSurface(), ElasticTwoLayerMesh< ELEMENT >::ElasticTwoLayerMesh(), get_coordinates_on_boundary(), oomph::TriangleMesh< ELEMENT >::output_boundary_coordinates(), oomph::UnstructuredTwoDMeshGeometryBase::setup_boundary_coordinates(), oomph::RefineableTetgenMesh< ELEMENT >::snap_nodes_onto_boundary(), oomph::TetMeshBase::snap_nodes_onto_geometric_objects(), oomph::UnstructuredTwoDMeshGeometryBase::snap_nodes_onto_geometric_objects(), oomph::TetMeshBase::snap_to_quadratic_surface(), VibratingShellProblem< ELEMENT >::VibratingShellProblem(), oomph::FaceElement::zeta_nodal(), and oomph::GenericLagrangeInterpolatedProjectableElement< ELEMENT >::zeta_nodal().

◆ get_coordinates_on_boundary() [2/2]

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

inlinevirtual

Return the vector of coordinates on mesh boundary b Broken virtual interface provides run-time error checking

     {
       get_coordinates_on_boundary(b, 0, boundary_zeta);
     }

References b, and get_coordinates_on_boundary().

◆ hang_code()

unsigned oomph::Node::hang_code ( )

inline

Code that encapsulates the hanging status of the node (incl. the geometric hanging status) as \( \sum_{i=-1}{nval-1} Node::is_hanging(i) 2^{i+1} \)

     {
       unsigned hang_code = 0;
       int nval = nvalue();
       for (int i = -1; i < nval; i++)
       {
         hang_code += unsigned(Node::is_hanging(i)) *
                      unsigned(std::pow(2.0, double(i + 1)));
       }
       return hang_code;
     }

References i, is_hanging(), oomph::Data::nvalue(), and Eigen::bfloat16_impl::pow().

◆ hanging_pt() [1/2]

HangInfo* const& oomph::Node::hanging_pt ( ) const

inline

Return pointer to hanging node data (this refers to the geometric hanging node status) (const version).

     {
 #ifdef PARANOID
       if (Hanging_pt == 0)
       {
         throw OomphLibError(
           "Vector of pointers to hanging data is not setup yet\n",
           OOMPH_CURRENT_FUNCTION,
           OOMPH_EXCEPTION_LOCATION);
       }
 #endif
       return Hanging_pt[0];
     }

References Hanging_pt, OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

◆ hanging_pt() [2/2]

HangInfo* const& oomph::Node::hanging_pt ( const int & i ) const

inline

Return pointer to hanging node data for value i (const version)

     {
 #ifdef PARANOID
       if (Hanging_pt == 0)
       {
         std::ostringstream error_message;
         error_message << "Vector of pointers to hanging data is not setup yet\n"
 #ifdef OOMPH_HAS_MPI
                       << "I'm on processor "
                       << MPI_Helpers::communicator_pt()->my_rank() << "\n"
 #endif
                       << "Coordinates: \n";
  
         unsigned n_dim = ndim();
         for (unsigned i = 0; i < n_dim; i++)
         {
           error_message << this->x(i) << " ";
         }
         throw OomphLibError(error_message.str(),
                             OOMPH_CURRENT_FUNCTION,
                             OOMPH_EXCEPTION_LOCATION);
       }
 #endif
 #ifdef RANGE_CHECKING
       // Range checking code.
       // Need to make sure that this is an int otherwise the test
       // fails when it shouldn't
       const int n_value = static_cast<int>(this->nvalue());
       if ((i < -1) || (i > n_value))
       {
         std::ostringstream error_message;
         error_message << "Range Error: Value " << i
                       << " is not in the range (-1," << n_value << ")";
         throw OomphLibError(error_message.str(),
                             OOMPH_CURRENT_FUNCTION,
                             OOMPH_EXCEPTION_LOCATION);
       }
 #endif
       return Hanging_pt[i + 1];
     }

References oomph::MPI_Helpers::communicator_pt(), Hanging_pt, i, oomph::OomphCommunicator::my_rank(), ndim(), oomph::Data::nvalue(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, and x().

◆ has_auxiliary_node_update_fct_pt()

bool oomph::Node::has_auxiliary_node_update_fct_pt ( )

inline

Boolean to indicate if node has a pointer to and auxiliary update function.

     {
       return (Aux_node_update_fct_pt != 0);
     }

References Aux_node_update_fct_pt.

◆ is_hanging() [1/2]

bool oomph::Node::is_hanging ( ) const

inline

Test whether the node is geometrically hanging.

     {
       if (Hanging_pt == 0)
       {
         return false;
       }
       else
       {
         return (Hanging_pt[0] != 0);
       }
     }

References Hanging_pt.

◆ is_hanging() [2/2]

bool oomph::Node::is_hanging ( const int & i ) const

inline

Test whether the i-th value is hanging.

     {
 #ifdef RANGE_CHECKING
       // Need to make sure that this is an int otherwise the test
       // fails when it shouldn't
       const int n_value = static_cast<int>(this->nvalue());
       if ((i < -1) || (i > n_value))
       {
         std::ostringstream error_message;
         error_message << "Range Error: Value " << i
                       << " is not in the range (-1," << n_value << ")";
         throw OomphLibError(error_message.str(),
                             OOMPH_CURRENT_FUNCTION,
                             OOMPH_EXCEPTION_LOCATION);
       }
 #endif
  
       // Test whether the node is geometrically hanging
       if (i == -1)
       {
         return is_hanging();
       }
       // Otherwise, is the i-th value hanging
       else
       {
         if (Hanging_pt == 0)
         {
           return false;
         }
         else
         {
           return (Hanging_pt[i + 1] != 0);
         }
       }
     }

References Hanging_pt, i, is_hanging(), oomph::Data::nvalue(), OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

◆ is_obsolete()

bool oomph::Node::is_obsolete ( )

inline

Test whether node is obsolete.

     {
       return Obsolete;
     }

References Obsolete.

◆ is_on_boundary() [1/2]

virtual bool oomph::Node::is_on_boundary ( ) const

inlinevirtual

Test whether the Node lies on a boundary. The "bulk" Node cannot lie on a boundary, so return false. This will be overloaded by BoundaryNodes

     {
       return false;
     }

Referenced by SurfactantProblem< ELEMENT, INTERFACE_ELEMENT >::actions_after_adapt(), SurfactantProblem< ELEMENT, INTERFACE_ELEMENT >::actions_before_implicit_timestep(), oomph::TreeBasedRefineableMeshBase::adapt_mesh(), STSpineMesh< ELEMENT, INTERFACE_ELEMENT >::add_mesh(), AxialSolidQuarterTubeMesh< ELEMENT, INTERFACE_ELEMENT >::AxialSolidQuarterTubeMesh(), AxialSpineQuarterTubeMesh< ELEMENT, INTERFACE_ELEMENT >::AxialSpineQuarterTubeMesh(), AxisymmetricVibratingShellProblem< ELEMENT >::AxisymmetricVibratingShellProblem(), oomph::BackupMeshForProjection< GEOMETRIC_ELEMENT >::BackupMeshForProjection(), oomph::BackwardStepQuadMesh< ELEMENT >::build_mesh(), oomph::ExtrudedCubeMeshFromQuadMesh< ELEMENT >::build_mesh(), oomph::BrickFromTetMesh< ELEMENT >::build_mesh(), CapProblem< ELEMENT >::CapProblem(), CombTipSpineMesh< ELEMENT, INTERFACE_ELEMENT >::change_boundaries(), DarcyProblem< ELEMENT >::complete_problem_setup(), AxisymmetricVibratingShellProblem< ELEMENT >::complete_problem_setup(), VibratingShellProblem< ELEMENT >::complete_problem_setup(), oomph::Mesh::copy_boundary_node_data_from_nodes(), SurfactantProblem< ELEMENT, INTERFACE_ELEMENT >::create_dependent_position_elements(), ContactProblem< ELEMENT >::create_displ_imposition_elements(), RefineableRotatingCylinderProblem< ELEMENT >::create_free_surface_elements(), FSICollapsibleChannelProblem< ELEMENT >::create_lagrange_multiplier_elements(), PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::create_lagrange_multiplier_elements(), FSIChannelWithLeafletProblem< ELEMENT >::create_lagrange_multiplier_elements(), UnstructuredFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::create_lagrange_multiplier_elements(), PrescribedBoundaryDisplacementProblem< ELEMENT >::create_lagrange_multiplier_elements(), CollapsibleChannelProblem< ELEMENT >::create_lagrange_multiplier_elements(), TiltedCavityProblem< ELEMENT >::create_parall_outflow_lagrange_elements(), SurfactantProblem< ELEMENT, INTERFACE_ELEMENT >::create_slave_position_elements(), oomph::DiskTetMeshFacetedSurface::DiskTetMeshFacetedSurface(), FpTestProblem::FpTestProblem(), oomph::Edge::is_on_boundary(), oomph::TFace::is_on_boundary(), WallMesh< ELEMENT >::max_deformation(), oomph::MeshHelper::merge_spine_meshes(), MortaringHelpers::MergedSolidMesh::MergedSolidMesh(), WallMesh< ELEMENT >::min_deformation(), oomph::TreeBasedRefineableMeshBase::p_adapt_mesh(), oomph::MGSolver< DIM >::plot(), PressureWaveFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::PressureWaveFSIProblem(), BrethertonElement< ELEMENT >::reassign_inflow(), oomph::RefineableQuadMeshWithMovingCylinder< ELEMENT >::RefineableQuadMeshWithMovingCylinder(), AxiPoroProblem< ELEMENT, TIMESTEPPER >::set_boundary_values(), oomph::TetMeshBase::snap_to_quadratic_surface(), SurfactantProblem< ELEMENT, INTERFACE_ELEMENT >::SurfactantProblem(), SurfactantProblem< ELEMENT, INTERFACE_ELEMENT >::unpin_surface(), UnstructuredFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::UnstructuredFSIProblem(), VibratingShellProblem< ELEMENT >::VibratingShellProblem(), WallMesh< ELEMENT >::WallMesh(), and oomph::TwoDAnnularMesh< ELEMENT >::wrap_into_annular_shape().

◆ is_on_boundary() [2/2]

virtual bool oomph::Node::is_on_boundary ( const unsigned & b ) const

inlinevirtual

Test whether the node lies on mesh boundary b. The "bulk" Node cannot lie on a boundary, so return false. This will be overloaded by BoundaryNodes

     {
       return false;
     }

◆ make_periodic()

void oomph::Node::make_periodic ( Node *const & node_pt )

virtual

Make the node periodic by copying the values from node_pt. Note that the coordinates will always remain independent, even though this may lead to (a little) unrequired information being stored. Broken virtual (only implemented in BoundaryNodes)

Make the node periodic by copying values from node_pt. Broken virtual (only implemented in BoundaryNodes)

   {
     throw OomphLibError("Only BoundaryNodes can be made periodic",
                         OOMPH_CURRENT_FUNCTION,
                         OOMPH_EXCEPTION_LOCATION);
   }

References OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

Referenced by NavierStokesProblem< ELEMENT >::apply_boundary_conditions(), oomph::RefineableQElement< 3 >::build(), oomph::RefineableQElement< 2 >::build(), UnsteadyHeatProblem< ELEMENT >::enforce_time_periodic_boundary_conditions(), oomph::PRefineableQElement< 2, INITIAL_NNODE_1D >::p_refine(), oomph::PRefineableQElement< 3, INITIAL_NNODE_1D >::p_refine(), and oomph::PeriodicOrbitTemporalMesh< ELEMENT >::PeriodicOrbitTemporalMesh().

◆ make_periodic_nodes()

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

virtual

Make the nodes passed in the vector periodic_nodes share the same data as this node.

Make the nodes passed in periodic_nodes_pt periodic by copying values across from this node. At present all the positions will be assumed to be independent. Broken virtual (only implemented in BoundaryNodes)

   {
     throw OomphLibError("Only BoundaryNodes can make periodic nodes",
                         OOMPH_CURRENT_FUNCTION,
                         OOMPH_EXCEPTION_LOCATION);
   }

References OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

◆ ncoordinates_on_boundary()

unsigned oomph::Node::ncoordinates_on_boundary ( const unsigned & b )

virtual

Get the number of boundary coordinates on mesh boundary b. Broken virtual interface provides run-time error checking

Interface to get the number of boundary coordinates on mesh boundary b. Broken here in order to provide run-time error reporting. Must be overloaded by all boundary nodes.

   {
     throw OomphLibError("Non-boundary Node cannot have boundary coordinates",
                         OOMPH_CURRENT_FUNCTION,
                         OOMPH_EXCEPTION_LOCATION);
     // dummy return
     return 0;
   }

References OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

Referenced by oomph::BackupMeshForProjection< GEOMETRIC_ELEMENT >::BackupMeshForProjection(), oomph::TwoLayerSpineMesh< BASE_ELEMENT >::build_two_layer_mesh(), and ElasticTwoLayerMesh< ELEMENT >::ElasticTwoLayerMesh().

◆ ndim()

unsigned oomph::Node::ndim ( ) const

inline

Return (Eulerian) spatial dimension of the node.

     {
       return Ndim;
     }

References Ndim.

◆ ngeom_data()

virtual unsigned oomph::Node::ngeom_data ( ) const

inlinevirtual

Return the number of geometric data that affect the nodal position. The default value is zero (node is stationary)

Reimplemented in oomph::SpineNode, and oomph::PerturbedSpineNode.

     {
       return 0;
     }

Referenced by oomph::ElementWithMovingNodes::assemble_set_of_all_geometric_data().

◆ ngeom_object()

virtual unsigned oomph::Node::ngeom_object ( ) const

inlinevirtual

Return the number of geometric objects that affect the nodal position. The default value is zero (node is stationary)

Reimplemented in oomph::SpineNode, oomph::MacroElementNodeUpdateNode, oomph::AlgebraicNode, and oomph::PerturbedSpineNode.

     {
       return 0;
     }

Referenced by oomph::ElementWithMovingNodes::assemble_set_of_all_geometric_data().

◆ node_update()

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

inlinevirtual

Interface for functions that update the nodal position using algebraic remeshing strategies. The interface is common to SpineNodes, AlgebraicNodes and MacroElementNodeUpdateNodes. The default is that the node does not "update itself" i.e. it is fixed in space. When implemented, this function should also execute the Node's auxiliary node update function (if any).

Reimplemented in oomph::SpineNode, oomph::SolidNode, oomph::MacroElementNodeUpdateNode, oomph::AlgebraicNode, and oomph::PerturbedSpineNode.

1588 {

1589 }

Referenced by main(), and oomph::FiniteElement::node_update().

◆ nposition_type()

unsigned oomph::Node::nposition_type ( ) const

inline

Number of coordinate types needed in the mapping between local and global coordinates.

     {
       return Nposition_type;
     }

References Nposition_type.

Referenced by oomph::SelfStartingBDF2::assign_initial_positions_impulsive(), oomph::Steady< NSTEPS >::assign_initial_positions_impulsive(), oomph::Newmark< NSTEPS >::assign_initial_positions_impulsive(), oomph::BDF< NSTEPS >::assign_initial_positions_impulsive(), oomph::BackupMeshForProjection< GEOMETRIC_ELEMENT >::BackupMeshForProjection(), oomph::RefineableQElement< 3 >::build(), oomph::RefineableQElement< 1 >::build(), oomph::RefineableQElement< 2 >::build(), copy(), oomph::PRefineableQElement< 1, INITIAL_NNODE_1D >::p_refine(), oomph::PRefineableQElement< 2, INITIAL_NNODE_1D >::p_refine(), oomph::PRefineableQElement< 3, INITIAL_NNODE_1D >::p_refine(), oomph::ProjectionProblem< PROJECTABLE_ELEMENT >::pin_all(), oomph::ProjectionProblem< PROJECTABLE_ELEMENT >::pin_dofs_of_coordinate(), oomph::ProjectionProblem< PROJECTABLE_ELEMENT >::project(), oomph::ProjectionProblem< PROJECTABLE_ELEMENT >::restore_positions(), oomph::Problem::set_pinned_values_to_zero(), set_position_time_stepper(), oomph::SelfStartingBDF2::shift_time_positions(), oomph::IMRBase::shift_time_positions(), oomph::Steady< NSTEPS >::shift_time_positions(), oomph::Newmark< NSTEPS >::shift_time_positions(), oomph::NewmarkBDF< NSTEPS >::shift_time_positions(), oomph::BDF< NSTEPS >::shift_time_positions(), oomph::ProjectionProblem< PROJECTABLE_ELEMENT >::store_positions(), oomph::ProjectionProblem< PROJECTABLE_ELEMENT >::unpin_all(), and oomph::ProjectionProblem< PROJECTABLE_ELEMENT >::unpin_dofs_of_coordinate().

◆ operator=()

void oomph::Node::operator= ( const Node & )

delete

Broken assignment operator.

◆ output()

void oomph::Node::output ( std::ostream & outfile )

Output nodal position.

Output nodal coordinates.

   {
     // Loop over the number of dimensions of the node
     const unsigned n_dim = this->ndim();
     for (unsigned i = 0; i < n_dim; i++)
     {
       outfile << x(i) << " ";
     }
     outfile << std::endl;
   }

References i, ndim(), and x().

◆ perform_auxiliary_node_update_fct()

void oomph::Node::perform_auxiliary_node_update_fct ( )

inline

Execute auxiliary update function (if any) – this can be used to update any nodal values following the update of the nodal position. This is needed e.g. to update the no-slip condition on moving boundaries.

     {
       if (Aux_node_update_fct_pt != 0)
       {
         Aux_node_update_fct_pt(this);
       }
     }

References Aux_node_update_fct_pt.

◆ pin_all()

virtual void oomph::Node::pin_all ( )

inlinevirtual

The pin_all() function must be overloaded by SolidNodes, so we put the virtual interface here to avoid virtual functions in Data

Reimplemented in oomph::SolidNode.

     {
       Data::pin_all();
     }

References oomph::Data::pin_all().

Referenced by oomph::SolidNode::pin_all().

◆ position() [1/5]

Vector<double> oomph::Node::position ( void ) const

inline

Return vector of position of node at current time.

     {
       Vector<double> pos(ndim(), 0.0);
       position(pos);
       return pos;
     }

References ndim().

Referenced by dposition_dt(), and position().

◆ position() [2/5]

double oomph::Node::position ( const unsigned & i ) const

Return i-th nodal coordinate either directly or via hanging node representation.

   {
     double posn = 0.0;
  
     // Non-hanging node: just return value
     if (!is_hanging())
     {
       posn = x(i);
     }
     // Hanging node: Use hanging node representation
     else
     {
       // Initialise
       double interpolated_position = 0.0;
  
       // Add contribution from master nodes
       const unsigned n_master = hanging_pt()->nmaster();
       for (unsigned m = 0; m < n_master; m++)
       {
         interpolated_position += hanging_pt()->master_node_pt(m)->x(i) *
                                  hanging_pt()->master_weight(m);
       }
       posn = interpolated_position;
     }
     return posn;
   }

References hanging_pt(), i, is_hanging(), m, oomph::HangInfo::master_node_pt(), oomph::HangInfo::master_weight(), oomph::HangInfo::nmaster(), and x().

◆ position() [3/5]

double oomph::Node::position	(	const unsigned &	t,
		const unsigned &	i
	)		const

Return i-th nodal coordinate at time level t (t=0: current; t>0: previous time level), either directly or via hanging node representation.

   {
     double posn = 0.0;
  
     // Non-hanging node: just return value
     if (!is_hanging())
     {
       posn = x(t, i);
     }
     // Hanging node: Use hanging node representation
     else
     {
       // Initialise
       double interpolated_position = 0.0;
  
       // Add contribution from master nodes
       const unsigned n_master = hanging_pt()->nmaster();
       for (unsigned m = 0; m < n_master; m++)
       {
         interpolated_position += hanging_pt()->master_node_pt(m)->x(t, i) *
                                  hanging_pt()->master_weight(m);
       }
       posn = interpolated_position;
     }
  
     return posn;
   }

References hanging_pt(), i, is_hanging(), m, oomph::HangInfo::master_node_pt(), oomph::HangInfo::master_weight(), oomph::HangInfo::nmaster(), plotPSD::t, and x().

◆ position() [4/5]

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

Compute Vector of nodal position at time level t (t=0: current; t>0: previous timestep), either directly or via hanging node representation.

Compute Vector of nodal position at timestep t (t=0: current; t>0: previous timestep), either directly or via hanging node representation.

   {
     // Assign all positions, using hanging node representation where necessary
     const unsigned n_dim = ndim();
     for (unsigned i = 0; i < n_dim; i++)
     {
       pos[i] = position(t, i);
     }
   }

References i, ndim(), position(), and plotPSD::t.

◆ position() [5/5]

void oomph::Node::position ( Vector< double > & pos ) const

Compute Vector of nodal positions either directly or via hanging node representation

   {
     // Assign all positions using hanging node representation where necessary
     const unsigned n_dim = ndim();
     for (unsigned i = 0; i < n_dim; i++)
     {
       pos[i] = position(i);
     }
   }

References i, ndim(), and position().

Referenced by oomph::TreeBasedRefineableMeshBase::adapt_mesh(), VorticityRecoveryProblem< ELEMENT >::apply_boundary_conditions(), VorticityRecoveryProblem< ELEMENT >::assign_synthetic_veloc_field(), oomph::Mesh::delete_all_external_storage(), oomph::DiskTetMeshFacetedSurface::DiskTetMeshFacetedSurface(), oomph::MyProblem::doc_boundaries(), oomph::ElementWithMovingNodes::get_dnodal_coordinates_dgeom_dofs(), oomph::MyProblem::get_error_norm(), oomph::MyProblem::my_set_initial_condition(), oomph::FiniteElement::nodal_position(), oomph::TreeBasedRefineableMeshBase::p_adapt_mesh(), oomph::XdaTetMesh< ELEMENT >::setup_boundary_coordinates(), oomph::MGSolver< DIM >::setup_interpolation_matrices_unstructured(), oomph::HelmholtzMGPreconditioner< DIM >::setup_interpolation_matrices_unstructured(), oomph::TetMeshBase::snap_nodes_onto_geometric_objects(), and oomph::ThinLayerBrickOnTetMesh< ELEMENT >::ThinLayerBrickOnTetMesh().

◆ position_gen() [1/2]

double oomph::Node::position_gen	(	const unsigned &	k,
		const unsigned &	i
	)		const

Return generalised nodal coordinate either directly or via hanging node representation.

   {
     double posn = 0.0;
  
     // Non-hanging node: just return value
     if (!is_hanging())
     {
       posn = x_gen(k, i);
     }
     // Hanging node: Use hanging node representation
     else
     {
       // Initialise
       double interpolated_position = 0.0;
  
       // Add contribution from master nodes
       const unsigned n_master = hanging_pt()->nmaster();
       for (unsigned m = 0; m < n_master; m++)
       {
         interpolated_position += hanging_pt()->master_node_pt(m)->x_gen(k, i) *
                                  hanging_pt()->master_weight(m);
       }
       posn = interpolated_position;
     }
     return posn;
   }

References hanging_pt(), i, is_hanging(), k, m, oomph::HangInfo::master_node_pt(), oomph::HangInfo::master_weight(), oomph::HangInfo::nmaster(), and x_gen().

Referenced by dposition_gen_dt(), and oomph::FiniteElement::nodal_position_gen().

◆ position_gen() [2/2]

double oomph::Node::position_gen	(	const unsigned &	t,
		const unsigned &	k,
		const unsigned &	i
	)		const

Return generalised nodal coordinate at time level t (t=0: current; t>0: previous time level), either directly or via hanging node representation.

   {
     double posn = 0.0;
  
     // Non-hanging node: just return value
     if (!is_hanging())
     {
       posn = x_gen(t, k, i);
     }
     // Hanging node: Use hanging node representation
     else
     {
       // Initialise
       double interpolated_position = 0.0;
  
       // Add contribution from master nodes
       const unsigned n_master = hanging_pt()->nmaster();
       for (unsigned m = 0; m < n_master; m++)
       {
         interpolated_position +=
           hanging_pt()->master_node_pt(m)->x_gen(t, k, i) *
           hanging_pt()->master_weight(m);
       }
       posn = interpolated_position;
     }
  
     return posn;
   }

References hanging_pt(), i, is_hanging(), k, m, oomph::HangInfo::master_node_pt(), oomph::HangInfo::master_weight(), oomph::HangInfo::nmaster(), plotPSD::t, and x_gen().

◆ position_is_a_copy() [1/2]

virtual bool oomph::Node::position_is_a_copy ( ) const

inlinevirtual

Return whether any position coordinate has been copied (always false)

Reimplemented in oomph::SolidNode.

     {
       return false;
     }

Referenced by oomph::SelfStartingBDF2::assign_initial_positions_impulsive(), oomph::Steady< NSTEPS >::assign_initial_positions_impulsive(), oomph::Newmark< NSTEPS >::assign_initial_positions_impulsive(), oomph::BDF< NSTEPS >::assign_initial_positions_impulsive(), oomph::BDF< NSTEPS >::calculate_predicted_positions(), oomph::TR::calculate_predicted_positions(), oomph::SelfStartingBDF2::calculate_predicted_positions_bdf2(), oomph::SelfStartingBDF2::shift_time_positions(), oomph::IMRBase::shift_time_positions(), oomph::Steady< NSTEPS >::shift_time_positions(), oomph::NewmarkBDF< NSTEPS >::shift_time_positions(), and oomph::BDF< NSTEPS >::shift_time_positions().

◆ position_is_a_copy() [2/2]

virtual bool oomph::Node::position_is_a_copy ( const unsigned & i ) const

inlinevirtual

Return whether the position coordinate i has been copied (always false)

Reimplemented in oomph::SolidNode.

     {
       return false;
     }

◆ position_time_stepper_pt() [1/2]

TimeStepper*& oomph::Node::position_time_stepper_pt ( )

inline

Return a pointer to the position timestepper.

     {
       return Position_time_stepper_pt;
     }

References Position_time_stepper_pt.

◆ position_time_stepper_pt() [2/2]

TimeStepper* const& oomph::Node::position_time_stepper_pt ( ) const

inline

Return a pointer to the position timestepper (const version).

     {
       return Position_time_stepper_pt;
     }

References Position_time_stepper_pt.

◆ raw_value() [1/2]

double oomph::Node::raw_value ( const unsigned & i ) const

inline

Return the i-th value stored at the Node. This interface does NOT take the hanging status of the Node into account.

     {
       return Data::value(i);
     }

References i, and oomph::Data::value().

Referenced by oomph::TreeBasedRefineableMeshBase::adapt_mesh(), oomph::TreeBasedRefineableMeshBase::p_adapt_mesh(), oomph::FiniteElement::raw_nodal_value(), and value().

◆ raw_value() [2/2]

double oomph::Node::raw_value	(	const unsigned &	t,
		const unsigned &	i
	)		const

inline

Return the i-th value at time level t (t=0: present, t>0: previous). This interface does NOT take the hanging status of the Node into account.

     {
       return Data::value(t, i);
     }

References i, plotPSD::t, and oomph::Data::value().

◆ read()

void oomph::Node::read ( std::ifstream & restart_file )

Read nodal position and associated data from file for restart.

Read nodal positions and associated data from file for restart.

   {
     std::string input_string;
  
     // Number of positional values
     const unsigned npos_storage = Ndim * Nposition_type;
  
     // Read line up to termination sign
     getline(restart_file, input_string, '#');
     // Ignore rest of line
     restart_file.ignore(80, '\n');
     // Check # of values:
     const unsigned long check_npos_storage = atoi(input_string.c_str());
     if (check_npos_storage != npos_storage)
     {
       std::ostringstream error_stream;
       error_stream << "The allocated positional storage " << npos_storage
                    << " is not the same as that in the input file"
                    << check_npos_storage << std::endl;
  
       throw OomphLibError(
         error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
  
     // Number of time values (incl present)
     const unsigned time_steps_range = Position_time_stepper_pt->ntstorage();
  
     // Read line up to termination sign
     getline(restart_file, input_string, '#');
     // Ignore rest of line
     restart_file.ignore(80, '\n');
     // Check # of values:
     const unsigned long check_time_steps_range = atoi(input_string.c_str());
     if (check_time_steps_range != time_steps_range)
     {
       std::ostringstream error_stream;
       error_stream
         << "Number of positional history values in dump file is less "
         << "than the storage allocated in Node object: "
         << check_time_steps_range << " " << time_steps_range << std::endl;
  
       throw OomphLibError(
         error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
  
     // Read fixed nodal positions
     for (unsigned t = 0; t < time_steps_range; t++)
     {
       for (unsigned j = 0; j < npos_storage; j++)
       {
         // Read line
         getline(restart_file, input_string);
  
         // Transform to double
         X_position[j][t] = atof(input_string.c_str());
       }
     }
  
     //  Read associated data
     Data::read(restart_file);
   }

References j, Ndim, Nposition_type, oomph::TimeStepper::ntstorage(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, Position_time_stepper_pt, oomph::Data::read(), oomph::Global_string_for_annotation::string(), plotPSD::t, and X_position.

Referenced by oomph::Mesh::read(), and oomph::SolidNode::read().

◆ remove_from_boundary()

void oomph::Node::remove_from_boundary ( const unsigned & b )

virtual

Broken interface for removing the node from the mesh boundary b Here to provide error reporting.

Interface for function to remove the node from the mesh boundary b. Broken here in order to report run-time erorrs. Must be overloaded by all boundary nodes

   {
     throw OomphLibError("Cannot remove non BoundaryNode<NODE> to boundary",
                         OOMPH_CURRENT_FUNCTION,
                         OOMPH_EXCEPTION_LOCATION);
   }

References OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

Referenced by STSpineMesh< ELEMENT, INTERFACE_ELEMENT >::add_mesh(), CombCanSpineMesh< ELEMENT, INTERFACE_ELEMENT >::build_single_layer_mesh(), CombTipSpineMesh< ELEMENT, INTERFACE_ELEMENT >::build_single_layer_mesh(), STSpineMesh< ELEMENT, INTERFACE_ELEMENT >::build_single_layer_mesh(), oomph::TwoLayerSpineMesh< BASE_ELEMENT >::build_two_layer_mesh(), ElasticTwoLayerMesh< ELEMENT >::ElasticTwoLayerMesh(), oomph::MeshHelper::merge_spine_meshes(), oomph::RefineableQuadMeshWithMovingCylinder< ELEMENT >::RefineableQuadMeshWithMovingCylinder(), oomph::Mesh::remove_boundary_node(), and oomph::Mesh::remove_boundary_nodes().

◆ resize()

void oomph::Node::resize ( const unsigned & n_value )

virtual

Resize the number of equations.

Resize the node to allow it to store n_value unknowns.

Reimplemented from oomph::Data.

   {
     // Old number of values
     unsigned old_nvalue = nvalue();
  
     // Now deal with the hanging Data (if any)
     HangInfo** backup_hanging_pt = 0;
     if (Hanging_pt != 0)
     {
       // Backup
       backup_hanging_pt = new HangInfo*[old_nvalue + 1];
  
       // Copy across existing ones
       for (unsigned i = 0; i < old_nvalue + 1; i++)
       {
         backup_hanging_pt[i] = Hanging_pt[i];
       }
  
       // Cleanup old one
       delete[] Hanging_pt;
       Hanging_pt = 0;
     }
  
     // Call the resize function for the underlying Data object
     Data::resize(n_value);
  
  
     // Now deal with the hanging Data (if any)
     if (backup_hanging_pt != 0)
     {
       // The size of the new hanging point is the number of new values plus one.
       const unsigned n_hang = n_value + 1;
       Hanging_pt = new HangInfo*[n_hang];
       // Initialise all entries to zero
       for (unsigned i = 0; i < n_hang; i++)
       {
         Hanging_pt[i] = 0;
       }
  
       // Restore the saved data
       for (unsigned i = 0; i <= old_nvalue; i++)
       {
         Hanging_pt[i] = backup_hanging_pt[i];
       }
  
       // Loop over the new values and set equal to the geometric hanging data
       for (unsigned i = old_nvalue + 1; i < n_hang; i++)
       {
         Hanging_pt[i] = Hanging_pt[0];
         // and constrain if necessary
         if (Hanging_pt[i] != 0)
         {
           constrain(i - 1);
         }
         else
         {
           unconstrain(i - 1);
         }
       }
  
       // If necessary constrain
       // Positions
       // if(Hanging_pt[0] != 0) {constrain_positions();}
       // Values
       // for(unsigned i=0;i<n_value;i++)
       // {
       //  if(Hanging_pt[i+1] != 0) {constrain(i);}
       // }
  
       // Loop over all values and geom hanging data
       /*for (int i=-1;i<int(old_nvalue);i++)
        {
         set_hanging_pt(backup_hanging_pt[i+1],i);
        }
  
       // By default use geometric hanging data for any new entries
       for (int i=int(old_nvalue);i<int(n_value);i++)
        {
         set_hanging_pt(backup_hanging_pt[0],i);
         }*/
  
       delete[] backup_hanging_pt;
     }
   }

References oomph::Data::constrain(), Hanging_pt, i, oomph::Data::nvalue(), oomph::Data::resize(), and oomph::Data::unconstrain().

Referenced by oomph::TriangleMesh< ELEMENT >::build_from_scaffold(), and oomph::FaceElement::resize_nodes().

◆ set_auxiliary_node_update_fct_pt()

void oomph::Node::set_auxiliary_node_update_fct_pt ( AuxNodeUpdateFctPt aux_node_update_fct_pt )

inline

Set pointer to auxiliary update function – this can be used to update any nodal values following the update of the nodal position. This is needed e.g. to update the no-slip condition on moving boundaries.

     {
       // Set pointer (by default it's set to NULL)
       Aux_node_update_fct_pt = aux_node_update_fct_pt;
     }

References Aux_node_update_fct_pt.

Referenced by AirwayReopeningProblem< ELEMENT >::AirwayReopeningProblem(), UnstructuredImmersedEllipseProblem< ELEMENT >::complete_problem_setup(), UnstructuredFluidProblem< ELEMENT >::complete_problem_setup(), FSIRingProblem::FSIRingProblem(), and OscRingNStProblem< ELEMENT >::OscRingNStProblem().

◆ set_coordinates_on_boundary() [1/2]

void oomph::Node::set_coordinates_on_boundary	(	const unsigned &	b,
		const unsigned &	k,
		const Vector< double > &	boundary_zeta
	)

virtual

Set the vector of the k-th generalised boundary coordinates on mesh boundary b. Broken virtual interface provides run-time error checking

Interface for function to set the k-th generalised boundary coordinate of the node on boundary b. Broken here to provide run-time error reports. Must be overloaded by all boundary nodes.

   {
     throw OomphLibError("Non-boundary Node cannot have boundary coordinates",
                         OOMPH_CURRENT_FUNCTION,
                         OOMPH_EXCEPTION_LOCATION);
   }

References OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

Referenced by AirwayReopeningProblem< ELEMENT >::AirwayReopeningProblem(), oomph::BackupMeshForProjection< GEOMETRIC_ELEMENT >::BackupMeshForProjection(), oomph::RefineableQElement< 3 >::build(), oomph::RefineableQElement< 2 >::build(), oomph::BrickFromTetMesh< ELEMENT >::build_mesh(), oomph::TwoLayerSpineMesh< BASE_ELEMENT >::build_two_layer_mesh(), oomph::ChannelWithLeafletMesh< ELEMENT >::ChannelWithLeafletMesh(), oomph::CollapsibleChannelMesh< ELEMENT >::CollapsibleChannelMesh(), oomph::ElasticRefineableRectangularQuadMesh< ELEMENT >::ElasticRefineableRectangularQuadMesh(), ElasticRefineableTwoLayerMesh< ELEMENT >::ElasticRefineableTwoLayerMesh(), ElasticTwoLayerMesh< ELEMENT >::ElasticTwoLayerMesh(), oomph::FSIDrivenCavityMesh< ELEMENT >::FSIDrivenCavityMesh(), oomph::PRefineableQElement< 2, INITIAL_NNODE_1D >::p_refine(), oomph::PRefineableQElement< 3, INITIAL_NNODE_1D >::p_refine(), oomph::QuarterPipeMesh< ELEMENT >::QuarterPipeMesh(), oomph::PRefineableQElement< 2, INITIAL_NNODE_1D >::rebuild_from_sons(), oomph::PRefineableQElement< 3, INITIAL_NNODE_1D >::rebuild_from_sons(), RefineableElasticCubicMesh< ELEMENT >::RefineableElasticCubicMesh(), oomph::RefineableSolidCubicMesh< ELEMENT >::RefineableSolidCubicMesh(), oomph::BrethertonSpineMesh< ELEMENT, INTERFACE_ELEMENT >::reposition_spines(), set_coordinates_on_boundary(), oomph::TetMeshBase::setup_boundary_coordinates(), oomph::XdaTetMesh< ELEMENT >::setup_boundary_coordinates(), oomph::UnstructuredTwoDMeshGeometryBase::setup_boundary_coordinates(), oomph::TetMeshBase::snap_to_quadratic_surface(), oomph::ThinLayerBrickOnTetMesh< ELEMENT >::ThinLayerBrickOnTetMesh(), and WallMesh< ELEMENT >::WallMesh().

◆ set_coordinates_on_boundary() [2/2]

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

inlinevirtual

Set the vector of coordinates on mesh boundary b Broken virtual interface provides run-time error checking

     {
       set_coordinates_on_boundary(b, 0, boundary_zeta);
     }

References b, and set_coordinates_on_boundary().

◆ set_hanging_pt()

void oomph::Node::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)

Set the hanging data for the i-th value. If node is already hanging, simply overwrite the appropriate entry. If the node isn't hanging (because it might not be hanging geometrically), create the Vector of hanging pointers and make the other entries point to the node's geometric hanging data. Set hang_pt=0 to make entry explicitly non-hanging. Use Node::set_nonhanging() to unhang everything and clear up storage.

   {
     // The number of hanging values is the number of stored values plus
     // one (geometry)
     unsigned n_hang = nvalue() + 1;
  
     // Has the vector of pointers to the HangInfo objects already been created?
     // If not create it
     if (Hanging_pt == 0)
     {
       Hanging_pt = new HangInfo*[n_hang];
       // Initialise all entries to zero
       for (unsigned n = 0; n < n_hang; n++)
       {
         Hanging_pt[n] = 0;
       }
     }
  
     // Geometric hanging data
     if (i == -1)
     {
       // Setup boolean array to find which pointers match the geometric pointer
       std::vector<bool> Same_as_geometric(n_hang, true);
  
       // Mark up any values that DON'T use the geometric hanging scheme
       for (unsigned n = 1; n < n_hang; n++)
       {
         if (Hanging_pt[n] != Hanging_pt[0])
         {
           Same_as_geometric[n] = false;
         }
       }
  
       // Remove the old geometric HangInfo
       delete Hanging_pt[0];
       // Assign the new geometric hanging data
       Hanging_pt[0] = hang_pt;
  
       // Constrain the geometric data (virtual function that is
       // overladed in solid nodes)
       if (hang_pt != 0)
       {
         constrain_positions();
       }
       else
       {
         unconstrain_positions();
       }
  
       // Loop over the entries again and update all pointers that pointed to
       // the geometric data
       for (unsigned n = 1; n < n_hang; n++)
       {
         if (Same_as_geometric[n] == true)
         {
           Hanging_pt[n] = Hanging_pt[0];
  
           // In addition set the corresponding value to be constrained (hanging)
           if (Hanging_pt[n] != 0)
           {
             constrain(n - 1);
           }
           else
           {
             unconstrain(n - 1);
           }
         }
       }
     }
     // Value data
     else
     {
       // If the data is different from geometric, delete it
       if (Hanging_pt[i + 1] != Hanging_pt[0])
       {
         delete Hanging_pt[i + 1];
         Hanging_pt[i + 1] = 0;
       }
  
       // Overwrite hanging data for the required value
       // Do not need to delete previous value, because it is assigned outside
       // the Node class
       Hanging_pt[i + 1] = hang_pt;
  
       // In addition set the value to be constrained (hanging)
       if (hang_pt != 0)
       {
         constrain(i);
       }
       else
       {
         unconstrain(i);
       }
     }
   }

References oomph::Data::constrain(), constrain_positions(), Hanging_pt, i, n, oomph::Data::nvalue(), oomph::Data::unconstrain(), and unconstrain_positions().

Referenced by oomph::TreeBasedRefineableMeshBase::complete_hanging_nodes(), oomph::RefineableQElement< 3 >::oc_hang_helper(), and oomph::RefineableQElement< 2 >::quad_hang_helper().

◆ set_non_obsolete()

void oomph::Node::set_non_obsolete ( )

inline

Mark node as non-obsolete.

     {
       Obsolete = false;
     }

References Obsolete.

Referenced by oomph::TreeBasedRefineableMeshBase::adapt_mesh(), oomph::TreeBasedRefineableMeshBase::p_adapt_mesh(), and oomph::RefineableElement::unbuild().

◆ set_nonhanging()

void oomph::Node::set_nonhanging ( )

Label node as non-hanging node by removing all hanging node data.

   {
     if (Hanging_pt != 0)
     {
       // Kill any additional hanging data for values
       const unsigned nhang = nvalue() + 1;
       for (unsigned ival = 1; ival < nhang; ival++)
       {
         // Only kill it if it's different from the geometric hanging node data
         if (Hanging_pt[ival] != Hanging_pt[0])
         {
           delete Hanging_pt[ival];
         }
         // Always zero the entry
         Hanging_pt[ival] = 0;
  
         // Unconstrain any values that were constrained only because they
         // were hanging
         unconstrain(ival - 1);
       }
  
       // Unconstrain the positions (virtual function that is overloaded for
       // solid nodes)
       unconstrain_positions();
  
       // Kill the geometric hanging node data
       delete Hanging_pt[0];
       Hanging_pt[0] = 0;
  
       // Kill the pointer to all hanging data
       delete[] Hanging_pt;
       Hanging_pt = 0;
     }
   }

References Hanging_pt, oomph::Data::nvalue(), oomph::Data::unconstrain(), and unconstrain_positions().

Referenced by oomph::TreeBasedRefineableMeshBase::adapt_mesh(), oomph::Mesh::delete_all_external_storage(), and oomph::TreeBasedRefineableMeshBase::p_adapt_mesh().

◆ set_obsolete()

void oomph::Node::set_obsolete ( )

inline

Mark node as obsolete.

     {
       Obsolete = true;
     }

References Obsolete.

Referenced by oomph::TreeBasedRefineableMeshBase::adapt_mesh(), oomph::TreeBasedRefineableMeshBase::p_adapt_mesh(), oomph::PMLCornerQuadMesh< ELEMENT >::PMLCornerQuadMesh(), and oomph::PMLQuadMesh< ELEMENT >::PMLQuadMesh().

◆ set_position_time_stepper()

void oomph::Node::set_position_time_stepper	(	TimeStepper *const &	position_time_stepper_pt,
		const bool &	preserve_existing_data
	)

virtual

Set a new position timestepper be resizing the appropriate storage

Set a new position TimeStepper be resizing the appropriate storage. The current (zero) values will be unaffected, but all other entries will be set to zero.

Reimplemented in oomph::SolidNode.

   {
     // If the timestepper is unchanged do nothing
     if (Position_time_stepper_pt == position_time_stepper_pt)
     {
       return;
     }
  
     // Find the amount of data to be preserved
     unsigned n_preserved_tstorage = 1;
     if (preserve_existing_data)
     {
       n_preserved_tstorage = Position_time_stepper_pt->ntstorage();
     }
  
     // Set the new time stepper
     Position_time_stepper_pt = position_time_stepper_pt;
  
     // Determine the total amount of storage required for position variables
     const unsigned n_storage = this->ndim() * this->nposition_type();
  
     // Amount of storage required for history values
     const unsigned n_tstorage = Position_time_stepper_pt->ntstorage();
  
     // Allocate all position data in one big array
     double* x_positions = new double[n_storage * n_tstorage];
  
     // If we have reduced the storage, reduce the size of preserved storage
     // to that of the new storage
     if (n_tstorage < n_preserved_tstorage)
     {
       n_preserved_tstorage = n_tstorage;
     }
  
     // Copy the old "preserved" positions into the new storage scheme
     for (unsigned j = 0; j < n_storage; ++j)
     {
       for (unsigned t = 0; t < n_preserved_tstorage; t++)
       {
         x_positions[j * n_tstorage + t] = this->X_position[j][t];
       }
     }
  
     // Now delete the old position storage, which was allocated in one block
     delete[] X_position[0];
  
     // Set the pointers to the contiguous memory
     for (unsigned j = 0; j < n_storage; j++)
     {
       // Set the pointer from the bug array
       X_position[j] = &x_positions[j * n_tstorage];
       // Initialise all new time storgae values to be zero
       for (unsigned t = n_preserved_tstorage; t < n_tstorage; t++)
       {
         X_position[j][t] = 0.0;
       }
     }
   }

References j, ndim(), nposition_type(), oomph::TimeStepper::ntstorage(), Position_time_stepper_pt, position_time_stepper_pt(), plotPSD::t, and X_position.

◆ unconstrain_positions()

virtual void oomph::Node::unconstrain_positions ( )

inlinevirtual

Unconstrain the positions when the node is made non-hanging Empty virtual function that is overloaded in SolidNodes

Reimplemented in oomph::SolidNode.

1349 {}

Referenced by set_hanging_pt(), and set_nonhanging().

◆ unpin_all()

virtual void oomph::Node::unpin_all ( )

inlinevirtual

The unpin_all() function must be overloaded by SolidNode, so we put the virtual interface here to avoid virtual functions in Data

Reimplemented in oomph::SolidNode.

     {
       Data::unpin_all();
     }

References oomph::Data::unpin_all().

Referenced by oomph::SolidNode::unpin_all().

◆ value() [1/5]

Vector<double> oomph::Node::value ( ) const

inline

Return vector of values calculated using value(vector).

     {
       Vector<double> vals(nvalue(), 0.0);
       value(vals);
       return vals;
     }

References oomph::Data::nvalue().

Referenced by value().

◆ value() [2/5]

double oomph::Node::value ( const unsigned & i ) const

Return i-th value (dofs or pinned) at this node either directly or via hanging node representation. Note that this REDFINES the interface in Data Thus, the present function will be called provided that it is accessed through a pointer to a node i.e. Node* node_pt->value() will take hanging information into account. If a pointer to a Node has been explicitly down-cast to a pointer to Data then the "wrong" (Data) version of the function will be called.

Return i-th value (free or pinned) at this node either directly or via hanging node representation.

   {
     // If value is not hanging, just return the underlying value
     if (!is_hanging(i))
     {
       return raw_value(i);
     }
     // Hanging node: Use hanging node representation
     else
     {
       // Initialise
       double sum = 0.0;
       // Add contribution from master nodes
       const unsigned n_master = hanging_pt(i)->nmaster();
       for (unsigned m = 0; m < n_master; m++)
       {
         // A master node cannot be hanging by definition.
         // so we get the raw value to avoid an unnecessary it
         sum += hanging_pt(i)->master_node_pt(m)->raw_value(i) *
                hanging_pt(i)->master_weight(m);
       }
       return sum;
     }
   }

References hanging_pt(), i, is_hanging(), m, oomph::HangInfo::master_node_pt(), oomph::HangInfo::master_weight(), oomph::HangInfo::nmaster(), and raw_value().

◆ value() [3/5]

double oomph::Node::value	(	const unsigned &	t,
		const unsigned &	i
	)		const

Return i-th value at time level t (t=0: present, t>0: previous) either directly or via hanging node representation. Note that this REDEFINES the interface in Data Thus, the present function will be called provided that it is accessed through a pointer to a node i.e. Node* node_pt->value() will take hanging information into account. If a pointer to a Node has been explicitly down-cast to a pointer to Data then the "wrong" (Data) version of the function will be called.

Return i-th value (free or pinned) at this node at time level t either directly or via hanging node representation.

   {
     // If value is not hanging, just return the raw value
     if (!is_hanging(i))
     {
       return raw_value(t, i);
     }
     // Hanging node: Use hanging node representation
     else
     {
       // Initialise
       double sum = 0.0;
  
       // Add contribution from master nodes
       const unsigned n_master = hanging_pt(i)->nmaster();
       for (unsigned m = 0; m < n_master; m++)
       {
         // Get the raw nodal values at each master to avoid un-necessary ifs
         sum += hanging_pt(i)->master_node_pt(m)->raw_value(t, i) *
                hanging_pt(i)->master_weight(m);
       }
       return sum;
     }
   }

References hanging_pt(), i, is_hanging(), m, oomph::HangInfo::master_node_pt(), oomph::HangInfo::master_weight(), oomph::HangInfo::nmaster(), raw_value(), and plotPSD::t.

◆ value() [4/5]

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

Compute Vector of values (dofs or pinned) in this data at time level t (t=0: present; t>0: previous). This interface explicitly takes the hanging status into account. Thus, the present function will be called provided that it is accessed through a pointer to a node i.e. Node* node_pt->value() will take hanging information into account. If a pointer to a Node has been explicitly down-cast to a pointer to Data then the "wrong" (Data) version of the function will be called.

Compute Vector of values (dofs or pinned) at this node at time level t (t=0: present; t>0: previous) either directly or via hanging node representation.

   {
     // Loop over all the values
     const unsigned n_value = nvalue();
     for (unsigned i = 0; i < n_value; i++)
     {
       // Set the value at the time-level t, using the hanging node
       // representation if necessary
       values[i] = value(t, i);
     }
   }

References i, oomph::Data::nvalue(), plotPSD::t, and value().

◆ value() [5/5]

void oomph::Node::value ( Vector< double > & values ) const

Compute Vector of values for the Data value taking the hanging node status into account. Note that this REDEFINES the interface in Data Thus, the present function will be called provided that it is accessed through a pointer to a node i.e. Node* node_pt->value() will take hanging information into account. If a pointer to a Node has been explicitly down-cast to a pointer to Data then the "wrong" (Data) version of the function will be called.

Compute Vector of values (dofs or pinned) at this Data object either directly or via hanging node representation.

   {
     // Loop over all the values
     const unsigned n_value = nvalue();
     for (unsigned i = 0; i < n_value; i++)
     {
       // Set the value, using the hanging node representation if necessary
       values[i] = value(i);
     }
   }

References i, oomph::Data::nvalue(), and value().

◆ x() [1/4]

double& oomph::Node::x ( const unsigned & i )

inline

Return the i-th nodal coordinate.

     {
 #ifdef RANGE_CHECKING
       x_gen_range_check(0, 0, i);
 #endif
       return X_position[Nposition_type * i][0];
     }

References i, Nposition_type, x_gen_range_check(), and X_position.

◆ x() [2/4]

const double& oomph::Node::x ( const unsigned & i ) const

inline

Return the i-th nodal coordinate (const version).

     {
 #ifdef RANGE_CHECKING
       x_gen_range_check(0, 0, i);
 #endif
       return X_position[Nposition_type * i][0];
     }

References i, Nposition_type, x_gen_range_check(), and X_position.

◆ x() [3/4]

double& oomph::Node::x	(	const unsigned &	t,
		const unsigned &	i
	)

inline

Return the position x(i) at previous timestep t (t=0: present; t>0 previous timestep).

     {
 #ifdef RANGE_CHECKING
       x_gen_range_check(t, 0, i);
 #endif
       return X_position[Nposition_type * i][t];
     }

References i, Nposition_type, plotPSD::t, x_gen_range_check(), and X_position.

◆ x() [4/4]

const double& oomph::Node::x	(	const unsigned &	t,
		const unsigned &	i
	)		const

inline

Return the position x(i) at previous timestep t (t=0: present; t>0 previous timestep) (const version)

     {
 #ifdef RANGE_CHECKING
       x_gen_range_check(t, 0, i);
 #endif
       return X_position[Nposition_type * i][t];
     }

References i, Nposition_type, plotPSD::t, x_gen_range_check(), and X_position.

◆ x_gen() [1/4]

double& oomph::Node::x_gen	(	const unsigned &	k,
		const unsigned &	i
	)

inline

Reference to the generalised position x(k,i). ‘Type’: k; Coordinate direction: i.

     {
 #ifdef RANGE_CHECKING
       x_gen_range_check(0, k, i);
 #endif
       return X_position[Nposition_type * i + k][0];
     }

References i, k, Nposition_type, x_gen_range_check(), and X_position.

Referenced by oomph::Newmark< 2 >::assign_initial_data_values_stage1(), oomph::SelfStartingBDF2::assign_initial_positions_impulsive(), oomph::Steady< NSTEPS >::assign_initial_positions_impulsive(), oomph::Newmark< NSTEPS >::assign_initial_positions_impulsive(), oomph::BDF< NSTEPS >::assign_initial_positions_impulsive(), oomph::RefineableSolidElement::assign_solid_hanging_local_eqn_numbers(), oomph::SolidFiniteElement::assign_solid_local_eqn_numbers(), dx_gen_dt(), oomph::ClampedHermiteShellBoundaryConditionElement::fill_in_contribution_to_residuals(), oomph::BiharmonicFluidBoundaryElement::fill_in_generic_residual_contribution_biharmonic_boundary(), oomph::SolidFiniteElement::fill_in_jacobian_from_solid_position_by_fd(), oomph::RefineableSolidElement::fill_in_jacobian_from_solid_position_by_fd(), oomph::RefineablePseudoSolidNodeUpdateElement< BASIC, SOLID >::fill_in_shape_derivatives_by_fd(), position_gen(), oomph::ProjectionProblem< PROJECTABLE_ELEMENT >::project(), oomph::FiniteElement::raw_nodal_position_gen(), oomph::ProjectionProblem< PROJECTABLE_ELEMENT >::restore_positions(), oomph::SolidMesh::set_lagrangian_nodal_coordinates(), oomph::Problem::set_pinned_values_to_zero(), oomph::HermiteQuadMesh< ELEMENT >::set_position_of_node(), oomph::SelfStartingBDF2::shift_time_positions(), oomph::IMRBase::shift_time_positions(), oomph::Steady< NSTEPS >::shift_time_positions(), oomph::NewmarkBDF< NSTEPS >::shift_time_positions(), oomph::BDF< NSTEPS >::shift_time_positions(), oomph::Newmark< 2 >::shift_time_values(), and oomph::ProjectionProblem< PROJECTABLE_ELEMENT >::store_positions().

◆ x_gen() [2/4]

const double& oomph::Node::x_gen	(	const unsigned &	k,
		const unsigned &	i
	)		const

inline

Reference to the generalised position x(k,i). ‘Type’: k; Coordinate direction: i (const version).

     {
 #ifdef RANGE_CHECKING
       x_gen_range_check(0, k, i);
 #endif
       return X_position[Nposition_type * i + k][0];
     }

References i, k, Nposition_type, x_gen_range_check(), and X_position.

◆ x_gen() [3/4]

double& oomph::Node::x_gen	(	const unsigned &	t,
		const unsigned &	k,
		const unsigned &	i
	)

inline

Reference to the generalised position x(k,i) at the previous timestep [t=0: present]. ‘Type’: k; Coordinate direction: i.

     {
 #ifdef RANGE_CHECKING
       x_gen_range_check(t, k, i);
 #endif
       return X_position[Nposition_type * i + k][t];
     }

References i, k, Nposition_type, plotPSD::t, x_gen_range_check(), and X_position.

◆ x_gen() [4/4]

const double& oomph::Node::x_gen	(	const unsigned &	t,
		const unsigned &	k,
		const unsigned &	i
	)		const

inline

Reference to the generalised position x(k,i) at the previous timestep [t=0: present]. ‘Type’: k; Coordinate direction: i. (const version)

     {
 #ifdef RANGE_CHECKING
       x_gen_range_check(t, k, i);
 #endif
       return X_position[Nposition_type * i + k][t];
     }

References i, k, Nposition_type, plotPSD::t, x_gen_range_check(), and X_position.

◆ x_gen_range_check()

void oomph::Node::x_gen_range_check	(	const unsigned &	t,
		const unsigned &	k,
		const unsigned &	i
	)		const

protected

Private function to check that the arguemnts to the position functions are in range

/////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////// Private function to check that the arguments are within the range of the stored coordinates, position types and time history values.

   {
     // Number of stored history values
     const unsigned position_ntstorage = Position_time_stepper_pt->ntstorage();
     // If any of the coordinates or time values are out of range
     if ((i >= Ndim) || (k >= Nposition_type) || (t >= position_ntstorage))
     {
       std::ostringstream error_message;
       // If it's the dimension
       if (i >= Ndim)
       {
         error_message << "Range Error: X coordinate " << i
                       << " is not in the range (0," << Ndim - 1 << ")";
       }
       // If it's the position type
       if (k >= Nposition_type)
       {
         error_message << "Range Error: Position type " << k
                       << " is not in the range (0," << Nposition_type - 1
                       << ")";
       }
       // If it's the time
       if (t >= position_ntstorage)
       {
         error_message << "Range Error: Position Time Value " << t
                       << " is not in the range (0," << position_ntstorage - 1
                       << ")";
       }
       // Throw the error
       throw OomphLibError(
         error_message.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
   }

References i, k, Ndim, Nposition_type, oomph::TimeStepper::ntstorage(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, Position_time_stepper_pt, and plotPSD::t.

Referenced by x(), and x_gen().

◆ x_position_pt()

double* oomph::Node::x_position_pt ( const unsigned & i )

inlineprotected

Direct access to the pointer to the i-th stored coordinate data.

     {
       return X_position[i];
     }

References i, and X_position.

◆ x_pt()

double* oomph::Node::x_pt	(	const unsigned &	t,
		const unsigned &	i
	)

inline

Direct access to the i-th coordinate at time level t (t=0: present; t>0: previous)

     {
       return &X_position[Nposition_type * i][t];
     }

References i, Nposition_type, plotPSD::t, and X_position.

Friends And Related Function Documentation

◆ BoundaryNodeBase

friend class BoundaryNodeBase

friend

to construct periodic Nodes

◆ operator<<

std::ostream& operator<<	(	std::ostream &	out,
		const Node &	d
	)

friend

Output operator: output location and all values at all times, along with any extra information stored for the timestepper.

Node output operator: output equation numbers and values at all times, along with any extra information stored for the timestepper.

   {
     const unsigned nt = nd.ntstorage();
     const unsigned dim = nd.ndim();
  
     // Output position, only doing current value for now but add position
     // history if you need it - David.
     out << "Position: [";
     for (unsigned j = 0; j < dim; j++)
     {
       out << "dimension " << dim << ": [";
       for (unsigned t = 0; t < nt - 1; t++)
       {
         out << nd.x(t, j) << ", ";
       }
       out << nd.x(nt - 1, j) << "]" << std::endl;
     }
     out << "]" << std::endl;
  
     // Use the function for data to output the data (we can't use overloading
     // here because operator<< is not a class function, so instead we
     // typecast the node to a data).
     out << dynamic_cast<const Data&>(nd);
     return out;
   }

Member Data Documentation

◆ Aux_node_update_fct_pt

AuxNodeUpdateFctPt oomph::Node::Aux_node_update_fct_pt

protected

Pointer to auxiliary update function – this can be used to update any nodal values following the update of the nodal position. This is needed e.g. to update the no-slip condition on moving boundaries.

Referenced by has_auxiliary_node_update_fct_pt(), oomph::PerturbedSpineNode::node_update(), oomph::AlgebraicNode::node_update(), oomph::MacroElementNodeUpdateNode::node_update(), oomph::SpineNode::node_update(), perform_auxiliary_node_update_fct(), and set_auxiliary_node_update_fct_pt().

◆ Hanging_pt

HangInfo** oomph::Node::Hanging_pt

protected

C-style array of pointers to hanging node info. It's set to NULL if the node isn't hanging. The first entry (0) is the geometric hanging node data. The remaining entries correspond to the hanging data for the other values stored at the node. Usually, these entries will be the same as the geometric hanging node data represented by Hanging_pt[0], but this is not necessarily the case; e.g. the pressure in Taylor Hood has different hanging node data from the velocities.

Referenced by hanging_pt(), is_hanging(), resize(), set_hanging_pt(), set_nonhanging(), and ~Node().

◆ Ndim

unsigned oomph::Node::Ndim

protected

Eulerian dimension of the node.

Referenced by copy(), dump(), ndim(), read(), oomph::SolidNode::SolidNode(), and x_gen_range_check().

◆ No_independent_position

unsigned oomph::Node::No_independent_position = 10

static

Static "Magic number" used to indicate that there is no independent position in a periodic node.

Static "Magic number" passed as independent_position when there is no independent position in the periodic node. For example, in a periodic mesh.

◆ Nposition_type

unsigned oomph::Node::Nposition_type

protected

Number of coordinate types used in the mapping between local and global coordinates (e.g. 1 for Lagrange-type elements; 2 for 1D Hermite elements; 4 for 2D Hermite elements, etc).

Referenced by copy(), dump(), nposition_type(), oomph::SolidNode::pin_position(), oomph::SolidNode::position_eqn_number(), oomph::SolidNode::position_is_a_copy(), oomph::SolidNode::position_is_pinned(), read(), oomph::SolidNode::SolidNode(), oomph::SolidNode::unpin_position(), x(), x_gen(), x_gen_range_check(), and x_pt().

◆ Obsolete

bool oomph::Node::Obsolete

protected

Flag to indicate that the Node has become obsolete — usually during mesh refinement process

Referenced by is_obsolete(), set_non_obsolete(), and set_obsolete().

◆ Position_time_stepper_pt

TimeStepper* oomph::Node::Position_time_stepper_pt

protected

Pointer to the timestepper associated with the position data.

Referenced by copy(), dposition_dt(), dposition_gen_dt(), dump(), dx_dt(), dx_gen_dt(), Node(), oomph::AlgebraicNode::node_update(), oomph::MacroElementNodeUpdateNode::node_update(), position_time_stepper_pt(), read(), set_position_time_stepper(), oomph::SolidNode::set_position_time_stepper(), and x_gen_range_check().

◆ X_position

double** oomph::Node::X_position

protected

Array of pointers to the data holding the Eulerian positions. The storage format must be the same as the internal data storage so that we can implement the functions x() in generality here without the need for virtual functions. The first index will be a flat array of position types and coordinates and the second will be the number of time history values at each position type.

Referenced by copy(), dump(), Node(), read(), oomph::SolidNode::set_external_variable_position_pt(), set_position_time_stepper(), oomph::SolidNode::set_position_time_stepper(), oomph::SolidNode::SolidNode(), x(), x_gen(), x_position_pt(), x_pt(), ~Node(), and oomph::SolidNode::~SolidNode().

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

Public Types

Public Member Functions

Static Public Attributes

Protected Member Functions

Protected Attributes

Friends

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ AuxNodeUpdateFctPt

Constructor & Destructor Documentation

◆ Node() [1/4]

◆ Node() [2/4]

◆ Node() [3/4]

◆ ~Node()

◆ Node() [4/4]

Member Function Documentation

◆ add_to_boundary()

◆ all_geom_data_pt()

◆ all_geom_object_pt()

◆ assign_eqn_numbers()

◆ boundary_coordinates_have_been_set_up()

◆ constrain_positions()

◆ copied_node_pt()

◆ copy()

◆ does_pointer_correspond_to_position_data()

◆ dposition_dt() [1/2]

◆ dposition_dt() [2/2]

◆ dposition_gen_dt() [1/2]

◆ dposition_gen_dt() [2/2]

◆ dump()

◆ dx_dt() [1/2]

◆ dx_dt() [2/2]

◆ dx_gen_dt() [1/2]

◆ dx_gen_dt() [2/2]

◆ get_boundaries_pt()

◆ get_coordinates_on_boundary() [1/2]

◆ get_coordinates_on_boundary() [2/2]

◆ hang_code()

◆ hanging_pt() [1/2]

◆ hanging_pt() [2/2]

◆ has_auxiliary_node_update_fct_pt()

◆ is_hanging() [1/2]

◆ is_hanging() [2/2]

◆ is_obsolete()

◆ is_on_boundary() [1/2]

◆ is_on_boundary() [2/2]

◆ make_periodic()

◆ make_periodic_nodes()

◆ ncoordinates_on_boundary()

◆ ndim()

◆ ngeom_data()

◆ ngeom_object()

◆ node_update()

◆ nposition_type()

◆ operator=()

◆ output()

◆ perform_auxiliary_node_update_fct()

◆ pin_all()

◆ position() [1/5]

◆ position() [2/5]

◆ position() [3/5]

◆ position() [4/5]

◆ position() [5/5]

◆ position_gen() [1/2]

◆ position_gen() [2/2]

◆ position_is_a_copy() [1/2]

◆ position_is_a_copy() [2/2]

◆ position_time_stepper_pt() [1/2]

◆ position_time_stepper_pt() [2/2]

◆ raw_value() [1/2]

◆ raw_value() [2/2]

◆ read()

◆ remove_from_boundary()

◆ resize()

◆ set_auxiliary_node_update_fct_pt()

◆ set_coordinates_on_boundary() [1/2]

◆ set_coordinates_on_boundary() [2/2]

◆ set_hanging_pt()

◆ set_non_obsolete()