Refineable version of the PseudoSolidNodeUpdateELement. More...

#include <pseudosolid_node_update_elements.h>

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

Public Member Functions
	RefineablePseudoSolidNodeUpdateElement ()

void	describe_local_dofs (std::ostream &out, const std::string &current_string) const

unsigned	required_nvalue (const unsigned &n) const
	The required number of values is the sum of the two. More...

unsigned	ncont_interpolated_values () const

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	fill_in_shape_derivatives_by_fd (DenseMatrix< double > &jacobian)

void	identify_geometric_data (std::set< Data * > &geometric_data_pt)

void	assign_additional_local_eqn_numbers ()

void	rebuild_from_sons (Mesh *&mesh_pt)
	Call rebuild_from_sons() for both of the underlying element types. More...

void	get_interpolated_values (const unsigned &t, const Vector< double > &s, Vector< double > &values)

void	get_interpolated_values (const Vector< double > &s, Vector< double > &values)

Node *	interpolating_node_pt (const unsigned &n, const int &value_id)

double	local_one_d_fraction_of_interpolating_node (const unsigned &n1d, const unsigned &i, const int &value_id)

Node *	get_interpolating_node_at_local_coordinate (const Vector< double > &s, const int &value_id)

unsigned	ninterpolating_node_1d (const int &value_id)

unsigned	ninterpolating_node (const int &value_id)

void	interpolating_basis (const Vector< double > &s, Shape &psi, const int &value_id) const

unsigned	num_Z2_flux_terms ()

void	get_Z2_flux (const Vector< double > &s, Vector< double > &flux)

void	further_setup_hanging_nodes ()

void	build (Mesh &mesh_pt, Vector< Node > &new_node_pt, bool &was_already_built, std::ofstream &new_nodes_file)

void	build (Mesh &mesh_pt, Vector< Node > &new_node_pt, bool &was_already_built)

void	further_build ()

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...

void	compute_norm (double &norm)
	Compute norm of solution. Use version in BASIC element. More...

void	compute_exact_Z2_error (std::ostream &outfile, FiniteElement::SteadyExactSolutionFctPt exact_flux_pt, double &error, double &norm)

unsigned	nrecovery_order ()

void	output (std::ostream &outfile)
	Overload the output function: Use that of the BASIC element. More...

void	output (std::ostream &outfile, const unsigned &n_p)
	Output function, plotting at n_p points: Use that of the BASIC element. More...

void	output (FILE *file_pt)
	Overload the output function: Use that of the BASIC element. More...

void	output (FILE *file_pt, const unsigned &n_p)
	Output function: Use that of the BASIC element. More...

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

Detailed Description

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

Refineable version of the PseudoSolidNodeUpdateELement.

Constructor & Destructor Documentation

◆ RefineablePseudoSolidNodeUpdateElement()

template<class BASIC , class SOLID >

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

inline

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

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

References oomph::PseudoSolidHelper::Zero.

Member Function Documentation

◆ assign_additional_local_eqn_numbers()

template<class BASIC , class SOLID >

void oomph::RefineablePseudoSolidNodeUpdateElement< BASIC, SOLID >::assign_additional_local_eqn_numbers ( )

inline

Final override for the assign__additional_local_eqn_numbers(): Call the version for the BASIC element

     {
       BASIC::assign_additional_local_eqn_numbers();
       SOLID::assign_additional_local_eqn_numbers();
     }

◆ build() [1/2]

template<class BASIC , class SOLID >

void oomph::RefineablePseudoSolidNodeUpdateElement< BASIC, SOLID >::build	(	Mesh *&	mesh_pt,
		Vector< Node * > &	new_node_pt,
		bool &	was_already_built
	)

inline

Build function: Call the one for the SOLID element since it calls the one basic build function automatically.

     {
       SOLID::build(mesh_pt, new_node_pt, was_already_built);
     }

◆ build() [2/2]

template<class BASIC , class SOLID >

void oomph::RefineablePseudoSolidNodeUpdateElement< BASIC, SOLID >::build	(	Mesh *&	mesh_pt,
		Vector< Node * > &	new_node_pt,
		bool &	was_already_built,
		std::ofstream &	new_nodes_file
	)

inline

Build function: Call the one for the SOLID element since it calls the one basic build function automatically.

     {
       SOLID::build(mesh_pt, new_node_pt, was_already_built, new_nodes_file);
     }

◆ compute_exact_Z2_error()

template<class BASIC , class SOLID >

void oomph::RefineablePseudoSolidNodeUpdateElement< 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::RefineablePseudoSolidNodeUpdateElement< BASIC, SOLID >::compute_norm ( double & norm )

inline

Compute norm of solution. Use version in BASIC element.

     {
       BASIC::compute_norm(norm);
     }

◆ describe_local_dofs()

template<class BASIC , class SOLID >

void oomph::RefineablePseudoSolidNodeUpdateElement< 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().

◆ fill_in_contribution_to_jacobian()

template<class BASIC , class SOLID >

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

inline

Final override for jacobian function: Calls get_jacobian() for both of 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_by_fd(jacobian);
     }

References oomph::fill_in_contribution_to_jacobian(), and oomph::RefineablePseudoSolidNodeUpdateElement< BASIC, SOLID >::fill_in_shape_derivatives_by_fd().

◆ fill_in_contribution_to_jacobian_and_mass_matrix()

template<class BASIC , class SOLID >

void oomph::RefineablePseudoSolidNodeUpdateElement< 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_by_fd(jacobian);
     }

References oomph::fill_in_contribution_to_jacobian_and_mass_matrix(), and oomph::RefineablePseudoSolidNodeUpdateElement< BASIC, SOLID >::fill_in_shape_derivatives_by_fd().

◆ fill_in_contribution_to_residuals()

template<class BASIC , class SOLID >

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

inline

Final override for residuals function: adds contributions from both underlying element types

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

References oomph::fill_in_contribution_to_residuals().

◆ fill_in_shape_derivatives_by_fd()

template<class BASIC , class SOLID >

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

inline

Fill in the derivatives of the BASIC equations w.r.t. to the solid position dofs, taking hanging nodes into account

     {
       // Find the number of nodes
       const unsigned n_node = this->nnode();
  
       // If there are no nodes, 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();
  
       //  bool use_first_order_fd=false;
  
       // Find the number of positional dofs and nodal dimension
       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
       // This is a bit more involved because we need to take account of
       // any hanging nodes
       for (unsigned n = 0; n < n_node; n++)
       {
         // Get pointer to the local node
         Node* const local_node_pt = this->node_pt(n);
  
         // If the node is not a hanging node
         if (local_node_pt->is_hanging() == false)
         {
           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;
               }
             }
           }
         }
         // Otherwise the node is hanging
         else
         {
           // Find the local hanging object
           HangInfo* hang_info_pt = local_node_pt->hanging_pt();
           // Loop over the master nodes
           const unsigned n_master = hang_info_pt->nmaster();
           for (unsigned m = 0; m < n_master; m++)
           {
             // Get the local equation numbers for the master node
             DenseMatrix<int> Position_local_eqn_at_node =
               this->local_position_hang_eqn(hang_info_pt->master_node_pt(m));
  
             // Loop over position dofs
             for (unsigned k = 0; k < n_position_type; k++)
             {
               // Loop over dimension
               for (unsigned i = 0; i < nodal_dim; i++)
               {
                 int local_dof = Position_local_eqn_at_node(k, i);
                 if (local_dof >= 0)
                 {
                   dof_is_solid[local_dof] = true;
                 }
               }
             }
           }
         }
       } // End of loop over nodes
  
       // Add the solid pressures (in solid elements without
       // solid pressure the number will be zero).
       unsigned n_solid_pres = this->npres_solid();
       // Now is the solid pressure hanging
       const int solid_p_index = this->solid_p_nodal_index();
       // Find out whether the solid node is hanging
       std::vector<bool> solid_p_is_hanging(n_solid_pres);
       // If we have nodal solid pressures then read out the hanging status
       if (solid_p_index >= 0)
       {
         // Loop over the solid dofs
         for (unsigned l = 0; l < n_solid_pres; l++)
         {
           solid_p_is_hanging[l] =
             this->solid_pressure_node_pt(l)->is_hanging(solid_p_index);
         }
       }
       // Otherwise the pressure is not nodal, so cannot hang
       else
       {
         for (unsigned l = 0; l < n_solid_pres; l++)
         {
           solid_p_is_hanging[l] = false;
         }
       }
  
       // Now we can loop of the dofs again to actually set that the appropriate
       // dofs are solid
       for (unsigned l = 0; l < n_solid_pres; l++)
       {
         // If the solid pressure is not hanging
         // we just read out the local equation numbers directly
         if (solid_p_is_hanging[l] == false)
         {
           int local_dof = this->solid_p_local_eqn(l);
           if (local_dof >= 0)
           {
             dof_is_solid[local_dof] = true;
           }
         }
         // Otherwise solid pressure is hanging and we need to take
         // care of the master nodes
         else
         {
           // Find the local hanging object
           HangInfo* hang_info_pt =
             this->solid_pressure_node_pt(l)->hanging_pt(solid_p_index);
           // Loop over the master nodes
           const unsigned n_master = hang_info_pt->nmaster();
           for (unsigned m = 0; m < n_master; m++)
           {
             // Get the local dof
             int local_dof = this->local_hang_eqn(
               hang_info_pt->master_node_pt(m), solid_p_index);
  
             if (local_dof >= 0)
             {
               dof_is_solid[local_dof] = true;
             }
           }
         }
       } // end of loop over solid pressure dofs
  
  
       // Used default value defined in GeneralisedElement
       const double fd_step = this->Default_fd_jacobian_step;
  
       // Integer storage for local unknowns
       int local_unknown = 0;
  
       // Loop over the nodes
       for (unsigned l = 0; l < n_node; l++)
       {
         // Get the pointer to the node
         Node* const local_node_pt = this->node_pt(l);
  
         // If the node is not a hanging node
         if (local_node_pt->is_hanging() == false)
         {
           // Loop over position dofs
           for (unsigned k = 0; k < n_position_type; k++)
           {
             // Loop over dimension
             for (unsigned i = 0; i < nodal_dim; i++)
             {
               local_unknown = this->position_local_eqn(l, k, i);
               // If the variable is free
               if (local_unknown >= 0)
               {
                 // Store a pointer to the (generalised) Eulerian nodal position
                 double* const value_pt = &(local_node_pt->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
                 local_node_pt->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(l)->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
                 local_node_pt->perform_auxiliary_node_update_fct();
               }
             }
           }
         }
         // Otherwise it's a hanging node
         else
         {
           // Find the local hanging object
           HangInfo* hang_info_pt = local_node_pt->hanging_pt();
           // Loop over the master nodes
           const unsigned n_master = hang_info_pt->nmaster();
           for (unsigned m = 0; m < n_master; m++)
           {
             // Get the pointer to the master node
             Node* const master_node_pt = hang_info_pt->master_node_pt(m);
  
             // Get the local equation numbers for the master node
             DenseMatrix<int> Position_local_eqn_at_node =
               this->local_position_hang_eqn(master_node_pt);
  
             // Loop over position dofs
             for (unsigned k = 0; k < n_position_type; k++)
             {
               // Loop over dimension
               for (unsigned i = 0; i < nodal_dim; i++)
               {
                 local_unknown = Position_local_eqn_at_node(k, i);
                 // If the variable is free
                 if (local_unknown >= 0)
                 {
                   // Store a pointer to the (generalised) Eulerian nodal
                   // position
                   double* const value_pt = &(master_node_pt->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
                   master_node_pt->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
                   //                 master_node_pt->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
                   master_node_pt->perform_auxiliary_node_update_fct();
                 }
               }
             }
           }
         } // End of hanging node case
  
       } // End of loop over nodes
  
       // End of finite difference loop
  
       // Final reset of any dependent data
       this->reset_after_solid_position_fd();
     }

References oomph::fill_in_contribution_to_residuals(), oomph::Node::hanging_pt(), i, oomph::Node::is_hanging(), k, m, oomph::HangInfo::master_node_pt(), n, oomph::HangInfo::nmaster(), oomph::Node::perform_auxiliary_node_update_fct(), oomph::RefineablePseudoSolidNodeUpdateElement< BASIC, SOLID >::solid_p_nodal_index(), and oomph::Node::x_gen().

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

◆ further_build()

template<class BASIC , class SOLID >

void oomph::RefineablePseudoSolidNodeUpdateElement< BASIC, SOLID >::further_build ( )

inline

Further build: Done for both of the underlying element types.

     {
       BASIC::further_build();
       SOLID::further_build();
     }

◆ further_setup_hanging_nodes()

template<class BASIC , class SOLID >

void oomph::RefineablePseudoSolidNodeUpdateElement< BASIC, SOLID >::further_setup_hanging_nodes ( )

inline

Perform additional hanging node procedures for variables that are not interpolated by all nodes. Done for both of the underlying element types.

     {
       BASIC::further_setup_hanging_nodes();
       SOLID::further_setup_hanging_nodes();
     }

◆ get_dof_numbers_for_unknowns()

template<class BASIC , class SOLID >

void oomph::RefineablePseudoSolidNodeUpdateElement< 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::RefineablePseudoSolidNodeUpdateElement< BASIC, SOLID >::nbasic_dof_types().

◆ get_interpolated_values() [1/2]

template<class BASIC , class SOLID >

void oomph::RefineablePseudoSolidNodeUpdateElement< BASIC, SOLID >::get_interpolated_values	(	const unsigned &	t,
		const Vector< double > &	s,
		Vector< double > &	values
	)

inline

Call get_interpolated_values(...) for both of the underlying element types

     {
       Vector<double> basic_values;
       BASIC::get_interpolated_values(t, s, basic_values);
       Vector<double> solid_values;
       SOLID::get_interpolated_values(t, s, solid_values);
  
       // Now add the basic value first
       for (Vector<double>::iterator it = basic_values.begin();
            it != basic_values.end();
            ++it)
       {
         values.push_back(*it);
       }
       // Then the solid
       for (Vector<double>::iterator it = solid_values.begin();
            it != solid_values.end();
            ++it)
       {
         values.push_back(*it);
       }
     }

References s, and plotPSD::t.

◆ get_interpolated_values() [2/2]

template<class BASIC , class SOLID >

void oomph::RefineablePseudoSolidNodeUpdateElement< BASIC, SOLID >::get_interpolated_values	(	const Vector< double > &	s,
		Vector< double > &	values
	)

inline

Call get_interpolated_values(...) for both of the underlying element types

     {
       Vector<double> basic_values;
       BASIC::get_interpolated_values(s, basic_values);
       Vector<double> solid_values;
       SOLID::get_interpolated_values(s, solid_values);
  
       // Now add the basic value first
       for (Vector<double>::iterator it = basic_values.begin();
            it != basic_values.end();
            ++it)
       {
         values.push_back(*it);
       }
       // Then the solid
       for (Vector<double>::iterator it = solid_values.begin();
            it != solid_values.end();
            ++it)
       {
         values.push_back(*it);
       }
     }

References s.

◆ get_interpolating_node_at_local_coordinate()

template<class BASIC , class SOLID >

Node* oomph::RefineablePseudoSolidNodeUpdateElement< BASIC, SOLID >::get_interpolating_node_at_local_coordinate	(	const Vector< double > &	s,
		const int &	value_id
	)

inline

The velocity nodes are the same as the geometric nodes. The pressure nodes must be calculated by using the same methods as the geometric nodes, but by recalling that there are only two pressure nodes per edge.

     {
       // Find the number of interpolated values in the BASIC equations
       int n_basic_values = BASIC::ncont_interpolated_values();
       // If the id is below this number, we call the BASIC functon
       if (value_id < n_basic_values)
       {
         return BASIC::get_interpolating_node_at_local_coordinate(s, value_id);
       }
       // Otherwise it's the solid and its value_id is the the current
       // it minus n_basic_values
       else
       {
         return SOLID::get_interpolating_node_at_local_coordinate(
           s, (value_id - n_basic_values));
       }
     }

References s.

◆ get_Z2_flux()

template<class BASIC , class SOLID >

void oomph::RefineablePseudoSolidNodeUpdateElement< 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::RefineablePseudoSolidNodeUpdateElement< 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). Refineable version includes hanging nodes

     {
       // 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++)
       {
         // If the node is a hanging node
         if (this->node_pt(j)->is_hanging())
         {
           // Find the local hang info object
           HangInfo* hang_info_pt = this->node_pt(j)->hanging_pt();
  
           // Find the number of master nodes
           unsigned n_master = hang_info_pt->nmaster();
  
           // Loop over the master nodes
           for (unsigned m = 0; m < n_master; m++)
           {
             // Get the m-th master node
             Node* Master_node_pt = hang_info_pt->master_node_pt(m);
  
             // Add to set
             geometric_data_pt.insert(
               dynamic_cast<SolidNode*>(Master_node_pt)->variable_position_pt());
           }
         }
         // Not hanging
         else
         {
           // Add node itself to set
           geometric_data_pt.insert(
             dynamic_cast<SolidNode*>(this->node_pt(j))->variable_position_pt());
         }
       }
     }

References j, m, oomph::HangInfo::master_node_pt(), and oomph::HangInfo::nmaster().

◆ interpolating_basis()

template<class BASIC , class SOLID >

void oomph::RefineablePseudoSolidNodeUpdateElement< BASIC, SOLID >::interpolating_basis	(	const Vector< double > &	s,
		Shape &	psi,
		const int &	value_id
	)		const

inline

The basis interpolating the pressure is given by pshape(). / The basis interpolating the velocity is shape().

     {
       // Find the number of interpolated values in the BASIC equations
       int n_basic_values = BASIC::ncont_interpolated_values();
       // If the id is below this number, we call the BASIC functon
       if (value_id < n_basic_values)
       {
         return BASIC::interpolating_basis(s, psi, value_id);
       }
       // Otherwise it's the solid and its value_id is the the current
       // it minus n_basic_values
       else
       {
         return SOLID::interpolating_basis(s, psi, (value_id - n_basic_values));
       }
     }

References s.

◆ interpolating_node_pt()

template<class BASIC , class SOLID >

Node* oomph::RefineablePseudoSolidNodeUpdateElement< BASIC, SOLID >::interpolating_node_pt	(	const unsigned &	n,
		const int &	value_id
	)

inline

We must compose the underlying interpolating nodes from the BASIC and SOLID equations, the BASIC ones are first

     {
       // Find the number of interpolated values in the BASIC equations
       int n_basic_values = BASIC::ncont_interpolated_values();
       // If the id is below this number, we call the BASIC functon
       if (value_id < n_basic_values)
       {
         return BASIC::interpolating_node_pt(n, value_id);
       }
       // Otherwise it's the solid and its value_id is the the current
       // it minus n_basic_values
       else
       {
         return SOLID::interpolating_node_pt(n, (value_id - n_basic_values));
       }
     }

References n.

◆ local_one_d_fraction_of_interpolating_node()

template<class BASIC , class SOLID >

double oomph::RefineablePseudoSolidNodeUpdateElement< BASIC, SOLID >::local_one_d_fraction_of_interpolating_node	(	const unsigned &	n1d,
		const unsigned &	i,
		const int &	value_id
	)

inline

The pressure nodes are the corner nodes, so when value_id==0, the fraction is the same as the 1d node number, 0 or 1.

     {
       // Find the number of interpolated values in the BASIC equations
       int n_basic_values = BASIC::ncont_interpolated_values();
       // If the id is below this number, we call the BASIC functon
       if (value_id < n_basic_values)
       {
         return BASIC::local_one_d_fraction_of_interpolating_node(
           n1d, i, value_id);
       }
       // Otherwise it's the solid and its value_id is the the current
       // it minus n_basic_values
       else
       {
         return SOLID::local_one_d_fraction_of_interpolating_node(
           n1d, i, (value_id - n_basic_values));
       }
     }

References i.

◆ nbasic_dof_types()

template<class BASIC , class SOLID >

unsigned oomph::RefineablePseudoSolidNodeUpdateElement< 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::RefineablePseudoSolidNodeUpdateElement< BASIC, SOLID >::get_dof_numbers_for_unknowns().

◆ ncont_interpolated_values()

template<class BASIC , class SOLID >

unsigned oomph::RefineablePseudoSolidNodeUpdateElement< BASIC, SOLID >::ncont_interpolated_values ( ) const

inline

The number of continuously interpolated values is the sum of the SOLID and BASIC values

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

◆ ndof_types()

template<class BASIC , class SOLID >

unsigned oomph::RefineablePseudoSolidNodeUpdateElement< 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();
     }

◆ ninterpolating_node()

template<class BASIC , class SOLID >

unsigned oomph::RefineablePseudoSolidNodeUpdateElement< BASIC, SOLID >::ninterpolating_node ( const int & value_id )

inline

The number of pressure nodes is 2^DIM. The number of velocity nodes is the same as the number of geometric nodes.

     {
       // Find the number of interpolated values in the BASIC equations
       int n_basic_values = BASIC::ncont_interpolated_values();
       // If the id is below this number, we call the BASIC functon
       if (value_id < n_basic_values)
       {
         return BASIC::ninterpolating_node(value_id);
       }
       // Otherwise it's the solid and its value_id is the the current
       // it minus n_basic_values
       else
       {
         return SOLID::ninterpolating_node((value_id - n_basic_values));
       }
     }

◆ ninterpolating_node_1d()

template<class BASIC , class SOLID >

unsigned oomph::RefineablePseudoSolidNodeUpdateElement< BASIC, SOLID >::ninterpolating_node_1d ( const int & value_id )

inline

The number of 1d pressure nodes is 2, otherwise we have the positional nodes

     {
       // Find the number of interpolated values in the BASIC equations
       int n_basic_values = BASIC::ncont_interpolated_values();
       // If the id is below this number, we call the BASIC functon
       if (value_id < n_basic_values)
       {
         return BASIC::ninterpolating_node_1d(value_id);
       }
       // Otherwise it's the solid and its value_id is the the current
       // it minus n_basic_values
       else
       {
         return SOLID::ninterpolating_node_1d((value_id - n_basic_values));
       }
     }

◆ nrecovery_order()

template<class BASIC , class SOLID >

unsigned oomph::RefineablePseudoSolidNodeUpdateElement< 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::RefineablePseudoSolidNodeUpdateElement< 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::RefineablePseudoSolidNodeUpdateElement< 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::RefineablePseudoSolidNodeUpdateElement< 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::RefineablePseudoSolidNodeUpdateElement< BASIC, SOLID >::output ( FILE * file_pt )

inline

Overload the output function: Use that of the BASIC element.

     {
       BASIC::output(file_pt);
     }

References output().

◆ output() [2/4]

template<class BASIC , class SOLID >

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

inline

Output function: Use that of the BASIC element.

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

References output().

◆ output() [3/4]

template<class BASIC , class SOLID >

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

inline

Overload the output function: Use that of the BASIC element.

     {
       BASIC::output(outfile);
     }

References output().

◆ output() [4/4]

template<class BASIC , class SOLID >

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

inline

Output function, plotting at n_p points: Use that of the BASIC element.

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

References output().

◆ rebuild_from_sons()

template<class BASIC , class SOLID >

void oomph::RefineablePseudoSolidNodeUpdateElement< BASIC, SOLID >::rebuild_from_sons ( Mesh *& mesh_pt )

inline

Call rebuild_from_sons() for both of the underlying element types.

     {
       BASIC::rebuild_from_sons(mesh_pt);
       SOLID::rebuild_from_sons(mesh_pt);
     }

◆ required_nvalue()

template<class BASIC , class SOLID >

unsigned oomph::RefineablePseudoSolidNodeUpdateElement< 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::RefineablePseudoSolidNodeUpdateElement< 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.

     {
       // Find the index in the solid
       int solid_p_index = SOLID::solid_p_nodal_index();
       // If there is a solid pressure at the nodes, return the
       // index after all the BASIC stuff
       if (solid_p_index >= 0)
       {
         return BASIC::ncont_interpolated_values() +
                SOLID::solid_p_nodal_index();
       }
       else
       {
         return solid_p_index;
       }
     }

Referenced by oomph::RefineablePseudoSolidNodeUpdateElement< BASIC, SOLID >::fill_in_shape_derivatives_by_fd().

◆ vertex_node_pt()

template<class BASIC , class SOLID >

Node* oomph::RefineablePseudoSolidNodeUpdateElement< 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.

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

pseudosolid_node_update_elements.h

Public Member Functions

Detailed Description

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

Constructor & Destructor Documentation

◆ RefineablePseudoSolidNodeUpdateElement()

Member Function Documentation

◆ assign_additional_local_eqn_numbers()

◆ build() [1/2]

◆ build() [2/2]

◆ compute_exact_Z2_error()

◆ compute_norm()

◆ describe_local_dofs()

◆ fill_in_contribution_to_jacobian()

◆ fill_in_contribution_to_jacobian_and_mass_matrix()

◆ fill_in_contribution_to_residuals()

◆ fill_in_shape_derivatives_by_fd()

◆ further_build()

◆ further_setup_hanging_nodes()

◆ get_dof_numbers_for_unknowns()

◆ get_interpolated_values() [1/2]

◆ get_interpolated_values() [2/2]

◆ get_interpolating_node_at_local_coordinate()

◆ get_Z2_flux()

◆ identify_geometric_data()

◆ interpolating_basis()

◆ interpolating_node_pt()

◆ local_one_d_fraction_of_interpolating_node()

◆ nbasic_dof_types()

◆ ncont_interpolated_values()

◆ ndof_types()

◆ ninterpolating_node()

◆ ninterpolating_node_1d()

◆ nrecovery_order()

◆ nsolid_dof_types()

◆ num_Z2_flux_terms()

◆ nvertex_node()

◆ output() [1/4]

◆ output() [2/4]

◆ output() [3/4]

◆ output() [4/4]

◆ rebuild_from_sons()

◆ required_nvalue()

◆ solid_p_nodal_index()

◆ vertex_node_pt()

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