#include <nodes.h>

Inheritance diagram for oomph::SolidNode:

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

	SolidNode (const unsigned &n_lagrangian, const unsigned &n_lagrangian_type, const unsigned &n_dim, const unsigned &n_position_type, const unsigned &initial_n_value)

	SolidNode (TimeStepper *const &time_stepper_pt, const unsigned &n_lagrangian, const unsigned &n_lagrangian_type, const unsigned &n_dim, const unsigned &Nposition_type, const unsigned &initial_n_value)

virtual	~SolidNode ()
	Destructor that cleans up the additional memory allocated in SolidNodes. More...

	SolidNode (const SolidNode &solid_node)=delete
	Broken copy constructor. More...

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

void	copy (SolidNode *orig_node_pt)

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

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

const Data &	variable_position () const
	Return the variable_position data (const version) More...

Data *const &	variable_position_pt () const
	Pointer to variable_position data (const version) More...

void	set_external_variable_position_pt (Data *const &data_pt)
	Set the variable position data from an external data object. More...

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

bool	does_pointer_correspond_to_position_data (double *const &parameter_pt)
	Check whether the pointer parameter_pt refers to positional data. More...

bool	position_is_a_copy () const
	Return whether any position component has been copied. More...

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

const long &	position_eqn_number (const unsigned &k, const unsigned &i) const

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

bool	position_is_pinned (const unsigned &k, const unsigned &i)

void	pin_position (const unsigned &i)
	Pin the nodal position. More...

void	pin_position (const unsigned &k, const unsigned &i)

void	unpin_position (const unsigned &i)
	Unpin the nodal position. More...

void	unpin_position (const unsigned &k, const unsigned &i)

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

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

void	constrain_positions ()

void	unconstrain_positions ()

unsigned	nlagrangian () const
	Return number of lagrangian coordinates. More...

unsigned	nlagrangian_type () const

double &	xi (const unsigned &i)
	Reference to i-th Lagrangian position. More...

const double &	xi (const unsigned &i) const
	Reference to i-th Lagrangian position (const version) More...

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

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

double	lagrangian_position (const unsigned &i) const

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

void	assign_eqn_numbers (unsigned long &global_number, Vector< double * > &dof_pt)
	Overload the assign equation numbers routine. More...

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

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

void	node_update (const bool &update_all_time_levels_for_new_node=false)

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

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

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

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

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

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

unsigned	nposition_type () const

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

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

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

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...

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

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	make_periodic (Node *const &node_pt)

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

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

virtual bool	is_on_boundary () const

virtual bool	is_on_boundary (const unsigned &b) const

virtual void	add_to_boundary (const unsigned &b)

virtual void	remove_from_boundary (const unsigned &b)

virtual unsigned	ncoordinates_on_boundary (const unsigned &b)

virtual bool	boundary_coordinates_have_been_set_up ()

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

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

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

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

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

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

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

double	raw_value (const unsigned &i) const

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

double	value (const unsigned &i) const

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

void	value (Vector< double > &values) const

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

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

void	position (Vector< double > &pos) const

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

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

double	position (const unsigned &i) const

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

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

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

double	dposition_dt (const unsigned &i) const

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

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

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

void	set_auxiliary_node_update_fct_pt (AuxNodeUpdateFctPt aux_node_update_fct_pt)

bool	has_auxiliary_node_update_fct_pt ()

void	perform_auxiliary_node_update_fct ()

virtual unsigned	ngeom_data () const

virtual Data **	all_geom_data_pt ()

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

Protected Attributes
unsigned	Nlagrangian
	Number of Lagrangian coordinates of the node. More...

unsigned	Nlagrangian_type

Data *	Variable_position_pt
	Pointer to data that will hold variable positions in elastic nodes. More...

double *	Xi_position
	Storage for the Lagrangian positions. More...

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

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

HangInfo **	Hanging_pt

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

unsigned	Nposition_type

bool	Obsolete

AuxNodeUpdateFctPt	Aux_node_update_fct_pt

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

unsigned	Ncopies

Private Member Functions
void	xi_gen_range_check (const unsigned &k, const unsigned &i) const

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

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

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

static long	Is_segregated_solve_pinned = -3

static long	Is_unclassified = -10

static long	Is_constrained = -2

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

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

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

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

A Class for nodes that deform elastically (i.e. position is an unknown in the problem). The idea is that the Eulerian positions are stored in a Data object and the Lagrangian coordinates are stored in addition. The pointer that addresses the Eulerian positions is set to the pointer to Value in the Data object. Hence, SolidNode uses knowledge of the internal structure of Data and must be a friend of the Data class. In order to allow a mesh to deform via an elastic-style equation in deforming-domain problems, the positions are stored separately from the values, so that elastic problems may be combined with any other type of problem.

Constructor & Destructor Documentation

◆ SolidNode() [1/4]

oomph::SolidNode::SolidNode ( )

inline

Default Constructor.

1708 : Node() {}

oomph::Node::Node

Node()

Default constructor.

Definition: nodes.cc:1574

◆ SolidNode() [2/4]

oomph::SolidNode::SolidNode	(	const unsigned &	n_lagrangian,
		const unsigned &	n_lagrangian_type,
		const unsigned &	n_dim,
		const unsigned &	n_position_type,
		const unsigned &	initial_n_value
	)

Steady constructor. The node has n_lagrangian Lagrangian coordinates of n_lagrangian_type types (1 for Lagrange elements, 2 for 1D Hermite etc.). The Eulerian dimension of the Node is n_dim and we have n_position_type (generalised) Eulerian coordinates. There are initial_n_value values stored at this node.

Steady constructor. The node has NLgrangian Lagrangian coordinates of n_lagrangian_type types (1 for Lagrange elements, 2 for 1D Hermite etc.). The Eulerian dimension of the Node is n_dim and we have n_position_type (generalised) Eulerian coordinates. There are initial_n_value values stored at this node and NAdditional_solid additional values associated with the solid equations are stored in a separate Data object at the node.

     : Node(n_dim, n_position_type, initial_n_value, false),
       Nlagrangian(n_lagrangian),
       Nlagrangian_type(n_lagrangian_type)
   {
     // Calculate the total storage required for positions
     const unsigned n_storage = Ndim * Nposition_type;
  
     // Allocate a data object with exactly the coorect number of coordinates
     Variable_position_pt = new Data(n_storage);
     // Set X_position to point to the data's positions
     X_position = Variable_position_pt->Value;
  
     // Setup the lagrangian storage
     const unsigned n_lagrangian_storage = n_lagrangian * n_lagrangian_type;
     Xi_position = new double[n_lagrangian_storage];
     // Initialise lagrangian positions to zero
     for (unsigned j = 0; j < n_lagrangian_storage; j++)
     {
       Xi_position[j] = 0.0;
     }
   }

References oomph::Data::Data(), j, oomph::Node::Ndim, oomph::Node::Nposition_type, oomph::Data::Value, Variable_position_pt, oomph::Node::X_position, and Xi_position.

◆ SolidNode() [3/4]

oomph::SolidNode::SolidNode	(	TimeStepper *const &	time_stepper_pt_,
		const unsigned &	n_lagrangian,
		const unsigned &	n_lagrangian_type,
		const unsigned &	n_dim,
		const unsigned &	n_position_type,
		const unsigned &	initial_n_value
	)

Unsteady constructor. Allocates storage for initial_n_value nodal values with history values as required by timestepper. The node has n_lagrangian Lagrangian coordinates of n_lagrangian_type types (1 for Lagrange elements, 2 for 1D Hermite etc.)/ The Eulerian dimension of the Node is n_dim and we have n_position_type generalised Eulerian coordinates.

Unsteady constructor. Allocates storage for initial_n_value nodal values with history values as required by timestepper. The node has NLgrangian Lagrangian coordinates of n_lagrangian_type types (1 for Lagrange elements, 2 for 1D Hermite etc.)/ The Eulerian dimension of the Node is n_dim and we have n_position_type generalised Eulerian coordinates.

     : Node(time_stepper_pt_, n_dim, n_position_type, initial_n_value, false),
       Nlagrangian(n_lagrangian),
       Nlagrangian_type(n_lagrangian_type)
   {
     // Calculate the total storage required for positions
     const unsigned n_storage = n_dim * n_position_type;
  
     // Allocate a Data value to each element of the Vector
     Variable_position_pt = new Data(time_stepper_pt_, n_storage);
     // Set the pointer
     X_position = Variable_position_pt->Value;
  
     // Setup the lagrangian storage
     const unsigned n_lagrangian_storage = n_lagrangian * n_lagrangian_type;
     Xi_position = new double[n_lagrangian_storage];
     // Initialise lagrangian positions to zero
     for (unsigned j = 0; j < n_lagrangian_storage; j++)
     {
       Xi_position[j] = 0.0;
     }
   }

References oomph::Data::Data(), j, oomph::Data::Value, Variable_position_pt, oomph::Node::X_position, and Xi_position.

◆ ~SolidNode()

oomph::SolidNode::~SolidNode ( )

virtual

Destructor that cleans up the additional memory allocated in SolidNodes.

Destructor to clean up the memory allocated for nodal positions and additional solid variables

   {
     // Null out X_position so that the Node destructor doesn't delete it
     X_position = 0;
     // Delete the position data
     delete Variable_position_pt;
     Variable_position_pt = 0;
     // Now clean up lagrangian position data
     delete[] Xi_position;
     Xi_position = 0;
   }

References Variable_position_pt, oomph::Node::X_position, and Xi_position.

◆ SolidNode() [4/4]

oomph::SolidNode::SolidNode ( const SolidNode & solid_node )

delete

Broken copy constructor.

Member Function Documentation

◆ add_value_pt_to_map()

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

virtual

Overload the function add_values_to_map so that it also adds the variable position data

Add pointers to all data values (including position data) to a map

Reimplemented from oomph::Data.

   {
     // Add the position values first
     Variable_position_pt->add_value_pt_to_map(map_of_value_pt);
     // Then call standard Data values
     Data::add_value_pt_to_map(map_of_value_pt);
   }

References oomph::Data::add_value_pt_to_map(), and Variable_position_pt.

◆ assign_eqn_numbers()

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

virtual

Overload the assign equation numbers routine.

Assign (global) equation number, for SolidNodes.

Reimplemented from oomph::Node.

   {
     // Let's call position equations first
     Variable_position_pt->assign_eqn_numbers(global_number, dof_pt);
     // Then call standard Data assign_eqn_numbers
     Data::assign_eqn_numbers(global_number, dof_pt);
   }

References oomph::Data::assign_eqn_numbers(), and Variable_position_pt.

◆ constrain_positions()

void oomph::SolidNode::constrain_positions ( )

inlinevirtual

Overload the constrain positions function to constrain all position values

Reimplemented from oomph::Node.

     {
       Variable_position_pt->constrain_all();
     }

References oomph::Data::constrain_all(), and Variable_position_pt.

◆ copy()

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

Copy nodal positions and associated data from specified node object

   {
     // Eulerian positions are stored as Data, so copy the data values
     // from one data to another
     Variable_position_pt->copy(orig_node_pt->variable_position_pt());
  
     // Copy the Lagrangian coordinates
     const unsigned nlagrangian_storage = Nlagrangian * Nlagrangian_type;
  
     // Check # of values:
     const unsigned long nlagrangian_storage_orig =
       orig_node_pt->nlagrangian() * orig_node_pt->nlagrangian_type();
     if (nlagrangian_storage != nlagrangian_storage_orig)
     {
       std::ostringstream error_stream;
       error_stream << "The allocated lagrangian storage " << nlagrangian_storage
                    << " is not the same as the original Solid Node "
                    << nlagrangian_storage_orig << std::endl;
  
       throw OomphLibError(
         error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
  
     // Copy lagrangian positions
     for (unsigned j = 0; j < nlagrangian_storage; j++)
     {
       Xi_position[j] = orig_node_pt->Xi_position[j];
     }
  
     // Copy the associated data
     Data::copy(orig_node_pt);
   }

References oomph::Data::copy(), j, Nlagrangian, nlagrangian(), Nlagrangian_type, nlagrangian_type(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, Variable_position_pt, variable_position_pt(), and Xi_position.

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

◆ describe_dofs()

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

virtual

Function to describe the dofs of the Node. The ostream specifies the output stream to which the description is written; the string stores the currently assembled output that is ultimately written to the output stream by Data::describe_dofs(...); it is typically built up incrementally as we descend through the call hierarchy of this function when called from Problem::describe_dofs(...)

Function to describe the dofs of the SolidNode. The ostream specifies the output stream to which the description is written; the string stores the currently assembled output that is ultimately written to the output stream by Data::describe_dofs(...); it is typically built up incrementally as we descend through the call hierarchy of this function when called from Problem::describe_dofs(...)

Reimplemented from oomph::Data.

   {
     // Let's call position equations first
     {
       std::stringstream conversion;
       conversion << " of Solid Node Position" << current_string;
       std::string in(conversion.str());
       Variable_position_pt->describe_dofs(out, in);
     } // Let conversion go out of scope.
  
     // Then call standard Data version
     std::stringstream conversion;
     conversion << " of Data" << current_string;
     std::string in(conversion.str());
     Data::describe_dofs(out, in);
   }

References oomph::Data::describe_dofs(), out(), oomph::Global_string_for_annotation::string(), and Variable_position_pt.

Referenced by oomph::SolidFiniteElement::describe_solid_local_dofs().

◆ does_pointer_correspond_to_position_data()

bool oomph::SolidNode::does_pointer_correspond_to_position_data ( double *const & parameter_pt )

virtual

Check whether the pointer parameter_pt refers to positional data.

Overload the check whether the pointer parameter_pt addresses position data values

Reimplemented from oomph::Node.

   {
     // Simply pass the test through to the data of the Variabl position pointer
     return (this->Variable_position_pt->does_pointer_correspond_to_value(
       parameter_pt));
   }

References oomph::Data::does_pointer_correspond_to_value(), and Variable_position_pt.

◆ dump()

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

virtual

Dump nodal positions and associated data to file for restart.

Dump nodal positions (variable and fixed) and associated data to file for restart

Reimplemented from oomph::Node.

   {
     // Dump out the Lagrangian coordinates
     // Number of lagrangian values
     const unsigned nlagrangian_storage = Nlagrangian * Nlagrangian_type;
     dump_file << nlagrangian_storage
               << " # number of Lagrangian position variables" << std::endl;
  
     for (unsigned j = 0; j < nlagrangian_storage; j++)
     {
       dump_file << Xi_position[j] << std::endl;
     }
  
     // Dump out Eulerian positions and nodal data
     Node::dump(dump_file);
   }

References oomph::Node::dump(), j, Nlagrangian, Nlagrangian_type, and Xi_position.

◆ lagrangian_position()

double oomph::SolidNode::lagrangian_position ( const unsigned & i ) const

Return lagrangian coordinate either directly or via hanging node representation

Return lagrangian coordinate either directly or via hanging node representation.

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

References oomph::Node::hanging_pt(), i, oomph::Node::is_hanging(), oomph::HangInfo::master_node_pt(), oomph::HangInfo::master_weight(), oomph::HangInfo::nmaster(), and xi().

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

◆ lagrangian_position_gen()

double oomph::SolidNode::lagrangian_position_gen	(	const unsigned &	k,
		const unsigned &	i
	)		const

Return generalised lagrangian coordinate either directly or via hanging node representation

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

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

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

◆ nlagrangian()

unsigned oomph::SolidNode::nlagrangian ( ) const

inline

Return number of lagrangian coordinates.

     {
       return Nlagrangian;
     }

References Nlagrangian.

◆ nlagrangian_type()

unsigned oomph::SolidNode::nlagrangian_type ( ) const

inline

Number of types of Lagrangian coordinates used to interpolate the Lagrangian coordinates within the element

     {
       return Nlagrangian_type;
     }

References Nlagrangian_type.

Referenced by oomph::RefineableSolidQElement< 3 >::build(), oomph::RefineableSolidQElement< 2 >::build(), copy(), oomph::ProjectionProblem< PROJECTABLE_ELEMENT >::project(), and oomph::SolidMesh::set_lagrangian_nodal_coordinates().

◆ node_update()

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

inlinevirtual

Overload node update function: Since the position of SolidNodes is determined by unknowns, there's nothing to be done apart from performing the auxiliary node update function (if any)

Reimplemented from oomph::Node.

     {
       perform_auxiliary_node_update_fct();
     }

References oomph::Node::perform_auxiliary_node_update_fct().

◆ operator=()

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

delete

Broken assignment operator.

◆ pin_all()

void oomph::SolidNode::pin_all ( )

inlinevirtual

Pin all the stored variables (Overloaded)

Reimplemented from oomph::Node.

     {
       Node::pin_all();
       Variable_position_pt->pin_all();
     }

References oomph::Data::pin_all(), oomph::Node::pin_all(), and Variable_position_pt.

◆ pin_position() [1/2]

void oomph::SolidNode::pin_position ( const unsigned & i )

inline

Pin the nodal position.

     {
       return Variable_position_pt->pin(Nposition_type * i);
     }

References i, oomph::Node::Nposition_type, oomph::Data::pin(), and Variable_position_pt.

◆ pin_position() [2/2]

void oomph::SolidNode::pin_position	(	const unsigned &	k,
		const unsigned &	i
	)

inline

Pin the generalised nodal position. ‘Type’: k; Coordinate direction: i.

     {
       return Variable_position_pt->pin(Nposition_type * i + k);
     }

References i, k, oomph::Node::Nposition_type, oomph::Data::pin(), and Variable_position_pt.

◆ position_eqn_number()

const long& oomph::SolidNode::position_eqn_number	(	const unsigned &	k,
		const unsigned &	i
	)		const

inline

Return the equation number for generalised Eulerian coordinate: type of coordinate: k, coordinate direction: i.

     {
       return Variable_position_pt->eqn_number(Nposition_type * i + k);
     }

References oomph::Data::eqn_number(), i, k, oomph::Node::Nposition_type, and Variable_position_pt.

Referenced by oomph::SolidFiniteElement::assign_solid_local_eqn_numbers().

◆ position_is_a_copy() [1/2]

bool oomph::SolidNode::position_is_a_copy ( ) const

inlinevirtual

Return whether any position component has been copied.

Reimplemented from oomph::Node.

     {
       return Variable_position_pt->is_a_copy();
     }

References oomph::Data::is_a_copy(), and Variable_position_pt.

◆ position_is_a_copy() [2/2]

bool oomph::SolidNode::position_is_a_copy ( const unsigned & i ) const

inlinevirtual

Return whether the position coordinate i has been copied.

Reimplemented from oomph::Node.

     {
       return Variable_position_pt->is_a_copy(Nposition_type * i);
     }

References i, oomph::Data::is_a_copy(), oomph::Node::Nposition_type, and Variable_position_pt.

◆ position_is_pinned() [1/2]

bool oomph::SolidNode::position_is_pinned ( const unsigned & i )

inline

Test whether the i-th coordinate is pinned, 0: false; 1: true.

     {
       return Variable_position_pt->is_pinned(Nposition_type * i);
     }

References i, oomph::Data::is_pinned(), oomph::Node::Nposition_type, and Variable_position_pt.

Referenced by SolidBag::actionsBeforeOomphTimeStep(), oomph::SolidICProblem::backup_original_state(), oomph::RefineableSolidQElement< 2 >::get_edge_solid_bcs(), oomph::RefineableSolidQElement< 3 >::get_face_solid_bcs(), and oomph::Problem::set_pinned_values_to_zero().

◆ position_is_pinned() [2/2]

bool oomph::SolidNode::position_is_pinned	(	const unsigned &	k,
		const unsigned &	i
	)

inline

Test whether the k-th type of the i-th coordinate is pinned 0: false; 1: true

     {
       return Variable_position_pt->is_pinned(Nposition_type * i + k);
     }

References i, oomph::Data::is_pinned(), k, oomph::Node::Nposition_type, and Variable_position_pt.

◆ read()

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

Read nodal positions and associated data to file for restart.

Read nodal positions (variable and fixed) and associated data from file for restart

   {
     std::string input_string;
  
     // Number of lagrangian values
     const unsigned nlagrangian_storage = Nlagrangian * Nlagrangian_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_nlagrangian_storage = atoi(input_string.c_str());
     if (check_nlagrangian_storage != nlagrangian_storage)
     {
       std::ostringstream error_stream;
       error_stream << "The allocated Lagrangian storage " << nlagrangian_storage
                    << " is not the same as that in the input file"
                    << check_nlagrangian_storage << std::endl;
  
       throw OomphLibError(
         error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
  
     // Read Lagrangian positions
     for (unsigned j = 0; j < nlagrangian_storage; j++)
     {
       // Read line
       getline(restart_file, input_string);
  
       // Transform to double
       Xi_position[j] = atof(input_string.c_str());
     }
  
     // Read Eulerian positions and nodal data
     Node::read(restart_file);
   }

References j, Nlagrangian, Nlagrangian_type, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::Node::read(), oomph::Global_string_for_annotation::string(), and Xi_position.

Referenced by oomph::Mesh::read().

◆ set_external_variable_position_pt()

void oomph::SolidNode::set_external_variable_position_pt ( Data *const & data_pt )

Set the variable position data from an external data object.

Set the variable position data from an external source. This is mainly used when setting periodic solid problems.

   {
     // Wipe the existing value
     delete Variable_position_pt;
     // Set the new value
     Variable_position_pt = new CopiedData(data_pt);
     // Set the new value of x
     X_position = Variable_position_pt->Value;
   }

References oomph::Data::CopiedData, oomph::Data::Value, Variable_position_pt, and oomph::Node::X_position.

◆ set_position_time_stepper()

void oomph::SolidNode::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 Overloaded from the basic implementation to take into account the fact that position is now Data

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 from oomph::Node.

   {
     // If the timestepper is unchanged do nothing
     if (Position_time_stepper_pt == position_time_stepper_pt)
     {
       return;
     }
  
     // Set the new time stepper
     Position_time_stepper_pt = position_time_stepper_pt;
  
     // Now simply set the time stepper of the variable position data
     this->Variable_position_pt->set_time_stepper(position_time_stepper_pt,
                                                  preserve_existing_data);
     // Need to reset the X_position to point to the variable positions data
     // values which have been reassigned
     X_position = this->Variable_position_pt->Value;
   }

References oomph::Node::Position_time_stepper_pt, oomph::Node::position_time_stepper_pt(), oomph::Data::set_time_stepper(), oomph::Data::Value, Variable_position_pt, and oomph::Node::X_position.

◆ unconstrain_positions()

void oomph::SolidNode::unconstrain_positions ( )

inlinevirtual

Overload the unconstrain positions function to unconstrain all position values

Reimplemented from oomph::Node.

     {
       Variable_position_pt->unconstrain_all();
     }

References oomph::Data::unconstrain_all(), and Variable_position_pt.

◆ unpin_all()

void oomph::SolidNode::unpin_all ( )

inlinevirtual

Unpin all the stored variables (Overloaded)

Reimplemented from oomph::Node.

     {
       Node::unpin_all();
       Variable_position_pt->unpin_all();
     }

References oomph::Data::unpin_all(), oomph::Node::unpin_all(), and Variable_position_pt.

◆ unpin_position() [1/2]

void oomph::SolidNode::unpin_position ( const unsigned & i )

inline

Unpin the nodal position.

     {
       return Variable_position_pt->unpin(Nposition_type * i);
     }

References i, oomph::Node::Nposition_type, oomph::Data::unpin(), and Variable_position_pt.

Referenced by UnstructuredImmersedEllipseProblem< ELEMENT >::complete_problem_setup(), TwoLayerInterfaceProblem< ELEMENT >::complete_problem_setup(), UnstructuredFluidProblem< ELEMENT >::complete_problem_setup(), BubbleInChannelProblem< ELEMENT >::complete_problem_setup(), DropInChannelProblem< ELEMENT >::complete_problem_setup(), SolidProblem< ELEMENT_TYPE >::prepareForSolve(), oomph::SolidICProblem::setup_problem(), oomph::ProjectionProblem< PROJECTABLE_ELEMENT >::unpin_all(), oomph::ProjectionProblem< PROJECTABLE_ELEMENT >::unpin_dofs_of_coordinate(), and SurfactantProblem< ELEMENT, INTERFACE_ELEMENT >::unpin_surface().

◆ unpin_position() [2/2]

void oomph::SolidNode::unpin_position	(	const unsigned &	k,
		const unsigned &	i
	)

inline

Unpin the generalised nodal position. ‘Type’: k; Coordinate direction: i.

     {
       return Variable_position_pt->unpin(Nposition_type * i + k);
     }

References i, k, oomph::Node::Nposition_type, oomph::Data::unpin(), and Variable_position_pt.

◆ variable_position()

const Data& oomph::SolidNode::variable_position ( ) const

inline

Return the variable_position data (const version)

     {
       return *Variable_position_pt;
     }

References Variable_position_pt.

◆ variable_position_pt()

Data* const& oomph::SolidNode::variable_position_pt ( ) const

inline

Pointer to variable_position data (const version)

     {
       return Variable_position_pt;
     }

References Variable_position_pt.

Referenced by oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::adapt_temporal_mesh(), oomph::StefanBoltzmannRadiationBase::add_stefan_boltzmann_illumination_info(), oomph::BoundaryNode< NODE_TYPE >::assign_eqn_numbers(), oomph::ElementWithExternalElement::assign_external_interaction_data_local_eqn_numbers(), oomph::GeneralisedElement::assign_local_eqn_numbers(), oomph::NodeNodeMortaringElement::construct_lagrange_multipliers(), copy(), DependentPositionPointElement::DependentPositionPointElement(), oomph::DisplacementControlElement::DisplacementControlElement(), oomph::FSI_functions::doc_fsi(), oomph::NodeNodeMortaringElement::fill_in_contribution_to_jacobian_mortared_nodes(), oomph::Hijacked< ELEMENT >::hijack_nodal_position_value(), oomph::NodeElementSolidOnlyMortaringElement::node_and_vector_to_data_pt(), oomph::NodeNodeConstraintElement::NodeNodeConstraintElement(), oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::pin_all_non_pressure_dofs(), oomph::NavierStokesEquations< DIM >::pin_all_non_pressure_dofs(), oomph::SpaceTimeNavierStokesEquations< DIM >::pin_all_non_pressure_dofs(), oomph::SpaceTimeNavierStokesMixedOrderEquations< DIM >::pin_all_non_pressure_dofs(), oomph::NavierStokesSchurComplementPreconditioner::reset_pin_status(), HeatedCircularPenetratorElement::set_contact_element_mesh_pt(), and SlavePositionPointElement::SlavePositionPointElement().

◆ xi() [1/2]

double& oomph::SolidNode::xi ( const unsigned & i )

inline

Reference to i-th Lagrangian position.

     {
 #ifdef RANGE_CHECKING
       xi_gen_range_check(0, i);
 #endif
       return Xi_position[Nlagrangian_type * i];
     }

References i, Nlagrangian_type, xi_gen_range_check(), and Xi_position.

Referenced by ElasticInclinedPlaneProblem< ELEMENT, TIMESTEPPER >::actions_after_implicit_timestep(), oomph::NonLinearElasticitySmoothMesh< ELEMENT >::actions_before_newton_solve(), oomph::TreeBasedRefineableMeshBase::adapt_mesh(), SimpleShearProblem< ELEMENT >::apply_boundary_conditions(), SolidBag::bendBag(), oomph::RefineableSolidQElement< 3 >::build(), oomph::RefineableSolidQElement< 2 >::build(), oomph::CircularCylindricalShellMesh< ELEMENT >::build_mesh(), CylinderAndInterfaceMesh< ELEMENT >::CylinderAndInterfaceMesh(), oomph::Mesh::delete_all_external_storage(), oomph::DummyErrorEstimator::DummyErrorEstimator(), oomph::ElasticRefineableRectangularQuadMesh< ELEMENT >::ElasticRefineableRectangularQuadMesh(), FlatPlateMesh< ELEMENT >::FlatPlateMesh(), oomph::DummyErrorEstimator::get_element_errors(), ElementAnalysis::getXiCenter(), lagrangian_position(), oomph::LinearElasticitySmoothMesh< LINEAR_ELASTICITY_ELEMENT >::operator()(), oomph::PoissonSmoothMesh< POISSON_ELEMENT >::operator()(), oomph::TreeBasedRefineableMeshBase::p_adapt_mesh(), SolidFreeSurfaceRotationProblem< ELEMENT >::set_positions_from_lagrangian_coordinates(), MortaringHelpers::setup_constraint_elements_at_nodes(), ShellMesh< ELEMENT >::ShellMesh(), and RefineableRotatingCylinderProblem< ELEMENT >::solve().

◆ xi() [2/2]

const double& oomph::SolidNode::xi ( const unsigned & i ) const

inline

Reference to i-th Lagrangian position (const version)

     {
 #ifdef RANGE_CHECKING
       xi_gen_range_check(0, i);
 #endif
       return Xi_position[Nlagrangian_type * i];
     }

References i, Nlagrangian_type, xi_gen_range_check(), and Xi_position.

◆ xi_gen() [1/2]

double& oomph::SolidNode::xi_gen	(	const unsigned &	k,
		const unsigned &	i
	)

inline

Reference to the generalised Lagrangian position. ‘Type’: k; 'Coordinate direction: i.

     {
 #ifdef RANGE_CHECKING
       xi_gen_range_check(k, i);
 #endif
       return Xi_position[Nlagrangian_type * i + k];
     }

References i, k, Nlagrangian_type, xi_gen_range_check(), and Xi_position.

Referenced by oomph::CircularCylindricalShellMesh< ELEMENT >::build_mesh(), FlatPlateMesh< ELEMENT >::FlatPlateMesh(), lagrangian_position_gen(), oomph::ProjectionProblem< PROJECTABLE_ELEMENT >::project(), oomph::SolidMesh::set_lagrangian_nodal_coordinates(), and ShellMesh< ELEMENT >::ShellMesh().

◆ xi_gen() [2/2]

const double& oomph::SolidNode::xi_gen	(	const unsigned &	k,
		const unsigned &	i
	)		const

inline

Reference to the generalised Lagrangian position. ‘Type’: k; 'Coordinate direction: i. (const version

     {
 #ifdef RANGE_CHECKING
       xi_gen_range_check(k, i);
 #endif
       return Xi_position[Nlagrangian_type * i + k];
     }

References i, k, Nlagrangian_type, xi_gen_range_check(), and Xi_position.

◆ xi_gen_range_check()

void oomph::SolidNode::xi_gen_range_check	(	const unsigned &	k,
		const unsigned &	i
	)		const

private

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

//////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////// Private function to check that the argument is within the range of stored Lagrangain coordinates and position types.

   {
     // If either the coordinate or type are out of range
     if ((i >= Nlagrangian) || (k >= Nlagrangian_type))
     {
       std::ostringstream error_message;
       // If it's the lagrangian coordinate
       if (i >= Nlagrangian)
       {
         error_message << "Range Error: Xi coordinate " << i
                       << " is not in the range (0," << Nlagrangian - 1 << ")";
       }
       // If it's the position type
       if (k >= Nlagrangian_type)
       {
         error_message << "Range Error: Lagrangian type " << k
                       << " is not in the range (0," << Nlagrangian_type - 1
                       << ")";
       }
  
       throw OomphLibError(
         error_message.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
   }

References i, k, Nlagrangian, Nlagrangian_type, OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

Referenced by xi(), and xi_gen().

Member Data Documentation

◆ Nlagrangian

unsigned oomph::SolidNode::Nlagrangian

protected

Number of Lagrangian coordinates of the node.

Referenced by copy(), dump(), nlagrangian(), read(), and xi_gen_range_check().

◆ Nlagrangian_type

unsigned oomph::SolidNode::Nlagrangian_type

protected

Number of types of Lagrangian coordinates used to interpolate the Lagrangian coordinates within the element

Referenced by copy(), dump(), nlagrangian_type(), read(), xi(), xi_gen(), and xi_gen_range_check().

◆ Variable_position_pt

Data* oomph::SolidNode::Variable_position_pt

protected

Pointer to data that will hold variable positions in elastic nodes.

Referenced by add_value_pt_to_map(), assign_eqn_numbers(), constrain_positions(), copy(), describe_dofs(), does_pointer_correspond_to_position_data(), pin_all(), pin_position(), position_eqn_number(), position_is_a_copy(), position_is_pinned(), set_external_variable_position_pt(), set_position_time_stepper(), SolidNode(), unconstrain_positions(), unpin_all(), unpin_position(), variable_position(), variable_position_pt(), and ~SolidNode().

◆ Xi_position

double* oomph::SolidNode::Xi_position

protected

Storage for the Lagrangian positions.

Referenced by copy(), dump(), read(), SolidNode(), xi(), xi_gen(), and ~SolidNode().

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

Public Member Functions

Protected Attributes

Private Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ SolidNode() [1/4]

◆ SolidNode() [2/4]

◆ SolidNode() [3/4]

◆ ~SolidNode()

◆ SolidNode() [4/4]

Member Function Documentation

◆ add_value_pt_to_map()

◆ assign_eqn_numbers()

◆ constrain_positions()

◆ copy()

◆ describe_dofs()

◆ does_pointer_correspond_to_position_data()

◆ dump()

◆ lagrangian_position()

◆ lagrangian_position_gen()

◆ nlagrangian()

◆ nlagrangian_type()

◆ node_update()

◆ operator=()

◆ pin_all()

◆ pin_position() [1/2]

◆ pin_position() [2/2]

◆ position_eqn_number()

◆ position_is_a_copy() [1/2]

◆ position_is_a_copy() [2/2]

◆ position_is_pinned() [1/2]

◆ position_is_pinned() [2/2]

◆ read()

◆ set_external_variable_position_pt()

◆ set_position_time_stepper()

◆ unconstrain_positions()

◆ unpin_all()

◆ unpin_position() [1/2]

◆ unpin_position() [2/2]

◆ variable_position()

◆ variable_position_pt()

◆ xi() [1/2]

◆ xi() [2/2]

◆ xi_gen() [1/2]

◆ xi_gen() [2/2]

◆ xi_gen_range_check()

Member Data Documentation

◆ Nlagrangian

◆ Nlagrangian_type

◆ Variable_position_pt

◆ Xi_position