element_with_mortaring_status_at_nodes.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_WITH_MORTARING_STATUS_AT_NODES_HEADER
#define ELEMENT_WITH_MORTARING_STATUS_AT_NODES_HEADER
 
#include "generic.h"
 
namespace oomph
{
// Stores an additional double at each node
// The value of the double represents if the node is marked for mortaring/has been mortared or not
// The mortared status is interpolated during mesh refinement
// Mortared status must be pinned before newton solve is called since it has no residual/jacobian fill-in
//TODO
// Generalise a little - replace set_mortared and set_not_mortared with set_mortared_status
// The mortared status can represent whatever the user wants it to
// Remove references to mortaring
// add general number of values
// allows for whatever quantities to be set by the user and interpolated automatically.
// Doees the mortaring status need to be a dof? It could just be stored in an array of sizse number of nodes
//  and interpolated from the nodes of the parent element during refinement by taking the value from this vector.
//  This will remove the need to pin the mortared status dof.
//  It will prevent the mortaring status from being derived from some set of equations, but if the user wants
//  To do this then they can implement that themselves.
template<class ELEMENT>
class ElementWithMortaringStatusAtNodes : public virtual ELEMENT
{
public:
 ElementWithMortaringStatusAtNodes() : ELEMENT(),
                                       Output_Mortared_Status(false) {}
 
 void set_output_mortared_status()
 {
  Output_Mortared_Status = true;
 }
 void set_do_not_output_mortared_status()
 {
  Output_Mortared_Status = false;
 }
 // Add 1 dof to each node to represent the mortared status
 unsigned required_nvalue(const unsigned &n) const override
 {
  return ELEMENT::required_nvalue(n) + 1;
 }
 
 unsigned mortared_dof_index(const unsigned &n) const
 {
  return required_nvalue(n) - 1;
 }
 
 // Mortared status of nth node
 double mortared_status(const unsigned &n) const
 {
  return this->node_pt(n)->value(mortared_dof_index(n));
 }
 
 // Set a node to be mortared or not mortared
 //  this can also be set directly on the node by assigning a value to the (nvalue()-1)th dof of the node
 void set_mortared(const unsigned&n, const double& mortared_status = 1.0)
 {
  return this->node_pt(n)->set_value(mortared_dof_index(n), mortared_status);
 }
 void set_not_mortared(const unsigned&n, const double& mortared_status = 0.0)
 {
  return this->node_pt(n)->set_value(mortared_dof_index(n), mortared_status);
 }
 
 // Pin all mortared status dofs in the nodes. Must be pinned since these dofs intentionally have no
 //  residual or jacobian
 void pin_mortared_status_of_all_nodes()
 {
  for(unsigned n=0; n<this->nnode(); n++)
  {
   this->node_pt(n)->pin(mortared_dof_index(n));
  }
 }
 
 unsigned ncont_interpolated_values() const
 {
  return ELEMENT::ncont_interpolated_values() + 1;
 }
 
 double get_interpolated_mortared_status(const Vector<double>& s)
 {
  double value = 0.0;
  // Find out how many nodes there are
  unsigned n_node = this->nnode();
 
  // Shape functions
  Shape psif(n_node);
  this->shape(s, psif);
  for (unsigned l = 0; l < n_node; l++)
  {
   value += this->mortared_status(l) * psif[l];
  }
  return value;
 }
 void get_interpolated_values(const Vector<double>& s,
                              Vector<double>& values)
 {
  ELEMENT::get_interpolated_values(s,values);
  values.push_back(get_interpolated_mortared_status(s));
 }
 
 void get_interpolated_values(const unsigned& t,
                              const Vector<double>& s,
                              Vector<double>& values)
 {
  ELEMENT::get_interpolated_values(t, s,values);
  values.push_back(get_interpolated_mortared_status(s));
 }
 
 void output(std::ostream& outfile, const unsigned& nplot)
 {
  if(Output_Mortared_Status)
  {
   // vector of local coordinates
   Vector<double> s(this->dim());
 
   // Tecplot header info
   outfile << this->tecplot_zone_string(nplot);
 
   // Loop over plot points
   unsigned num_plot_points = this->nplot_points(nplot);
   for (unsigned iplot = 0; iplot < num_plot_points; iplot++)
   {
    // Get local coordinates of plot point
    this->get_s_plot(iplot, nplot, s);
 
    for (unsigned i = 0; i < this->dim(); i++)
    {
     outfile << this->interpolated_x(s, i) << " ";
    }
 
    outfile << get_interpolated_mortared_status(s);
    outfile << std::endl;
   }
   outfile << std::endl;
   // Write tecplot footer (e.g. FE connectivity lists)
   this->write_tecplot_zone_footer(outfile, nplot);
  }
  else
  {
   ELEMENT::output(outfile, nplot);
  }
 }
 
 // Call the underlying element further build and then pass forward the Output_Mortared_Status flag
 void further_build()
 {
  ELEMENT::further_build();
  Output_Mortared_Status = dynamic_cast<ElementWithMortaringStatusAtNodes<ELEMENT>*>(this->father_element_pt())->get_output_mortared_status();
 }
 
protected:
 const double get_output_mortared_status() const
 {
  return Output_Mortared_Status;
 }
private:
 // When true output will output the mortared status of each node
 bool Output_Mortared_Status;
};
 
// When a face geometry is required, just return a face geometry of the underling element
template<class ELEMENT>
class FaceGeometry<ElementWithMortaringStatusAtNodes<ELEMENT>> : public virtual FaceGeometry<ELEMENT>
{
public:
 FaceGeometry() : FaceGeometry<ELEMENT>() {}
};
 
}//End namespace
#endif