#include <constraint_elements.h>

Inheritance diagram for oomph::ConstraintElement:

Public Member Functions
	ConstraintElement (Vector< Data * > &data_pt)

	ConstraintElement (Vector< Data * > data_pt)

virtual void	fill_in_contribution_to_residuals (Vector< double > &residuals)

virtual void	construct_lagrange_multipliers ()

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

Protected Member Functions
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_jacobian (Vector< double > &residuals, DenseMatrix< double > &jacobian)

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
Vector< unsigned >	Constrained_Data_Local_Index

unsigned	Num_Constrained_Data

unsigned	Lagrange_Multiplier_Index

unsigned	Num_Constraints

Private Member Functions
void	build (Vector< Data * > &data_pt)

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

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

static std::deque< double * >	Dof_pt_deque

Constructor & Destructor Documentation

◆ ConstraintElement() [1/2]

oomph::ConstraintElement::ConstraintElement ( Vector< Data * > & data_pt )

inline

                                             : Num_Constraints(0)
   {
    build(data_pt);
   }

References build().

◆ ConstraintElement() [2/2]

oomph::ConstraintElement::ConstraintElement ( Vector< Data * > data_pt )

inline

                                            : Num_Constraints(0)
   {
    build(data_pt);
   }

References build().

Member Function Documentation

◆ build()

void oomph::ConstraintElement::build ( Vector< Data * > & data_pt )

inlineprivate

   {
    // Add the data as external data
    Num_Constrained_Data = data_pt.size();
    Constrained_Data_Local_Index.resize(Num_Constrained_Data);
    for(unsigned i=0; i<Num_Constrained_Data; i++)
    {
     // Add the external data - we want to add it to the finite differencing
     Constrained_Data_Local_Index[i] = add_external_data(data_pt[i], true);
    }
   }

References oomph::GeneralisedElement::add_external_data(), Constrained_Data_Local_Index, i, and Num_Constrained_Data.

Referenced by ConstraintElement().

◆ construct_lagrange_multipliers()

void oomph::ConstraintElement::construct_lagrange_multipliers ( )

virtual

Reimplemented in oomph::NodeNodeMortaringElement.

  {
   // Get the number of constraints by calling evaluate_constraint_functions
   Vector<double> test_error;
   evaluate_constraint_functions(test_error);
   Num_Constraints = test_error.size();
  
   // Create the lagrange multipliers
   // - by default we want to include the lagrange multipliers in any finite differencing
   Lagrange_Multiplier_Index = add_internal_data(new Data(Num_Constraints), true);
  
  
   // TODO THE BELOW REQUIRES THAT EQN NUMBERS HAVE BEEN ASSIGNED....HOW TO AVOID THIS REQUIREMENT??
   // IT WOULD BE NICE TO HAVE AN AUTOMATIC CHECK THAT A CONSTRAINT IS ENFORCIBLE.
   // Could resolve this by adding a function to check if the lagrange multipliers are enforcible
   // which can be called after the equation numbers have been assigned.
   // Or could just remove this check. If the user is trying to over constrain the system then
   // they'll be made aware of that when the Jacobian is singular.
  
   // Determine if each constraint is enforcible
   // - construct the jacobian and check if the rows/columns of the lagrange multipliers are zero
   // - this assumes that there is no point at which the derivatives of the constraint functions
   //   vanish which is a sensible assumption if they do then the problem could mysteriously become
   //   singular without warning. Therefore by assuming that the constraint functions do not vanish
   //   the only way a lagrange multiplier row/column of the jacobian is singular is if it has no
   //   dependence on any unpinned degrees of freedom.
  
   // // Calculate the jacobian
   // Vector<double> residuals(this->ndof());
   // DenseMatrix<double> jacobian(this->ndof());
   // fill_in_contribution_to_jacobian(residuals, jacobian);
  
   // // Interrogate the rows/columns of each lagrange multiplier and check that they are not zero.
   // // if they are then pin that lagrange multiplier
   // for(unsigned i=0; i<Num_Constraints; i++)
   // {
   //  // Get the local equation of the lagrange multiplier
   //  const int l_index = lagrange_eqn(i);
    
   //  // Loop over external data
   //  for(unsigned j=0; j<Num_Constrained_Data; j++)
   //  {
   //   // Loop over the dofs in that external data
   //   const unsigned num_dofs = external_data_pt(j)->nvalue();
   //   for(unsigned k=0; k<num_dofs; k++)
   //   {
   //    // Get the local equation of the external dof
   //    const int ext_index = external_local_eqn(j, k);
   //    // If the external dof is pinned then skip it
   //    if(ext_index < 0) continue;
   //    if(abs(jacobian(l_index,ext_index)) > FiniteElement::Tolerance_for_singular_jacobian || abs(jacobian(ext_index,l_index)) > FiniteElement::Tolerance_for_singular_jacobian)
   //    {
   //     // If the entry is non-zero then the constraint is enforcible, stop checking
   //     goto constraintIsEnforcible;
   //    }
   //   }
   //  }
   //  // If we have got to here then there are no non-zero entries in the lagrange multiplier column/row of the jacobian so it is unenforcible
   //  lagrange_multiplier()->pin(i);
   // #ifdef PARANOID
   //  // Tell the user
   //  std::cout << "A constraint is unenforcible because there are not sufficient unpinned dofs the constraint is dependent on.\nPinning corresponding lagrange multiplier" << std::endl;  
   // #endif
   
   //  // Using a goto because we have 2 nested for loops
   // constraintIsEnforcible:
   //  continue;
   // }
  }

References oomph::GeneralisedElement::add_internal_data(), evaluate_constraint_functions(), Lagrange_Multiplier_Index, and Num_Constraints.

◆ evaluate_constraint_functions()

void oomph::ConstraintElement::evaluate_constraint_functions ( Vector< double > & error )

protectedvirtual

Reimplemented in oomph::ElementElementMortaringElement.

  {
   // Throw an error
   throw OomphLibError("evaluate_constraint_functions has not been implemented for this element.\nIt must be implemented in any class which inherits from ConstraintElement",
                       OOMPH_CURRENT_FUNCTION,
                       OOMPH_EXCEPTION_LOCATION);
  }

References OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

Referenced by construct_lagrange_multipliers(), and fill_in_contribution_to_residuals().

◆ ext_data_pt()

Data* oomph::ConstraintElement::ext_data_pt ( const unsigned & i )

inlineprotected

   {
   #ifdef RANGE_CHECKING
    if(i>=Num_Constrained_Data)
    {
     throw OomphLibError(std::to_string(i) + " is greater than the number of constrained data " + std::to_string(Num_Constrained_Data),
                         OOMPH_CURRENT_FUNCTION,
                         OOMPH_EXCEPTION_LOCATION);
    }
   #endif
    return external_data_pt(Constrained_Data_Local_Index[i]);
   }

References Constrained_Data_Local_Index, oomph::GeneralisedElement::external_data_pt(), i, Num_Constrained_Data, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, and oomph::StringConversion::to_string().

Referenced by oomph::NodeElementSolidOnlyMortaringElement::fill_in_contribution_to_jacobian_mortared_nodes(), fill_in_contribution_to_residuals(), oomph::NodeNodeConstraintElement::node_pt(), oomph::NodeElementSolidOnlyMortaringElement::position_in_element(), and oomph::NodeNodeConstraintElement::solid_node_pt().

◆ ext_eqn()

const int oomph::ConstraintElement::ext_eqn	(	const unsigned &	i,
		const unsigned &	j
	)

inlineprotected

   {
   #ifdef RANGE_CHECKING
    if(i>=Num_Constrained_Data)
    {
     throw OomphLibError(std::to_string(i) + " is greater than the number of constrained data " + std::to_string(Num_Constrained_Data),
                         OOMPH_CURRENT_FUNCTION,
                         OOMPH_EXCEPTION_LOCATION);
    }
   #endif
    return external_local_eqn(Constrained_Data_Local_Index[i], j);
   }

References Constrained_Data_Local_Index, oomph::GeneralisedElement::external_local_eqn(), i, j, Num_Constrained_Data, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, and oomph::StringConversion::to_string().

Referenced by oomph::NodeElementSolidOnlyMortaringElement::fill_in_contribution_to_jacobian_mortared_nodes(), and oomph::NodeNodeMortaringElement::fill_in_contribution_to_jacobian_mortared_nodes().

◆ fill_in_contribution_to_residuals()

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

virtual

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

Reimplemented in oomph::NodeNodeMortaringElement, and oomph::NodeElementSolidOnlyMortaringElement.

  {
   // Compute the residual by finite differencing the constraints
   // R_{x_i} = \lambda_k \frac{\partial g_k}{\partial x_i}
   // R_{\lambda_i} = g_i
  
   // Use the default finite difference step
   const double fd_step = Default_fd_jacobian_step;
  
   // Get the error
   Vector<double> error;
   evaluate_constraint_functions(error);
  
   // Create test_error vector
   Vector<double> test_error;
   
   // Update the residual entry for each of the lagrange multipliers
   for(unsigned i=0; i<Num_Constraints; i++)
   {
    // Get the local equation of the lagrange multiplier
    const int l_index = lagrange_eqn(i);
  
    // R_{\lambda_i} = g_i
    residuals[l_index] = error[i];
   }
  
   // For each of the external data finite difference the constraint equations to find the residual entry
   for (unsigned i=0; i<Num_Constrained_Data; i++)
   {
    // Get the number of values at the external data
    const unsigned n_value = ext_data_pt(i)->nvalue();
    for(unsigned j=0; j<n_value; j++)
    {
     // Get the local equation of the external dof
     const int ext_index = external_local_eqn(i, j);
  
     // If it is pinned then skip it
     if(ext_index < 0) continue;
     
     // Get a pointer to the External data value
     double* const value_pt = ext_data_pt(i)->value_pt(j);
  
     // Save the old value of the External data
     const double old_var = *value_pt;
  
     // Increment the value of the External data
     *value_pt += fd_step;
  
     // Evaluate the constraint functions at the new variables value
     evaluate_constraint_functions(test_error);
  
     // R_{x_i} = \lambda_k \frac{\partial g_k}{\partial x_i}
     double sum = 0.0;
     // Do finite differences
     for (unsigned k = 0; k < Num_Constraints; k++)
     {
      if(lagrange_multiplier()->is_pinned(k)) continue;
      sum += lagrange_multiplier()->value(k) * (test_error[k] - error[k]) / fd_step;
     }
  
     // Add to the residuals
     residuals[ext_index] = sum;
    }
   }
  }

References oomph::GeneralisedElement::Default_fd_jacobian_step, calibrate::error, evaluate_constraint_functions(), ext_data_pt(), oomph::GeneralisedElement::external_local_eqn(), i, j, k, lagrange_eqn(), lagrange_multiplier(), Num_Constrained_Data, Num_Constraints, oomph::Data::nvalue(), oomph::Data::value(), and oomph::Data::value_pt().

◆ get_constrained_data_local_index()

Vector<unsigned> oomph::ConstraintElement::get_constrained_data_local_index ( )

inlineprotected

   {
    return Constrained_Data_Local_Index;
   }

References Constrained_Data_Local_Index.

◆ get_lagrange_multiplier_index()

unsigned oomph::ConstraintElement::get_lagrange_multiplier_index ( )

inlineprotected

   {
    return Lagrange_Multiplier_Index;
   }

References Lagrange_Multiplier_Index.

◆ lagrange_eqn()

const int oomph::ConstraintElement::lagrange_eqn ( const unsigned & i )

inlineprotected

   {
    // std::cout << "lagrange_eqn(" << i << ") ninternal_data " << ninternal_data() << std::endl;
   #ifdef RANGE_CHECKING
    if(i>=Num_Constraints)
    {
     throw OomphLibError(std::to_string(i) + " is greater than the number of constraints " + std::to_string(Num_Constraints),
                         OOMPH_CURRENT_FUNCTION,
                         OOMPH_EXCEPTION_LOCATION);
    }
   #endif
    return internal_local_eqn(Lagrange_Multiplier_Index, i);
   }

References i, oomph::GeneralisedElement::internal_local_eqn(), Lagrange_Multiplier_Index, Num_Constraints, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, and oomph::StringConversion::to_string().

Referenced by oomph::NodeElementSolidOnlyMortaringElement::fill_in_contribution_to_jacobian_mortared_nodes(), oomph::NodeNodeMortaringElement::fill_in_contribution_to_jacobian_mortared_nodes(), and fill_in_contribution_to_residuals().

◆ lagrange_multiplier()

Data* oomph::ConstraintElement::lagrange_multiplier ( )

inlineprotected

   {
    return internal_data_pt(Lagrange_Multiplier_Index);
   }

References oomph::GeneralisedElement::internal_data_pt(), and Lagrange_Multiplier_Index.

Referenced by oomph::NodeNodeMortaringElement::construct_lagrange_multipliers(), oomph::NodeElementSolidOnlyMortaringElement::fill_in_contribution_to_jacobian_mortared_nodes(), oomph::NodeNodeMortaringElement::fill_in_contribution_to_jacobian_mortared_nodes(), and fill_in_contribution_to_residuals().

Member Data Documentation

◆ Constrained_Data_Local_Index

Vector<unsigned> oomph::ConstraintElement::Constrained_Data_Local_Index

protected

Referenced by build(), ext_data_pt(), ext_eqn(), and get_constrained_data_local_index().

◆ Lagrange_Multiplier_Index

unsigned oomph::ConstraintElement::Lagrange_Multiplier_Index

protected

Referenced by construct_lagrange_multipliers(), oomph::NodeNodeMortaringElement::construct_lagrange_multipliers(), get_lagrange_multiplier_index(), lagrange_eqn(), lagrange_multiplier(), and oomph::NodeElementSolidOnlyMortaringElement::NodeElementSolidOnlyMortaringElement().

◆ Num_Constrained_Data

unsigned oomph::ConstraintElement::Num_Constrained_Data

protected

Referenced by build(), oomph::ElementElementConstraintElement::build(), ext_data_pt(), ext_eqn(), and fill_in_contribution_to_residuals().

◆ Num_Constraints

unsigned oomph::ConstraintElement::Num_Constraints

protected

Referenced by construct_lagrange_multipliers(), oomph::NodeNodeMortaringElement::construct_lagrange_multipliers(), oomph::NodeNodeMortaringElement::fill_in_contribution_to_jacobian_mortared_nodes(), fill_in_contribution_to_residuals(), lagrange_eqn(), and oomph::NodeElementSolidOnlyMortaringElement::NodeElementSolidOnlyMortaringElement().

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

Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Additional Inherited Members

Constructor & Destructor Documentation

◆ ConstraintElement() [1/2]

◆ ConstraintElement() [2/2]

Member Function Documentation

◆ build()

◆ construct_lagrange_multipliers()

◆ evaluate_constraint_functions()

◆ ext_data_pt()

◆ ext_eqn()

◆ fill_in_contribution_to_residuals()

◆ get_constrained_data_local_index()

◆ get_lagrange_multiplier_index()

◆ lagrange_eqn()

◆ lagrange_multiplier()

Member Data Documentation

◆ Constrained_Data_Local_Index

◆ Lagrange_Multiplier_Index

◆ Num_Constrained_Data

◆ Num_Constraints