oomph::ElasticUpdateFluidInterfaceElement< EQUATION_CLASS, DERIVATIVE_CLASS, ELEMENT > Class Template Reference

#include <specific_node_update_interface_elements.h>

Inheritance diagram for oomph::ElasticUpdateFluidInterfaceElement< EQUATION_CLASS, DERIVATIVE_CLASS, ELEMENT >:

Public Member Functions
	ElasticUpdateFluidInterfaceElement (FiniteElement *const &element_pt, const int &face_index, const unsigned &id=0)
double	zeta_nodal (const unsigned &n, const unsigned &k, const unsigned &i) const
double &	lagrange (const unsigned &n)
	Return the lagrange multiplier at local node n. More...
void	fill_in_contribution_to_jacobian (Vector< double > &residuals, DenseMatrix< double > &jacobian)
	Fill in contribution to residuals and Jacobian. More...
void	output (std::ostream &outfile)
	Overload the output function. More...
void	output (std::ostream &outfile, const unsigned &n_plot)
	Output the element. More...
void	output (FILE *file_pt)
	Overload the C-style output function. More...
void	output (FILE *file_pt, const unsigned &n_plot)
	C-style Output function. More...
void	add_additional_residual_contributions_interface (Vector< double > &residuals, DenseMatrix< double > &jacobian, const unsigned &flag, const Shape &psif, const DShape &dpsifds, const DShape &dpsifdS, const DShape &dpsifdS_div, const Vector< double > &s, const Vector< double > &interpolated_x, const Vector< double > &interpolated_n, const double &W, const double &J)
virtual FluidInterfaceBoundingElement *	make_bounding_element (const int &face_index)
Public Member Functions inherited from oomph::Hijacked< FaceGeometry< ELEMENT > >
	Hijacked ()
	Constructor, call the constructors of the base elements. More...
	Hijacked (FiniteElement *const &element_pt, const int &face_index)
	Constructor used for hijacking face elements. More...
	Hijacked (FiniteElement *const &element_pt, const int &face_index, const unsigned &id=0)
Data *	hijack_internal_value (const unsigned &n, const unsigned &i, const bool &return_data=true)
Data *	hijack_external_value (const unsigned &n, const unsigned &i, const bool &return_data=true)
Data *	hijack_nodal_value (const unsigned &n, const unsigned &i, const bool &return_data=true)
Data *	hijack_nodal_position_value (const unsigned &n, const unsigned &i, const bool &return_data=true)
Data *	hijack_nodal_spine_value (const unsigned &n, const unsigned &i, const bool &return_data=true)
void	assign_local_eqn_numbers (const bool &store_local_dof_pt)
void	get_residuals (Vector< double > &residuals)
void	get_jacobian (Vector< double > &residuals, DenseMatrix< double > &jacobian)
Public Member Functions inherited from oomph::HijackedElementBase
	HijackedElementBase ()
virtual	~HijackedElementBase ()
	Destructor, destroy the storage for the equation numbers. More...
void	unhijack_all_data ()
const double &	residual_multiplier () const
	Return the value of the residual multiplier. More...
double *&	residual_multiplier_pt ()
	Return the pointer to the residual multiplier. More...

Protected Member Functions
double	compute_surface_derivatives (const Shape &psi, const DShape &dpsids, const DenseMatrix< double > &interpolated_t, const Vector< double > &interpolated_x, DShape &surface_gradient, DShape &surface_divergence)
Protected Member Functions inherited from oomph::HijackedElementBase
void	hijack_global_eqn (long *const &global_eqn_pt)
void	unhijack_global_eqn (long *const &global_eqn_pt)

Private Member Functions
unsigned	lagrange_index (const unsigned &n)
int	kinematic_local_eqn (const unsigned &n)
void	hijack_kinematic_conditions (const Vector< unsigned > &bulk_node_number)

Private Attributes
Vector< unsigned >	Lagrange_index

Additional Inherited Members
Protected Attributes inherited from oomph::HijackedElementBase
std::set< long * > *	Hijacked_global_eqn_number_pt
Vector< int > *	Hijacked_local_eqn_number_pt
double *	Residual_multiplier_pt
Static Protected Attributes inherited from oomph::HijackedElementBase
static double	Default_residual_multiplier = 0.0

Detailed Description

template<class EQUATION_CLASS, class DERIVATIVE_CLASS, class ELEMENT>
class oomph::ElasticUpdateFluidInterfaceElement< EQUATION_CLASS, DERIVATIVE_CLASS, ELEMENT >

//////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// Generic Elastic node update interface template class that can be combined with a given surface equations class and surface derivative class to provide a concrete implementation of any surface element that uses elastic node updates.

Constructor & Destructor Documentation

ElasticUpdateFluidInterfaceElement()

template<class EQUATION_CLASS , class DERIVATIVE_CLASS , class ELEMENT >

oomph::ElasticUpdateFluidInterfaceElement< EQUATION_CLASS, DERIVATIVE_CLASS, ELEMENT >::ElasticUpdateFluidInterfaceElement ( FiniteElement *const &  element_pt, const int &  face_index, const unsigned &  id = 0  )

inline

Constructor, pass a pointer to the bulk element and the face index of the bulk element to which the element is to be attached to. The optional identifier can be used to distinguish the additional nodal value (Lagr mult) created by this element from those created by other FaceElements.

      : FaceGeometry<ELEMENT>(), EQUATION_CLASS(), DERIVATIVE_CLASS()
    {
      // Attach the geometrical information to the element
      // This function also assigned nbulk_value from required_nvalue of the
      // bulk element
      element_pt->build_face_element(face_index, this);
 
#ifdef PARANOID
      // Is it refineable
      RefineableElement* ref_el_pt =
        dynamic_cast<RefineableElement*>(element_pt);
      if (ref_el_pt != 0)
      {
        if (this->has_hanging_nodes())
        {
          throw OomphLibError(
            "This flux element will not work correctly if nodes are hanging\n",
            OOMPH_CURRENT_FUNCTION,
            OOMPH_EXCEPTION_LOCATION);
        }
      }
#endif
 
      // Find the index at which the velocity unknowns are stored
      // from the bulk element and resize the local storage scheme
      ELEMENT* cast_element_pt = dynamic_cast<ELEMENT*>(element_pt);
      const unsigned n_u_index = cast_element_pt->n_u_nst();
      this->U_index_interface.resize(n_u_index);
      for (unsigned i = 0; i < n_u_index; i++)
      {
        this->U_index_interface[i] = cast_element_pt->u_index_nst(i);
      }
 
      // Read out the number of nodes on the face
      unsigned n_node_face = this->nnode();
 
      // Create an instance of the policy class that determines
      // how many additional values are required
      FluidInterfaceAdditionalValues<EQUATION_CLASS>*
        interface_additional_values_pt =
          new FluidInterfaceAdditionalValues<EQUATION_CLASS>();
 
      // Set the additional data values in the face
      // There is always also one additional values at each node --- the
      // Lagrange multiplier
      Vector<unsigned> additional_data_values(n_node_face);
      for (unsigned n = 0; n < n_node_face; n++)
      {
        // Now add one to the addtional values at every single node
        additional_data_values[n] =
          interface_additional_values_pt->nadditional_values(n) + 1;
      }
 
      // Now add storage for Lagrange multipliers and set the map containing
      // the position of the first entry of this face element's
      // additional values.
      this->add_additional_values(additional_data_values, id);
 
      // Now I can just store the lagrange index offset to give the storage
      // location of the nodes
      Lagrange_index.resize(n_node_face);
      for (unsigned n = 0; n < n_node_face; ++n)
      {
        Lagrange_index[n] =
          additional_data_values[n] - 1 +
          dynamic_cast<BoundaryNodeBase*>(this->node_pt(n))
            ->index_of_first_value_assigned_by_face_element(id);
      }
 
      // Call any local setup from the interface policy class
      interface_additional_values_pt->setup_equation_indices(this, id);
 
      // Can now delete the policy class
      delete interface_additional_values_pt;
      interface_additional_values_pt = 0;
    }

References oomph::FiniteElement::build_face_element(), i, oomph::ElasticUpdateFluidInterfaceElement< EQUATION_CLASS, DERIVATIVE_CLASS, ELEMENT >::Lagrange_index, n, oomph::FluidInterfaceAdditionalValues< ELEMENT >::nadditional_values(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, and oomph::FluidInterfaceAdditionalValues< ELEMENT >::setup_equation_indices().

Member Function Documentation

add_additional_residual_contributions_interface()

template<class EQUATION_CLASS , class DERIVATIVE_CLASS , class ELEMENT >

void oomph::ElasticUpdateFluidInterfaceElement< EQUATION_CLASS, DERIVATIVE_CLASS, ELEMENT >::add_additional_residual_contributions_interface ( Vector< double > &  residuals, DenseMatrix< double > &  jacobian, const unsigned &  flag, const Shape &  psif, const DShape &  dpsifds, const DShape &  dpsifdS, const DShape &  dpsifdS_div, const Vector< double > &  s, const Vector< double > &  interpolated_x, const Vector< double > &  interpolated_n, const double &  W, const double &  J  )

inline

Helper function to calculate the additional contributions to be added at each integration point. This deals with Lagrange multiplier contribution, as well as any additional contributions by the other equations.

    {
      EQUATION_CLASS::add_additional_residual_contributions_interface(
        residuals,
        jacobian,
        flag,
        psif,
        dpsifds,
        dpsifdS,
        dpsifdS_div,
        s,
        interpolated_x,
        interpolated_n,
        W,
        J);
 
      // Assemble Lagrange multiplier by loop over the shape functions
      const unsigned n_node = this->nnode();
      // Read out the dimension of the node
      const unsigned nodal_dimension = this->nodal_dimension();
 
      double interpolated_lagrange = 0.0;
      for (unsigned l = 0; l < n_node; l++)
      {
        // Note same shape functions used for lagrange multiplier field
        interpolated_lagrange += lagrange(l) * psif(l);
      }
 
      int local_eqn = 0, local_unknown = 0;
 
      // Loop over the shape functions to assemble contributions
      for (unsigned l = 0; l < n_node; l++)
      {
        // Loop over the directions
        for (unsigned i = 0; i < nodal_dimension; i++)
        {
          // Now using the same shape functions for the elastic equations,
          // so we can stay in the loop
          local_eqn = this->position_local_eqn(l, 0, i);
          if (local_eqn >= 0)
          {
            // Add in the Lagrange multiplier contribution
            residuals[local_eqn] -=
              interpolated_lagrange * interpolated_n[i] * psif(l) * J * W;
 
            // Do the Jacobian calculation
            if (flag)
            {
              // Loop over the nodes
              for (unsigned l2 = 0; l2 < n_node; l2++)
              {
                // Dependence on solid positions will be handled by FDs
                // That leaves the Lagrange multiplier contribution
                local_unknown = this->kinematic_local_eqn(l2);
                if (local_unknown >= 0)
                {
                  jacobian(local_eqn, local_unknown) -=
                    psif(l2) * interpolated_n[i] * psif(l) * J * W;
                }
              }
            } // End of Jacobian calculation
          }
        }
      } // End of loop over shape functions
    }

References i, J, oomph::ElasticUpdateFluidInterfaceElement< EQUATION_CLASS, DERIVATIVE_CLASS, ELEMENT >::kinematic_local_eqn(), oomph::ElasticUpdateFluidInterfaceElement< EQUATION_CLASS, DERIVATIVE_CLASS, ELEMENT >::lagrange(), s, and oomph::QuadTreeNames::W.

compute_surface_derivatives()

template<class EQUATION_CLASS , class DERIVATIVE_CLASS , class ELEMENT >

double oomph::ElasticUpdateFluidInterfaceElement< EQUATION_CLASS, DERIVATIVE_CLASS, ELEMENT >::compute_surface_derivatives ( const Shape &  psi, const DShape &  dpsids, const DenseMatrix< double > &  interpolated_t, const Vector< double > &  interpolated_x, DShape &  surface_gradient, DShape &  surface_divergence  )

inlineprotected

Fill in the specific surface derivative calculations by calling the appropriate function from the derivative class

    {
      return DERIVATIVE_CLASS::compute_surface_derivatives(psi,
                                                           dpsids,
                                                           interpolated_t,
                                                           interpolated_x,
                                                           surface_gradient,
                                                           surface_divergence);
    }

fill_in_contribution_to_jacobian()

template<class EQUATION_CLASS , class DERIVATIVE_CLASS , class ELEMENT >

void oomph::ElasticUpdateFluidInterfaceElement< EQUATION_CLASS, DERIVATIVE_CLASS, ELEMENT >::fill_in_contribution_to_jacobian ( Vector< double > &  residuals, DenseMatrix< double > &  jacobian  )

inline

Fill in contribution to residuals and Jacobian.

    {
      // Call the generic routine with the flag set to 1
      EQUATION_CLASS::fill_in_generic_residual_contribution_interface(
        residuals, jacobian, 1);
 
      // Call the generic finite difference routine for the solid variables
      this->fill_in_jacobian_from_solid_position_by_fd(jacobian);
    }

hijack_kinematic_conditions()

template<class EQUATION_CLASS , class DERIVATIVE_CLASS , class ELEMENT >

void oomph::ElasticUpdateFluidInterfaceElement< EQUATION_CLASS, DERIVATIVE_CLASS, ELEMENT >::hijack_kinematic_conditions ( const Vector< unsigned > &  bulk_node_number )

inlineprivate

Hijacking the kinematic condition corresponds to hijacking the variables associated with the Lagrange multipliers that are assigned on construction of this element.

    {
      // Loop over all the nodes that are passed in
      for (Vector<unsigned>::const_iterator it = bulk_node_number.begin();
           it != bulk_node_number.end();
           ++it)
      {
        // Hijack the appropriate value and delete the returned Node
        delete this->hijack_nodal_value(*it, this->lagrange_index(*it));
      }
    }

References oomph::Hijacked< FaceGeometry< ELEMENT > >::hijack_nodal_value(), and oomph::ElasticUpdateFluidInterfaceElement< EQUATION_CLASS, DERIVATIVE_CLASS, ELEMENT >::lagrange_index().

kinematic_local_eqn()

template<class EQUATION_CLASS , class DERIVATIVE_CLASS , class ELEMENT >

int oomph::ElasticUpdateFluidInterfaceElement< EQUATION_CLASS, DERIVATIVE_CLASS, ELEMENT >::kinematic_local_eqn ( const unsigned &  n )

inlineprivate

Equation number of the kinematic BC associated with node j. (This is the equation for the Lagrange multiplier)

    {
      // Get the index of the nodal value associated with Lagrange multiplier
      return this->nodal_local_eqn(n, this->lagrange_index(n));
    }

References oomph::ElasticUpdateFluidInterfaceElement< EQUATION_CLASS, DERIVATIVE_CLASS, ELEMENT >::lagrange_index(), and n.

Referenced by oomph::ElasticUpdateFluidInterfaceElement< EQUATION_CLASS, DERIVATIVE_CLASS, ELEMENT >::add_additional_residual_contributions_interface().

lagrange()

template<class EQUATION_CLASS , class DERIVATIVE_CLASS , class ELEMENT >

double& oomph::ElasticUpdateFluidInterfaceElement< EQUATION_CLASS, DERIVATIVE_CLASS, ELEMENT >::lagrange ( const unsigned &  n )

inline

Return the lagrange multiplier at local node n.

    {
      return *this->node_pt(n)->value_pt(this->lagrange_index(n));
    }

References oomph::ElasticUpdateFluidInterfaceElement< EQUATION_CLASS, DERIVATIVE_CLASS, ELEMENT >::lagrange_index(), and n.

Referenced by oomph::ElasticUpdateFluidInterfaceElement< EQUATION_CLASS, DERIVATIVE_CLASS, ELEMENT >::add_additional_residual_contributions_interface(), and RefineableRotatingCylinderProblem< ELEMENT >::solve().

lagrange_index()

template<class EQUATION_CLASS , class DERIVATIVE_CLASS , class ELEMENT >

unsigned oomph::ElasticUpdateFluidInterfaceElement< EQUATION_CLASS, DERIVATIVE_CLASS, ELEMENT >::lagrange_index ( const unsigned &  n )

inlineprivate

Return the index at which the lagrange multiplier is stored at the n-th node

    {
      return this->Lagrange_index[n];
    }

References n.

Referenced by oomph::ElasticUpdateFluidInterfaceElement< EQUATION_CLASS, DERIVATIVE_CLASS, ELEMENT >::hijack_kinematic_conditions(), oomph::ElasticUpdateFluidInterfaceElement< EQUATION_CLASS, DERIVATIVE_CLASS, ELEMENT >::kinematic_local_eqn(), and oomph::ElasticUpdateFluidInterfaceElement< EQUATION_CLASS, DERIVATIVE_CLASS, ELEMENT >::lagrange().

make_bounding_element()

template<class EQUATION_CLASS , class DERIVATIVE_CLASS , class ELEMENT >

virtual FluidInterfaceBoundingElement* oomph::ElasticUpdateFluidInterfaceElement< EQUATION_CLASS, DERIVATIVE_CLASS, ELEMENT >::make_bounding_element ( const int &  face_index )

inlinevirtual

Create an "bounding" element (here actually a 2D line element of type ElasticLineFluidInterfaceBoundingElement<ELEMENT> that allows the application of a contact angle boundary condition on the the specified face.

    {
      // Create a temporary pointer to the appropriate FaceElement
      BoundingElementType<ElasticUpdateFluidInterfaceElement<EQUATION_CLASS,
                                                             DERIVATIVE_CLASS,
                                                             ELEMENT>>*
        face_el_pt = new BoundingElementType<
          ElasticUpdateFluidInterfaceElement<EQUATION_CLASS,
                                             DERIVATIVE_CLASS,
                                             ELEMENT>>;
 
      // Attach the geometrical information to the new element
      this->build_face_element(face_index, face_el_pt);
 
      // Set the index at which the velocity nodes are stored
      face_el_pt->u_index_interface_boundary() = this->U_index_interface;
 
      // Set the value of the nbulk_value, the node is not resized
      // in this bounding element,
      // so it will just be the actual nvalue here
      // There is some ambiguity about what this means (however)
      const unsigned n_node_bounding = face_el_pt->nnode();
      // Storage for lagrange multiplier index at the face nodes
      Vector<unsigned> local_lagrange_index(n_node_bounding);
      for (unsigned n = 0; n < n_node_bounding; n++)
      {
        face_el_pt->nbulk_value(n) = face_el_pt->node_pt(n)->nvalue();
        // At the moment the assumption is that it is stored at all nodes, but
        // that is consistent with the assumption in this element
        local_lagrange_index[n] =
          this->Lagrange_index[face_el_pt->bulk_node_number(n)];
      }
 
      // Pass the ID and offset down
      face_el_pt->set_lagrange_index(local_lagrange_index);
 
      // Find the nodes
      std::set<SolidNode*> set_of_solid_nodes;
      const unsigned n_node = this->nnode();
      for (unsigned n = 0; n < n_node; n++)
      {
        set_of_solid_nodes.insert(static_cast<SolidNode*>(this->node_pt(n)));
      }
 
      // Delete the nodes from the face
      // n_node = face_el_pt->nnode();
      for (unsigned n = 0; n < n_node_bounding; n++)
      {
        // Set the value of the nbulk_value, from the present element
        face_el_pt->nbulk_value(n) =
          this->nbulk_value(face_el_pt->bulk_node_number(n));
 
        // Now delete the nodes from the set
        set_of_solid_nodes.erase(
          static_cast<SolidNode*>(face_el_pt->node_pt(n)));
      }
 
      // Now add these as external data
      for (std::set<SolidNode*>::iterator it = set_of_solid_nodes.begin();
           it != set_of_solid_nodes.end();
           ++it)
      {
        face_el_pt->add_external_data((*it)->variable_position_pt());
      }
 
 
      // Return the value of the pointer
      return face_el_pt;
    }

References n.

output() [1/4]

template<class EQUATION_CLASS , class DERIVATIVE_CLASS , class ELEMENT >

void oomph::ElasticUpdateFluidInterfaceElement< EQUATION_CLASS, DERIVATIVE_CLASS, ELEMENT >::output ( FILE *  file_pt )

inline

Overload the C-style output function.

    {
      EQUATION_CLASS::output(file_pt);
    }

References output().

output() [2/4]

template<class EQUATION_CLASS , class DERIVATIVE_CLASS , class ELEMENT >

void oomph::ElasticUpdateFluidInterfaceElement< EQUATION_CLASS, DERIVATIVE_CLASS, ELEMENT >::output ( FILE *  file_pt, const unsigned &  n_plot  )

inline

C-style Output function.

    {
      EQUATION_CLASS::output(file_pt, n_plot);
    }

References output().

output() [3/4]

template<class EQUATION_CLASS , class DERIVATIVE_CLASS , class ELEMENT >

void oomph::ElasticUpdateFluidInterfaceElement< EQUATION_CLASS, DERIVATIVE_CLASS, ELEMENT >::output ( std::ostream &  outfile )

inline

Overload the output function.

    {
      EQUATION_CLASS::output(outfile);
    }

References output().

output() [4/4]

template<class EQUATION_CLASS , class DERIVATIVE_CLASS , class ELEMENT >

void oomph::ElasticUpdateFluidInterfaceElement< EQUATION_CLASS, DERIVATIVE_CLASS, ELEMENT >::output ( std::ostream &  outfile, const unsigned &  n_plot  )

inline

Output the element.

    {
      EQUATION_CLASS::output(outfile, n_plot);
    }

References output().

zeta_nodal()

template<class EQUATION_CLASS , class DERIVATIVE_CLASS , class ELEMENT >

double oomph::ElasticUpdateFluidInterfaceElement< EQUATION_CLASS, DERIVATIVE_CLASS, ELEMENT >::zeta_nodal ( const unsigned &  n, const unsigned &  k, const unsigned &  i  ) const

inline

The "global" intrinsic coordinate of the element when viewed as part of a geometric object should be given by the FaceElement representation, by default

    {
      return FaceElement::zeta_nodal(n, k, i);
    }

References i, k, n, and oomph::FaceElement::zeta_nodal().

Member Data Documentation

Lagrange_index

template<class EQUATION_CLASS , class DERIVATIVE_CLASS , class ELEMENT >

Vector<unsigned> oomph::ElasticUpdateFluidInterfaceElement< EQUATION_CLASS, DERIVATIVE_CLASS, ELEMENT >::Lagrange_index

private

Storage for the location of the Lagrange multiplier (If other additional values have been added we need to add the Lagrange multiplier at the end)

Referenced by oomph::ElasticUpdateFluidInterfaceElement< EQUATION_CLASS, DERIVATIVE_CLASS, ELEMENT >::ElasticUpdateFluidInterfaceElement().

---

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

• specific_node_update_interface_elements.h