oomph::PseudoSolidNodeUpdateElement< BASIC, SOLID > Class Template Reference

#include <pseudosolid_node_update_elements.h>

Inheritance diagram for oomph::PseudoSolidNodeUpdateElement< BASIC, SOLID >:

Public Member Functions
	PseudoSolidNodeUpdateElement ()
void	describe_local_dofs (std::ostream &out, const std::string &current_string) const
void	compute_norm (double &el_norm)
unsigned	required_nvalue (const unsigned &n) const
	The required number of values is the sum of the two. More...
int	solid_p_nodal_index () const
void	fill_in_contribution_to_residuals (Vector< double > &residuals)
void	fill_in_contribution_to_jacobian (Vector< double > &residuals, DenseMatrix< double > &jacobian)
void	fill_in_contribution_to_jacobian_and_mass_matrix (Vector< double > &residuals, DenseMatrix< double > &jacobian, DenseMatrix< double > &mass_matrix)
void	evaluate_shape_derivs_by_direct_fd ()
	Evaluate shape derivatives by direct finite differencing. More...
void	evaluate_shape_derivs_by_chain_rule ()
	Evaluate shape derivatives by chain rule. More...
void	fill_in_shape_derivatives (DenseMatrix< double > &jacobian)
void	fill_in_shape_derivatives_by_fd (DenseMatrix< double > &jacobian)
void	identify_geometric_data (std::set< Data * > &geometric_data_pt)
void	output (std::ostream &outfile)
	Overload the output function: Call that of the basic element. More...
void	output (std::ostream &outfile, const unsigned &n_p)
void	output (FILE *file_pt)
	Overload the output function: Call that of the basic element. More...
void	output (FILE *file_pt, const unsigned &n_p)
	Output function is just the same as the basic equations. More...
unsigned	num_Z2_flux_terms ()
void	compute_exact_Z2_error (std::ostream &outfile, FiniteElement::SteadyExactSolutionFctPt exact_flux_pt, double &error, double &norm)
void	get_Z2_flux (const Vector< double > &s, Vector< double > &flux)
unsigned	nvertex_node () const
	Number of vertex nodes in the element. More...
Node *	vertex_node_pt (const unsigned &j) const
	Pointer to the j-th vertex node in the element. More...
unsigned	nrecovery_order ()
unsigned	ndof_types () const
unsigned	nbasic_dof_types () const
unsigned	nsolid_dof_types () const
void	get_dof_numbers_for_unknowns (std::list< std::pair< unsigned long, unsigned >> &dof_lookup_list) const

Private Attributes
bool	Shape_derivs_by_direct_fd
	Boolean flag to indicate shape derivative method. More...

Detailed Description

template<class BASIC, class SOLID>
class oomph::PseudoSolidNodeUpdateElement< BASIC, SOLID >

A templated class that permits combination two different element types, for the solution of problems in deforming domains. The first template paremter BASIC is the standard element and the second SOLID solves the equations that are used to control the mesh deformation.

Constructor & Destructor Documentation

PseudoSolidNodeUpdateElement()

template<class BASIC , class SOLID >

oomph::PseudoSolidNodeUpdateElement< BASIC, SOLID >::PseudoSolidNodeUpdateElement ( )

inline

Constructor, call the BASIC and SOLID elements' constructors and set the "density" parameter for solid element to zero

      : BASIC(), SOLID(), Shape_derivs_by_direct_fd(true)
    {
      SOLID::lambda_sq_pt() = &PseudoSolidHelper::Zero;
    }

References oomph::PseudoSolidHelper::Zero.

Member Function Documentation

compute_exact_Z2_error()

template<class BASIC , class SOLID >

void oomph::PseudoSolidNodeUpdateElement< BASIC, SOLID >::compute_exact_Z2_error ( std::ostream &  outfile, FiniteElement::SteadyExactSolutionFctPt  exact_flux_pt, double &  error, double &  norm  )

inline

Plot the error when compared against a given exact flux. Also calculates the norm of the error and that of the exact flux. Use version in BASIC element

    {
      BASIC::compute_exact_Z2_error(outfile, exact_flux_pt, error, norm);
    }

References calibrate::error.

compute_norm()

template<class BASIC , class SOLID >

void oomph::PseudoSolidNodeUpdateElement< BASIC, SOLID >::compute_norm ( double &  el_norm )

inline

Compute norm of solution: use the version in the BASIC class if there's any ambiguity

    {
      BASIC::compute_norm(el_norm);
    }

describe_local_dofs()

template<class BASIC , class SOLID >

void oomph::PseudoSolidNodeUpdateElement< BASIC, SOLID >::describe_local_dofs ( std::ostream &  out, const std::string &  current_string  ) const

inline

Function to describe the local dofs of the element. The ostream specifies the output stream to which the description is written; the string stores the currently assembled output that is ultimately written to the output stream by Data::describe_dofs(...); it is typically built up incrementally as we descend through the call hierarchy of this function when called from Problem::describe_dofs(...)

    {
      BASIC::describe_local_dofs(out, current_string);
      SOLID::describe_local_dofs(out, current_string);
    }

References out().

evaluate_shape_derivs_by_chain_rule()

template<class BASIC , class SOLID >

void oomph::PseudoSolidNodeUpdateElement< BASIC, SOLID >::evaluate_shape_derivs_by_chain_rule ( )

inline

Evaluate shape derivatives by chain rule.

    {
      Shape_derivs_by_direct_fd = false;
    }

References oomph::PseudoSolidNodeUpdateElement< BASIC, SOLID >::Shape_derivs_by_direct_fd.

evaluate_shape_derivs_by_direct_fd()

template<class BASIC , class SOLID >

void oomph::PseudoSolidNodeUpdateElement< BASIC, SOLID >::evaluate_shape_derivs_by_direct_fd ( )

inline

Evaluate shape derivatives by direct finite differencing.

    {
      Shape_derivs_by_direct_fd = true;
    }

References oomph::PseudoSolidNodeUpdateElement< BASIC, SOLID >::Shape_derivs_by_direct_fd.

fill_in_contribution_to_jacobian()

template<class BASIC , class SOLID >

void oomph::PseudoSolidNodeUpdateElement< BASIC, SOLID >::fill_in_contribution_to_jacobian ( Vector< double > &  residuals, DenseMatrix< double > &  jacobian  )

inline

Final override for jacobian function: Contributions are included from both the underlying element types

    {
      // Call the basic equations first
      BASIC::fill_in_contribution_to_jacobian(residuals, jacobian);
      // Call the solid equations
      SOLID::fill_in_contribution_to_jacobian(residuals, jacobian);
 
      // Now fill in the off-diagonal entries (the shape derivatives),
      fill_in_shape_derivatives(jacobian);
    }

References oomph::fill_in_contribution_to_jacobian(), and oomph::PseudoSolidNodeUpdateElement< BASIC, SOLID >::fill_in_shape_derivatives().

fill_in_contribution_to_jacobian_and_mass_matrix()

template<class BASIC , class SOLID >

void oomph::PseudoSolidNodeUpdateElement< BASIC, SOLID >::fill_in_contribution_to_jacobian_and_mass_matrix ( Vector< double > &  residuals, DenseMatrix< double > &  jacobian, DenseMatrix< double > &  mass_matrix  )

inline

Final override for mass matrix function: contributions are included from both the underlying element types

    {
      // Call the basic equations first
      BASIC::fill_in_contribution_to_jacobian_and_mass_matrix(
        residuals, jacobian, mass_matrix);
      // Call the solid equations
      SOLID::fill_in_contribution_to_jacobian_and_mass_matrix(
        residuals, jacobian, mass_matrix);
 
      // Now fill in the off-diagonal entries (the shape derivatives),
      fill_in_shape_derivatives(jacobian);
    }

References oomph::fill_in_contribution_to_jacobian_and_mass_matrix(), and oomph::PseudoSolidNodeUpdateElement< BASIC, SOLID >::fill_in_shape_derivatives().

fill_in_contribution_to_residuals()

template<class BASIC , class SOLID >

void oomph::PseudoSolidNodeUpdateElement< BASIC, SOLID >::fill_in_contribution_to_residuals ( Vector< double > &  residuals )

inline

Final override for the residuals function. Contributions are added from both underlying element types

    {
      // Call the basic equations first
      BASIC::fill_in_contribution_to_residuals(residuals);
      // Add the solid equations contribution
      SOLID::fill_in_contribution_to_residuals(residuals);
    }

References oomph::fill_in_contribution_to_residuals().

fill_in_shape_derivatives()

template<class BASIC , class SOLID >

void oomph::PseudoSolidNodeUpdateElement< BASIC, SOLID >::fill_in_shape_derivatives ( DenseMatrix< double > &  jacobian )

inline

Fill in the shape derivatives of the BASIC equations w.r.t. the solid position dofs

    {
      // Default is to use finite differences
      if (Shape_derivs_by_direct_fd)
      {
        this->fill_in_shape_derivatives_by_fd(jacobian);
      }
      // Otherwise need to do a bit more work
      else
      {
        // Calculate storage requirements
        const unsigned n_dof = this->ndof();
        const unsigned n_node = this->nnode();
        const unsigned nodal_dim = this->nodal_dimension();
 
        // If there are no nodes or dofs return
        if ((n_dof == 0) || (n_node == 0))
        {
          return;
        }
 
        // Generalised dofs have NOT been considered, shout
        if (this->nnodal_position_type() != 1)
        {
          throw OomphLibError("Shape derivatives do not (yet) allow for "
                              "generalised position dofs\n",
                              OOMPH_CURRENT_FUNCTION,
                              OOMPH_EXCEPTION_LOCATION);
        }
 
        // Storage for derivatives of residuals w.r.t. nodal coordinates
        RankThreeTensor<double> dresidual_dnodal_coordinates(
          n_dof, nodal_dim, n_node, 0.0);
 
        // Get the analytic derivatives for the BASIC equations
        BASIC::get_dresidual_dnodal_coordinates(dresidual_dnodal_coordinates);
 
        // Now add the appropriate contributions to the Jacobian
        int local_unknown = 0;
 
        // Loop over dofs
        //(this will include the solid dofs,
        // but all those contributions should be zero)
        for (unsigned l = 0; l < n_dof; l++)
        {
          // Loop over the nodes
          for (unsigned n = 0; n < n_node; n++)
          {
            // Loop over the position_types (only one)
            unsigned k = 0;
            // Loop over the coordinates
            for (unsigned i = 0; i < nodal_dim; i++)
            {
              // Get the equation of the local unknown
              local_unknown = this->position_local_eqn(n, k, i);
 
              // If not pinned, add the contribution to the Jacobian
              if (local_unknown >= 0)
              {
                jacobian(l, local_unknown) +=
                  dresidual_dnodal_coordinates(l, i, n);
              }
            }
          }
        }
      }
    }

References oomph::PseudoSolidNodeUpdateElement< BASIC, SOLID >::fill_in_shape_derivatives_by_fd(), i, k, n, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, and oomph::PseudoSolidNodeUpdateElement< BASIC, SOLID >::Shape_derivs_by_direct_fd.

Referenced by oomph::PseudoSolidNodeUpdateElement< BASIC, SOLID >::fill_in_contribution_to_jacobian(), and oomph::PseudoSolidNodeUpdateElement< BASIC, SOLID >::fill_in_contribution_to_jacobian_and_mass_matrix().

fill_in_shape_derivatives_by_fd()

template<class BASIC , class SOLID >

void oomph::PseudoSolidNodeUpdateElement< BASIC, SOLID >::fill_in_shape_derivatives_by_fd ( DenseMatrix< double > &  jacobian )

inline

Fill in the derivatives of the BASIC equations w.r.t. the solid position dofs

    {
      // Flag to indicate if we use first or second order FD
      // bool use_first_order_fd=false;
 
      // Find the number of nodes
      const unsigned n_node = this->nnode();
 
      // If there aren't any nodes, then return straight away
      if (n_node == 0)
      {
        return;
      }
 
      // Call the update function to ensure that the element is in
      // a consistent state before finite differencing starts
      this->update_before_solid_position_fd();
 
      // Get the number of position dofs and dimensions at the node
      const unsigned n_position_type = this->nnodal_position_type();
      const unsigned nodal_dim = this->nodal_dimension();
 
      // Find the number of dofs in the element
      const unsigned n_dof = this->ndof();
 
      // Create residual newres vectors
      Vector<double> residuals(n_dof);
      Vector<double> newres(n_dof);
      // Vector<double> newres_minus(n_dof);
 
      // Calculate the residuals (for the BASIC) equations
      // Need to do this using fill_in because get_residuals will
      // compute all residuals for the problem, which is
      // a little ineffecient
      for (unsigned m = 0; m < n_dof; m++)
      {
        residuals[m] = 0.0;
      }
      BASIC::fill_in_contribution_to_residuals(residuals);
 
      // Need to determine which degrees of freedom are solid degrees of
      // freedom
      // A vector of booleans that will be true if the dof is associated
      // with the solid equations
      std::vector<bool> dof_is_solid(n_dof, false);
 
      // Now set all solid positional dofs in the vector
      for (unsigned n = 0; n < n_node; n++)
      {
        for (unsigned k = 0; k < n_position_type; k++)
        {
          for (unsigned i = 0; i < nodal_dim; i++)
          {
            int local_dof = this->position_local_eqn(n, k, i);
            if (local_dof >= 0)
            {
              dof_is_solid[local_dof] = true;
            }
          }
        }
      }
 
      // Add the solid pressures (in solid elements without
      // solid pressure the number will be zero).
      unsigned n_solid_pres = this->npres_solid();
      for (unsigned l = 0; l < n_solid_pres; l++)
      {
        int local_dof = this->solid_p_local_eqn(l);
        if (local_dof >= 0)
        {
          dof_is_solid[local_dof] = true;
        }
      }
 
 
      // Integer storage for local unknown
      int local_unknown = 0;
 
      // Use default value defined in GeneralisedElement
      const double fd_step = this->Default_fd_jacobian_step;
 
      // Loop over the nodes
      for (unsigned n = 0; n < n_node; n++)
      {
        // Loop over position dofs
        for (unsigned k = 0; k < n_position_type; k++)
        {
          // Loop over dimension
          for (unsigned i = 0; i < nodal_dim; i++)
          {
            // If the variable is free
            local_unknown = this->position_local_eqn(n, k, i);
            if (local_unknown >= 0)
            {
              // Store a pointer to the (generalised) Eulerian nodal position
              double* const value_pt = &(this->node_pt(n)->x_gen(k, i));
 
              // Save the old value of the (generalised) Eulerian nodal position
              const double old_var = *value_pt;
 
              // Increment the (generalised) Eulerian nodal position
              *value_pt += fd_step;
 
              // Perform any auxialiary node updates
              this->node_pt(n)->perform_auxiliary_node_update_fct();
 
              // Calculate the new residuals
              // Need to do this using fill_in because get_residuals will
              // compute all residuals for the problem, which is
              // a little ineffecient
              for (unsigned m = 0; m < n_dof; m++)
              {
                newres[m] = 0.0;
              }
              BASIC::fill_in_contribution_to_residuals(newres);
 
              //          if (use_first_order_fd)
              {
                // Do forward finite differences
                for (unsigned m = 0; m < n_dof; m++)
                {
                  // Stick the entry into the Jacobian matrix
                  // but only if it's not a solid dof
                  if (dof_is_solid[m] == false)
                  {
                    jacobian(m, local_unknown) =
                      (newres[m] - residuals[m]) / fd_step;
                  }
                }
              }
              //           else
              //            {
              //             //Take backwards step for the  (generalised)
              //             Eulerian nodal
              //             // position
              //             node_pt(n)->x_gen(k,i) = old_var-fd_step;
 
              //             //Calculate the new residuals at backward position
              //             //BASIC::get_residuals(newres_minus);
 
              //             //Do central finite differences
              //             for(unsigned m=0;m<n_dof;m++)
              //              {
              //               //Stick the entry into the Jacobian matrix
              //               jacobian(m,local_unknown) =
              //                (newres[m] - newres_minus[m])/(2.0*fd_step);
              //              }
              //            }
 
              // Reset the (generalised) Eulerian nodal position
              *value_pt = old_var;
 
              // Perform any auxialiary node updates
              this->node_pt(n)->perform_auxiliary_node_update_fct();
            }
          }
        }
      }
 
      // End of finite difference loop
      // Final reset of any dependent data
      this->reset_after_solid_position_fd();
    }

References oomph::fill_in_contribution_to_residuals(), i, k, m, and n.

Referenced by oomph::PseudoSolidNodeUpdateElement< BASIC, SOLID >::fill_in_shape_derivatives().

get_dof_numbers_for_unknowns()

template<class BASIC , class SOLID >

void oomph::PseudoSolidNodeUpdateElement< BASIC, SOLID >::get_dof_numbers_for_unknowns ( std::list< std::pair< unsigned long, unsigned >> &  dof_lookup_list ) const

inline

Create a list of pairs for all unknowns in this element, so that the first entry in each pair contains the global equation number of the unknown, while the second one contains the number of the "DOF type" that this unknown is associated with. This method combines the get_dof_numbers_for_unknowns(...) method for the BASIC and SOLID elements. The basic elements retain their DOF type numbering and the SOLID elements DOF type numbers are incremented by nbasic_dof_types().

    {
      // get the solid list
      std::list<std::pair<unsigned long, unsigned>> solid_list;
      SOLID::get_dof_numbers_for_unknowns(solid_list);
 
      // get the basic list
      BASIC::get_dof_numbers_for_unknowns(dof_lookup_list);
 
      // get the number of basic dof types
      unsigned nbasic_dof_types = BASIC::ndof_types();
 
      // add the solid lookup list to the basic lookup list
      // incrementing the solid dof numbers by nbasic_dof_types
      typedef std::list<std::pair<unsigned long, unsigned>>::iterator IT;
      for (IT it = solid_list.begin(); it != solid_list.end(); it++)
      {
        std::pair<unsigned long, unsigned> new_pair;
        new_pair.first = it->first;
        new_pair.second = it->second + nbasic_dof_types;
        dof_lookup_list.push_front(new_pair);
      }
    }

References oomph::PseudoSolidNodeUpdateElement< BASIC, SOLID >::nbasic_dof_types().

get_Z2_flux()

template<class BASIC , class SOLID >

void oomph::PseudoSolidNodeUpdateElement< BASIC, SOLID >::get_Z2_flux ( const Vector< double > &  s, Vector< double > &  flux  )

inline

'Flux' vector for Z2 error estimation: Error estimation is based on error in BASIC element

    {
      BASIC::get_Z2_flux(s, flux);
    }

References ProblemParameters::flux(), get_Z2_flux(), and s.

identify_geometric_data()

template<class BASIC , class SOLID >

void oomph::PseudoSolidNodeUpdateElement< BASIC, SOLID >::identify_geometric_data ( std::set< Data * > &  geometric_data_pt )

inline

Specify Data that affects the geometry of the element by adding the position Data to the set that's passed in. (This functionality is required in FSI problems; set is used to avoid double counting).

    {
      // Loop over the node update data and add to the set
      const unsigned n_node = this->nnode();
      for (unsigned j = 0; j < n_node; j++)
      {
        geometric_data_pt.insert(
          dynamic_cast<SolidNode*>(this->node_pt(j))->variable_position_pt());
      }
    }

References j.

nbasic_dof_types()

template<class BASIC , class SOLID >

unsigned oomph::PseudoSolidNodeUpdateElement< BASIC, SOLID >::nbasic_dof_types ( ) const

inline

return the number of DOF types associated with the BASIC elements in this combined element

    {
      return BASIC::ndof_types();
    }

Referenced by oomph::PseudoSolidNodeUpdateElement< BASIC, SOLID >::get_dof_numbers_for_unknowns().

ndof_types()

template<class BASIC , class SOLID >

unsigned oomph::PseudoSolidNodeUpdateElement< BASIC, SOLID >::ndof_types ( ) const

inline

The number of "DOF types" that degrees of freedom in this element are sub-divided into.

    {
      return BASIC::ndof_types() + SOLID::ndof_types();
    }

nrecovery_order()

template<class BASIC , class SOLID >

unsigned oomph::PseudoSolidNodeUpdateElement< BASIC, SOLID >::nrecovery_order ( )

inline

Order of recovery shape functions for Z2 error estimation: Done for BASIC element since it determines the refinement

    {
      return BASIC::nrecovery_order();
    }

nsolid_dof_types()

template<class BASIC , class SOLID >

unsigned oomph::PseudoSolidNodeUpdateElement< BASIC, SOLID >::nsolid_dof_types ( ) const

inline

return the number of DOF types associated with the SOLID elements in this combined element

    {
      return SOLID::ndof_types();
    }

num_Z2_flux_terms()

template<class BASIC , class SOLID >

unsigned oomph::PseudoSolidNodeUpdateElement< BASIC, SOLID >::num_Z2_flux_terms ( )

inline

Number of 'flux' terms for Z2 error estimation: Error estimation is based on error in BASIC element

    {
      return BASIC::num_Z2_flux_terms();
    }

nvertex_node()

template<class BASIC , class SOLID >

unsigned oomph::PseudoSolidNodeUpdateElement< BASIC, SOLID >::nvertex_node ( ) const

inline

Number of vertex nodes in the element.

    {
      return BASIC::nvertex_node();
    }

output() [1/4]

template<class BASIC , class SOLID >

void oomph::PseudoSolidNodeUpdateElement< BASIC, SOLID >::output ( FILE *  file_pt )

inline

Overload the output function: Call that of the basic element.

    {
      BASIC::output(file_pt);
    }

References output().

output() [2/4]

template<class BASIC , class SOLID >

void oomph::PseudoSolidNodeUpdateElement< BASIC, SOLID >::output ( FILE *  file_pt, const unsigned &  n_p  )

inline

Output function is just the same as the basic equations.

    {
      BASIC::output(file_pt, n_p);
    }

References output().

output() [3/4]

template<class BASIC , class SOLID >

void oomph::PseudoSolidNodeUpdateElement< BASIC, SOLID >::output ( std::ostream &  outfile )

inline

Overload the output function: Call that of the basic element.

    {
      BASIC::output(outfile);
    }

References output().

output() [4/4]

template<class BASIC , class SOLID >

void oomph::PseudoSolidNodeUpdateElement< BASIC, SOLID >::output ( std::ostream &  outfile, const unsigned &  n_p  )

inline

Output function: Plot at n_p plot points using the basic element's output function

    {
      BASIC::output(outfile, n_p);
    }

References output().

required_nvalue()

template<class BASIC , class SOLID >

unsigned oomph::PseudoSolidNodeUpdateElement< BASIC, SOLID >::required_nvalue ( const unsigned &  n ) const

inline

The required number of values is the sum of the two.

    {
      return BASIC::required_nvalue(n) + SOLID::required_nvalue(n);
    }

References n.

solid_p_nodal_index()

template<class BASIC , class SOLID >

int oomph::PseudoSolidNodeUpdateElement< BASIC, SOLID >::solid_p_nodal_index ( ) const

inline

We assume that the solid stuff is stored at the end of the nodes, i.e. its index is the number of continuously interplated values in the BASIC equations.

    {
      // At the moment, we can't handle this case in generality so throw an
      // error if the solid pressure is stored at the nodes
      if (SOLID::solid_p_nodal_index() >= 0)
      {
        throw OomphLibError("Cannot handle (non-refineable) continuous solid "
                            "pressure interpolation",
                            OOMPH_CURRENT_FUNCTION,
                            OOMPH_EXCEPTION_LOCATION);
      }
 
      return SOLID::solid_p_nodal_index();
    }

References OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

vertex_node_pt()

template<class BASIC , class SOLID >

Node* oomph::PseudoSolidNodeUpdateElement< BASIC, SOLID >::vertex_node_pt ( const unsigned &  j ) const

inline

Pointer to the j-th vertex node in the element.

    {
      return BASIC::vertex_node_pt(j);
    }

References j.

Member Data Documentation

Shape_derivs_by_direct_fd

template<class BASIC , class SOLID >

bool oomph::PseudoSolidNodeUpdateElement< BASIC, SOLID >::Shape_derivs_by_direct_fd

private

Boolean flag to indicate shape derivative method.

Referenced by oomph::PseudoSolidNodeUpdateElement< BASIC, SOLID >::evaluate_shape_derivs_by_chain_rule(), oomph::PseudoSolidNodeUpdateElement< BASIC, SOLID >::evaluate_shape_derivs_by_direct_fd(), and oomph::PseudoSolidNodeUpdateElement< BASIC, SOLID >::fill_in_shape_derivatives().

---

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

• pseudosolid_node_update_elements.h