node_node_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 NODE_NODE_CONSTRAINT_ELEMENTS_HEADER
#define NODE_NODE_CONSTRAINT_ELEMENTS_HEADER
 
#include "constraint_elements.h"
 
// Config header generated by autoconfig
#ifdef HAVE_CONFIG_H
#include <oomph-lib-config.h>
#endif
 
 
namespace oomph
{
 // Generic for constructing constraints between two nodes.
 // Must call construct_lagrange_multipliers() in the constructor of any derived class
 class NodeNodeConstraintElement : public virtual ConstraintElement
 {
 public:
  // Pointers to the nodes which own the dofs which are to be pinned
  NodeNodeConstraintElement(Node* node0_pt, Node* node1_pt) :
   GeneralisedElement(),
   ConstraintElement({node0_pt, node1_pt})
  {
  }
 
  // Pointers to the nodes which own the dofs which are to be pinned,
  //  includes additional data pointers for the variational positions
  NodeNodeConstraintElement(SolidNode* node0_pt, SolidNode* node1_pt) :
   GeneralisedElement(),
   ConstraintElement({node0_pt,
                      node1_pt,
                      node0_pt->variable_position_pt(),
                      node1_pt->variable_position_pt()})
  {
  }
 
  // return a pointer to the i-th node
  Data* node_pt(const unsigned& i)
  {
  #ifdef RANGE_CHECKING
   if(i!=0 || i!=1)
   {
    throw OomphLibError("There are only 2 nodes but you requested node " + std::to_string(i),
                        OOMPH_CURRENT_FUNCTION,
                        OOMPH_EXCEPTION_LOCATION);
   }
  #endif
   return ext_data_pt(i);
  }
  
  // Access the i-th node as a solid node pt
  SolidNode* solid_node_pt(const unsigned& i)
  {
  #ifdef PARANOID
   if(dynamic_cast<SolidNode*>(ext_data_pt(i)) == nullptr)
   {
    throw OomphLibError("Node* cannot be cast to SolidNode*",
                        OOMPH_CURRENT_FUNCTION,
                        OOMPH_EXCEPTION_LOCATION);
   }
  #endif
   return dynamic_cast<SolidNode*>(ext_data_pt(i));
  }
 };
 
 
 // A specific reimplementation of NodeNodeConstraintElement which enforces that dofs at
 // all specified indicies of the nodes passed to the constructor are identical in value
 // including solid dofs.
 class NodeNodeMortaringElement : public virtual NodeNodeConstraintElement
 {
 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
  NodeNodeMortaringElement(Node* node0_pt, Node* node1_pt,
                           const Vector<int>& mortared_indices = {-1}) :
   GeneralisedElement(),
   ConstraintElement({node0_pt, node1_pt}),
   NodeNodeConstraintElement(node0_pt, node1_pt),
   Mortared_Indices(mortared_indices),
   Mortared_Solid_Indices({-1})
  {
   construct_lagrange_multipliers();
  }
 
  // Pointers to the nodes which own the dofs which are to be pinned. Pass in the list of indices which are to be mortared and list
  // of solid dofs which are to be mortared.
  // var_pos1_pt and var_pos1_pt
  NodeNodeMortaringElement(SolidNode* node0_pt, SolidNode* node1_pt,
                           const Vector<int>& mortared_indices = {-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();
  }
 
  // We know precisely how many lagrange multipliers we need and what the residual and jacobian entries are
  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;
 
 private:
  void fill_in_contribution_to_jacobian_mortared_nodes(Vector<double>& residuals, DenseMatrix<double>& jacobian, const bool& flag);
  Vector<int> Mortared_Indices;
  Vector<int> Mortared_Solid_Indices;
 };
} // End namespace
#endif