element_element_constraint_elements.h

Go to the documentation of this file.

// This file is part of the MercuryDPM project (https://www.mercurydpm.org).
// Copyright (c), The MercuryDPM Developers Team. All rights reserved.
// License: BSD 3-Clause License; see the LICENSE file in the root directory.
 
#ifndef ELEMENT_ELEMENT_CONSTRAINT_ELEMENTS_HEADER
#define ELEMENT_ELEMENT_CONSTRAINT_ELEMENTS_HEADER
 
#include "constraint_elements.h"
 
// TODO these haven't been tested and probably have several issues.
 
namespace oomph
{
 // Helper class containing a single static function.
 // Get the data of an element and return them in a known order: local nodes, external data
 class ElementElementConstraintElementHelper
 {
 public:
  static Vector<Data*> element_pt_to_data_pt(Vector<FiniteElement*> elem_pt);
 };
 
 // Constrain two elements. Collects the local and external data of the elements and adds them as 
 
 // Must call construct_lagrange_multipliers() in the constructor of any derived class
 class ElementElementConstraintElement : public virtual ConstraintElement
 {
 public:
  ElementElementConstraintElement(Vector<FiniteElement*> elem_pt) :
    ConstraintElement(ElementElementConstraintElementHelper::element_pt_to_data_pt(elem_pt)),
    Element_pt(elem_pt),
    N_Element(elem_pt.size())
  {
   // 
   build(elem_pt);
  }
  
 
 protected:
  FiniteElement* elem_pt(const unsigned& i)
  {
  #ifdef RANGE_CHECKING
   if(i>=N_Element)
   {
    throw OomphLibError(std::to_string(i) + " is greater than the number of elements " + std::to_string(N_Element),
                        OOMPH_CURRENT_FUNCTION,
                        OOMPH_EXCEPTION_LOCATION);
   }
  #endif
   return Element_pt[i];
  }
 
  // Get the ith data of the eth element
  Data* node_pt(const unsigned& e, const unsigned& i)
  {
   return external_data_pt(Node_Local_Index[e][i]);
  }
  // Get the ith internal of the eth element
  Data* extern_data_pt(const unsigned& e, const unsigned& i)
  {
   return external_data_pt(Internal_Data_Local_Index[e][i]);
  }
  // Get the ith external of the eth element
  Data* intern_data_pt(const unsigned& e, const unsigned& i)
  {
   return external_data_pt(External_Data_Local_Index[e][i]);
  }
 
  const int node_eqn(const unsigned& e, const unsigned& i, const unsigned& j)
  {
   return external_local_eqn(Node_Local_Index[e][i], j);
  }
  const int extern_data_eqn(const unsigned& e, const unsigned& i, const unsigned& j)
  {
   return external_local_eqn(Internal_Data_Local_Index[e][i], j);
  }
  const int intern_data_eqn(const unsigned& e, const unsigned& i, const unsigned& j)
  {
   return external_local_eqn(External_Data_Local_Index[e][i], j);
  }
 
 private:
  // Finish the element build
  void build(Vector<FiniteElement*>& elem_pt);
  // Number of elements constrained
  unsigned N_Element;
  // Pointers to the two elements
  Vector<FiniteElement*> Element_pt;
  // The lookup for the external data local index for the nodes of the element
  Vector<Vector<unsigned>> Node_Local_Index;
  // Number of nodes in each element
  Vector<unsigned> N_Node;
  // The lookup for the external data local index for the internal data of the element
  Vector<Vector<unsigned>> Internal_Data_Local_Index;
  // Number of internal data in each element
  Vector<unsigned> N_Internal_Data;
  // The lookup for the external data local index for the external data of the element
  Vector<Vector<unsigned>> External_Data_Local_Index;
  // Number of external data in each element
  Vector<unsigned> N_External_Data;
 };
 
 
 
 
 
 
 // A specific reimplementation of ElementElementConstraintElement which enforces that interpolated solid dofs at
 // all specified indicies of the nodes passed to the constructor are identical in value
 class ElementElementMortaringElement : public virtual ElementElementConstraintElement
 {
 public:
  // Pointers to the nodes which own the dofs which are to be pinned. Pass in the list of indices which are to be mortared
  // for this mortaring element a list of indices must be passed since there is no general way of finding how many values
  // an element can sensibly interpolate from the nodes
  ElementElementMortaringElement(FiniteElement* elem0_pt, FiniteElement* elem1_pt,
                                 Vector<double>& s0, Vector<double>& s1,
                                 const Vector<unsigned>& mortared_dimensions = {0,1,2}) :
         ConstraintElement(ElementElementConstraintElementHelper::element_pt_to_data_pt({elem0_pt, elem1_pt})),
         ElementElementConstraintElement({elem0_pt, elem1_pt}),
         Local_Coord({s0, s1}),
         Mortared_Dimensions(mortared_dimensions)
  {
   if(elem0_pt->dim() != elem1_pt->dim())
   {
    // Throw an error
    throw OomphLibError("The elements do not have the same dimension",
                        OOMPH_CURRENT_FUNCTION,
                        OOMPH_EXCEPTION_LOCATION);
   }
   // There are never more than 3 dimensions
   if(mortared_dimensions.size()>elem0_pt->dim())
   {
    // Throw an error
    throw OomphLibError("Specified more than " + std::to_string(elem0_pt->dim()) + " dimensions to pin",
                        OOMPH_CURRENT_FUNCTION,
                        OOMPH_EXCEPTION_LOCATION);
   }
 
   construct_lagrange_multipliers();
  }
 
 protected:
  // Generic interface for evaluating constraint functions
  // - must re-size the error vector to the number of constraints being enforced
  void evaluate_constraint_functions(Vector<double>& error);
 private:
  Vector<Vector<double>> Local_Coord;
  Vector<unsigned> Mortared_Dimensions;
 };
} // End namespace
#endif