#include <node_node_constraint_elements.h>

Inheritance diagram for oomph::NodeNodeMortaringElement:

Public Member Functions
	NodeNodeMortaringElement (Node node0_pt, Node node1_pt, const Vector< int > &mortared_indices={-1})

	NodeNodeMortaringElement (SolidNode node0_pt, SolidNode node1_pt, const Vector< int > &mortared_indices={-1}, const Vector< int > &mortared_solid_indices={-1})

void	construct_lagrange_multipliers () override

void	fill_in_contribution_to_residuals (Vector< double > &residuals) override

void	fill_in_contribution_to_jacobian (Vector< double > &residuals, DenseMatrix< double > &jacobian) override

Public Member Functions inherited from oomph::NodeNodeConstraintElement
	NodeNodeConstraintElement (Node node0_pt, Node node1_pt)

	NodeNodeConstraintElement (SolidNode node0_pt, SolidNode node1_pt)

Data *	node_pt (const unsigned &i)

SolidNode *	solid_node_pt (const unsigned &i)

Public Member Functions inherited from oomph::ConstraintElement
	ConstraintElement (Vector< Data * > &data_pt)

	ConstraintElement (Vector< Data * > data_pt)

Public Member Functions inherited from oomph::GeneralisedElement
	GeneralisedElement ()
	Constructor: Initialise all pointers and all values to zero. More...

virtual	~GeneralisedElement ()
	Virtual destructor to clean up any memory allocated by the object. More...

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

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

Data *&	internal_data_pt (const unsigned &i)
	Return a pointer to i-th internal data object. More...

Data *const &	internal_data_pt (const unsigned &i) const
	Return a pointer to i-th internal data object (const version) More...

Data *&	external_data_pt (const unsigned &i)
	Return a pointer to i-th external data object. More...

Data *const &	external_data_pt (const unsigned &i) const
	Return a pointer to i-th external data object (const version) More...

unsigned long	eqn_number (const unsigned &ieqn_local) const

int	local_eqn_number (const unsigned long &ieqn_global) const

unsigned	add_external_data (Data *const &data_pt, const bool &fd=true)

bool	external_data_fd (const unsigned &i) const

void	exclude_external_data_fd (const unsigned &i)

void	include_external_data_fd (const unsigned &i)

void	flush_external_data ()
	Flush all external data. More...

void	flush_external_data (Data *const &data_pt)
	Flush the object addressed by data_pt from the external data array. More...

unsigned	ninternal_data () const
	Return the number of internal data objects. More...

unsigned	nexternal_data () const
	Return the number of external data objects. More...

unsigned	ndof () const
	Return the number of equations/dofs in the element. More...

void	dof_vector (const unsigned &t, Vector< double > &dof)
	Return the vector of dof values at time level t. More...

void	dof_pt_vector (Vector< double * > &dof_pt)
	Return the vector of pointers to dof values. More...

void	set_internal_data_time_stepper (const unsigned &i, TimeStepper *const &time_stepper_pt, const bool &preserve_existing_data)

void	assign_internal_eqn_numbers (unsigned long &global_number, Vector< double * > &Dof_pt)

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

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

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

virtual void	assign_local_eqn_numbers (const bool &store_local_dof_pt)

virtual void	complete_setup_of_dependencies ()

virtual void	get_residuals (Vector< double > &residuals)

virtual void	get_jacobian (Vector< double > &residuals, DenseMatrix< double > &jacobian)

virtual void	get_mass_matrix (Vector< double > &residuals, DenseMatrix< double > &mass_matrix)

virtual void	get_jacobian_and_mass_matrix (Vector< double > &residuals, DenseMatrix< double > &jacobian, DenseMatrix< double > &mass_matrix)

virtual void	get_dresiduals_dparameter (double *const &parameter_pt, Vector< double > &dres_dparam)

virtual void	get_djacobian_dparameter (double *const &parameter_pt, Vector< double > &dres_dparam, DenseMatrix< double > &djac_dparam)

virtual void	get_djacobian_and_dmass_matrix_dparameter (double *const &parameter_pt, Vector< double > &dres_dparam, DenseMatrix< double > &djac_dparam, DenseMatrix< double > &dmass_matrix_dparam)

virtual void	get_hessian_vector_products (Vector< double > const &Y, DenseMatrix< double > const &C, DenseMatrix< double > &product)

virtual void	get_inner_products (Vector< std::pair< unsigned, unsigned >> const &history_index, Vector< double > &inner_product)

virtual void	get_inner_product_vectors (Vector< unsigned > const &history_index, Vector< Vector< double >> &inner_product_vector)

virtual unsigned	self_test ()

virtual void	compute_norm (Vector< double > &norm)

virtual void	compute_norm (double &norm)

virtual unsigned	ndof_types () const

virtual void	get_dof_numbers_for_unknowns (std::list< std::pair< unsigned long, unsigned >> &dof_lookup_list) const

Private Member Functions
void	fill_in_contribution_to_jacobian_mortared_nodes (Vector< double > &residuals, DenseMatrix< double > &jacobian, const bool &flag)

Private Attributes
Vector< int >	Mortared_Indices

Vector< int >	Mortared_Solid_Indices

Additional Inherited Members
Static Public Attributes inherited from oomph::GeneralisedElement
static bool	Suppress_warning_about_repeated_internal_data

static bool	Suppress_warning_about_repeated_external_data = true

static double	Default_fd_jacobian_step = 1.0e-8

Protected Member Functions inherited from oomph::ConstraintElement
virtual void	evaluate_constraint_functions (Vector< double > &error)

Vector< unsigned >	get_constrained_data_local_index ()

unsigned	get_lagrange_multiplier_index ()

Data *	lagrange_multiplier ()

const int	lagrange_eqn (const unsigned &i)

Data *	ext_data_pt (const unsigned &i)

const int	ext_eqn (const unsigned &i, const unsigned &j)

Protected Member Functions inherited from oomph::GeneralisedElement
unsigned	add_internal_data (Data *const &data_pt, const bool &fd=true)

bool	internal_data_fd (const unsigned &i) const

void	exclude_internal_data_fd (const unsigned &i)

void	include_internal_data_fd (const unsigned &i)

void	clear_global_eqn_numbers ()

void	add_global_eqn_numbers (std::deque< unsigned long > const &global_eqn_numbers, std::deque< double * > const &global_dof_pt)

virtual void	assign_internal_and_external_local_eqn_numbers (const bool &store_local_dof_pt)

virtual void	assign_all_generic_local_eqn_numbers (const bool &store_local_dof_pt)

virtual void	assign_additional_local_eqn_numbers ()

int	internal_local_eqn (const unsigned &i, const unsigned &j) const

int	external_local_eqn (const unsigned &i, const unsigned &j)

void	fill_in_jacobian_from_internal_by_fd (Vector< double > &residuals, DenseMatrix< double > &jacobian, const bool &fd_all_data=false)

void	fill_in_jacobian_from_internal_by_fd (DenseMatrix< double > &jacobian, const bool &fd_all_data=false)

void	fill_in_jacobian_from_external_by_fd (Vector< double > &residuals, DenseMatrix< double > &jacobian, const bool &fd_all_data=false)

void	fill_in_jacobian_from_external_by_fd (DenseMatrix< double > &jacobian, const bool &fd_all_data=false)

virtual void	update_before_internal_fd ()

virtual void	reset_after_internal_fd ()

virtual void	update_in_internal_fd (const unsigned &i)

virtual void	reset_in_internal_fd (const unsigned &i)

virtual void	update_before_external_fd ()

virtual void	reset_after_external_fd ()

virtual void	update_in_external_fd (const unsigned &i)

virtual void	reset_in_external_fd (const unsigned &i)

virtual void	fill_in_contribution_to_mass_matrix (Vector< double > &residuals, DenseMatrix< double > &mass_matrix)

virtual void	fill_in_contribution_to_jacobian_and_mass_matrix (Vector< double > &residuals, DenseMatrix< double > &jacobian, DenseMatrix< double > &mass_matrix)

virtual void	fill_in_contribution_to_dresiduals_dparameter (double *const &parameter_pt, Vector< double > &dres_dparam)

virtual void	fill_in_contribution_to_djacobian_dparameter (double *const &parameter_pt, Vector< double > &dres_dparam, DenseMatrix< double > &djac_dparam)

virtual void	fill_in_contribution_to_djacobian_and_dmass_matrix_dparameter (double *const &parameter_pt, Vector< double > &dres_dparam, DenseMatrix< double > &djac_dparam, DenseMatrix< double > &dmass_matrix_dparam)

virtual void	fill_in_contribution_to_hessian_vector_products (Vector< double > const &Y, DenseMatrix< double > const &C, DenseMatrix< double > &product)

virtual void	fill_in_contribution_to_inner_products (Vector< std::pair< unsigned, unsigned >> const &history_index, Vector< double > &inner_product)

virtual void	fill_in_contribution_to_inner_product_vectors (Vector< unsigned > const &history_index, Vector< Vector< double >> &inner_product_vector)

Protected Attributes inherited from oomph::ConstraintElement
Vector< unsigned >	Constrained_Data_Local_Index

unsigned	Num_Constrained_Data

unsigned	Lagrange_Multiplier_Index

unsigned	Num_Constraints

Static Protected Attributes inherited from oomph::GeneralisedElement
static DenseMatrix< double >	Dummy_matrix

static std::deque< double * >	Dof_pt_deque

Constructor & Destructor Documentation

◆ NodeNodeMortaringElement() [1/2]

oomph::NodeNodeMortaringElement::NodeNodeMortaringElement	(	Node *	node0_pt,
		Node *	node1_pt,
		const Vector< int > &	mortared_indices = `{-1}`
	)

inline

                                                                  {-1}) :
    GeneralisedElement(),
    ConstraintElement({node0_pt, node1_pt}),
    NodeNodeConstraintElement(node0_pt, node1_pt),
    Mortared_Indices(mortared_indices),
    Mortared_Solid_Indices({-1})
   {
    construct_lagrange_multipliers();
   }

◆ NodeNodeMortaringElement() [2/2]

oomph::NodeNodeMortaringElement::NodeNodeMortaringElement	(	SolidNode *	node0_pt,
		SolidNode *	node1_pt,
		const Vector< int > &	mortared_indices = `{-1}`,
		const Vector< int > &	mortared_solid_indices = `{-1}`
	)

inline

                                                                  {-1},
                            const Vector<int>& mortared_solid_indices = {-1}) : // Set to {-1} - this implies we want to mortar all solid dofs
    GeneralisedElement(),
    ConstraintElement({node0_pt, node1_pt, node0_pt->variable_position_pt(), node1_pt->variable_position_pt()}),
    NodeNodeConstraintElement(node0_pt, node1_pt),
    Mortared_Indices(mortared_indices),
    Mortared_Solid_Indices(mortared_solid_indices)
   {
    construct_lagrange_multipliers();
   }

Member Function Documentation

◆ construct_lagrange_multipliers()

void oomph::NodeNodeMortaringElement::construct_lagrange_multipliers ( )

overridevirtual

Reimplemented from oomph::ConstraintElement.

  {
   // If the only specified mortared index is -1 then that indicates that we don't need to mortar anything
   if(Mortared_Indices[0] == -1)
   {
    Mortared_Indices.clear();
   }
   // Otherwise we will be mortaring something
   else
   {
    // If no mortared indices were specified then assume all indices are to be mortared
    if(Mortared_Indices.size()==0)
    {
     // Check that both nodes have the same number of degrees of freedom
     if(node_pt(0)->nvalue() != node_pt(1)->nvalue())
     {
      // Throw an error
      throw OomphLibError("It was requested that all degrees of freedom of nodes is mortared but the nodes have different numbers of degrees of freedom",
                          OOMPH_CURRENT_FUNCTION,
                          OOMPH_EXCEPTION_LOCATION);
     }
     Mortared_Indices.resize(node_pt(0)->nvalue());
     // Set the mortared index numbers
     for(unsigned i=0; i<node_pt(0)->nvalue(); i++)
     {
      Mortared_Indices[i] = i;
     }
    }
   #ifdef RANGE_CHECKING
    // Check that the specified indices are valid
    for(unsigned i=0; i<Mortared_Indices.size(); i++)
    { 
     if(Mortared_Indices[i]>node_pt(0)->nvalue() || Mortared_Indices[i]>node_pt(1)->nvalue())
     {
      // Throw an error
      throw OomphLibError("A constrained index is not valid for a constrained data",
                          OOMPH_CURRENT_FUNCTION,
                          OOMPH_EXCEPTION_LOCATION);
     }
    }
   #endif
   }
  
   // Now do the same for the solid dofs:
  
  
   // If Mortared_Solid_Indices = {-1} that means we mortar in every dimension
   if(Mortared_Solid_Indices.size() == 1 && Mortared_Solid_Indices[0] == -1)
   {
    // Check that both nodes have the same number of dimensions
    if(solid_node_pt(0)->variable_position_pt()->nvalue() != solid_node_pt(1)->variable_position_pt()->nvalue())
    {
     // Throw an error
     throw OomphLibError("Nodes have different dimensions",
                         OOMPH_CURRENT_FUNCTION,
                         OOMPH_EXCEPTION_LOCATION);
    }
    // resize and fill in the mortared solid indices
    Mortared_Solid_Indices.resize(solid_node_pt(0)->variable_position_pt()->nvalue());
    for(unsigned i=0; i<solid_node_pt(0)->variable_position_pt()->nvalue(); i++) Mortared_Solid_Indices[i] = i;
   }
  #ifdef RANGE_CHECKING
   // Check that the specified indices are valid for both nodes
   for(unsigned i=0; i<Mortared_Solid_Indices.size(); i++)
   { 
    if(Mortared_Solid_Indices[i]>solid_node_pt(0)->variable_position_pt()->nvalue())
    {
     // Throw an error
     throw OomphLibError("A constrained index is not valid for a constrained data",
                         OOMPH_CURRENT_FUNCTION,
                         OOMPH_EXCEPTION_LOCATION);
    }
   }
  #endif
  
   Num_Constraints = Mortared_Indices.size() + Mortared_Solid_Indices.size();
   // Create the lagrange multipliers
   Lagrange_Multiplier_Index = add_internal_data(new Data(Num_Constraints), true);
  
   // Check if any constraints are unenforcible and the corresponding lagrange multiplier needs
   // to be pinned
   for(unsigned i=0; i<Mortared_Indices.size(); i++)
   {
    if(node_pt(0)->is_pinned(i) && node_pt(1)->is_pinned(i))
    {
     lagrange_multiplier()->pin(i);
    }
   }
   // Check for the solid dofs
   for(unsigned i=0; i<Mortared_Solid_Indices.size(); i++)
   {
    if(solid_node_pt(0)->variable_position_pt()->is_pinned(i) && solid_node_pt(1)->variable_position_pt()->is_pinned(i))
    {
     lagrange_multiplier()->pin(i);
    }
   }
  }

References oomph::GeneralisedElement::add_internal_data(), i, oomph::ConstraintElement::lagrange_multiplier(), oomph::ConstraintElement::Lagrange_Multiplier_Index, Mortared_Indices, Mortared_Solid_Indices, oomph::NodeNodeConstraintElement::node_pt(), oomph::ConstraintElement::Num_Constraints, oomph::Data::nvalue(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::Data::pin(), oomph::NodeNodeConstraintElement::solid_node_pt(), and oomph::SolidNode::variable_position_pt().

◆ fill_in_contribution_to_jacobian()

void oomph::NodeNodeMortaringElement::fill_in_contribution_to_jacobian	(	Vector< double > &	residuals,
		DenseMatrix< double > &	jacobian
	)

overridevirtual

Add the elemental contribution to the jacobian matrix. and the residuals vector. Note that this function will NOT initialise the residuals vector or the jacobian matrix. It must be called after the residuals vector and jacobian matrix have been initialised to zero. The default is to use finite differences to calculate the jacobian

Reimplemented from oomph::GeneralisedElement.

  {
   fill_in_contribution_to_jacobian_mortared_nodes(residuals, jacobian, 1);
  }

References fill_in_contribution_to_jacobian_mortared_nodes().

◆ fill_in_contribution_to_jacobian_mortared_nodes()

void oomph::NodeNodeMortaringElement::fill_in_contribution_to_jacobian_mortared_nodes	(	Vector< double > &	residuals,
		DenseMatrix< double > &	jacobian,
		const bool &	flag
	)

private

  {
   for(unsigned i=0; i<Num_Constraints; i++)
   {
    bool handling_solid_constraint = false;
    if(i >= Mortared_Indices.size()) handling_solid_constraint = true;
    // Get the nodal values
    Vector<double> nodal_values;
    // Get the nodal values from the solid data
    if(handling_solid_constraint) nodal_values = {solid_node_pt(0)->variable_position_pt()->value(i - Mortared_Indices.size()),
                                                  solid_node_pt(1)->variable_position_pt()->value(i - Mortared_Indices.size())};
  
    // Get the lagrange multiplier value
    const double lambda = lagrange_multiplier()->value(i);
  
    // Lagrange multiplier eqn number
    const int lambda_eqn = lagrange_eqn(i);
  
    // Nodal eqn number
    Vector<int> node_eqn{ext_eqn(0,i),
                         ext_eqn(1,i)};
    // Get the eqn number from the solid data
    if(handling_solid_constraint) node_eqn = {ext_eqn(2, i - Mortared_Indices.size()),
                                              ext_eqn(3, i - Mortared_Indices.size())};
  
   #ifdef PARANOID
    if(node_eqn[0] < 0 && node_eqn[1] < 0 && lambda_eqn>=0)
    {
     throw OomphLibError("Both mutually constrained dofs are pinned. Dof type " + std::to_string(dof_type) + ". " + std::to_string(node_eqn[0]) + " " + std::to_string(node_eqn[1]),
                         OOMPH_CURRENT_FUNCTION,
                         OOMPH_EXCEPTION_LOCATION);
    }
   #endif
    // Residual and jacobian of lagrange multiplier
    if(lambda_eqn>=0)
    {
     // add to the lagrange multiplier residual
     residuals[lambda_eqn] += (nodal_values[0] - nodal_values[1]);
  
     if(flag)
     {
      if(node_eqn[0]>=0)
      {
       jacobian(lambda_eqn, node_eqn[0]) += 1.0;
      }
      if(node_eqn[1]>=0)
      {
       jacobian(lambda_eqn, node_eqn[1]) += -1.0;
      }
     }
    }
    // Residual and jacobian of nodal values
    if(node_eqn[0]>=0)
    {
     residuals[node_eqn[0]] += lambda;
  
     if(flag)
     {
      if(lambda_eqn>=0)
      {
       jacobian(node_eqn[0], lambda_eqn) += 1.0;
      }
     }
    }
    if(node_eqn[1]>=0)
    {
     residuals[node_eqn[1]] += -lambda;
  
     if(flag)
     {
      if(lambda_eqn>=0)
      {
       jacobian(node_eqn[1], lambda_eqn) += -1.0;
      }
     }
    }
   }
  }

References oomph::ConstraintElement::ext_eqn(), i, oomph::ConstraintElement::lagrange_eqn(), oomph::ConstraintElement::lagrange_multiplier(), lambda, Mortared_Indices, oomph::ConstraintElement::Num_Constraints, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::NodeNodeConstraintElement::solid_node_pt(), oomph::StringConversion::to_string(), oomph::Data::value(), and oomph::SolidNode::variable_position_pt().

Referenced by fill_in_contribution_to_jacobian(), and fill_in_contribution_to_residuals().

◆ fill_in_contribution_to_residuals()

void oomph::NodeNodeMortaringElement::fill_in_contribution_to_residuals ( Vector< double > & residuals )

overridevirtual

Add the elemental contribution to the residuals vector. Note that this function will NOT initialise the residuals vector. It must be called after the residuals vector has been initialised to zero.

Reimplemented from oomph::ConstraintElement.

  {
   fill_in_contribution_to_jacobian_mortared_nodes(residuals, GeneralisedElement::Dummy_matrix, 0);
  }

References oomph::GeneralisedElement::Dummy_matrix, and fill_in_contribution_to_jacobian_mortared_nodes().

Member Data Documentation

◆ Mortared_Indices

Vector<int> oomph::NodeNodeMortaringElement::Mortared_Indices

private

Referenced by construct_lagrange_multipliers(), and fill_in_contribution_to_jacobian_mortared_nodes().

◆ Mortared_Solid_Indices

Vector<int> oomph::NodeNodeMortaringElement::Mortared_Solid_Indices

private

Referenced by construct_lagrange_multipliers().

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

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Constructor & Destructor Documentation

◆ NodeNodeMortaringElement() [1/2]

◆ NodeNodeMortaringElement() [2/2]

Member Function Documentation

◆ construct_lagrange_multipliers()

◆ fill_in_contribution_to_jacobian()

◆ fill_in_contribution_to_jacobian_mortared_nodes()

◆ fill_in_contribution_to_residuals()

Member Data Documentation

◆ Mortared_Indices

◆ Mortared_Solid_Indices