Public Member Functions | List of all members
oomph::RefineablePVDEquationsWithPressure< DIM > Class Template Reference

#include <refineable_solid_elements.h>

+ Inheritance diagram for oomph::RefineablePVDEquationsWithPressure< DIM >:

Public Member Functions

 RefineablePVDEquationsWithPressure ()
 Constructor: More...
 
void fill_in_generic_residual_contribution_pvd_with_pressure (Vector< double > &residuals, DenseMatrix< double > &jacobian, DenseMatrix< double > &mass_matrix, const unsigned &flag)
 
void get_interpolated_values (const unsigned &t, const Vector< double > &s, Vector< double > &values)
 No values are interpolated in this element (pure solid) More...
 
void get_interpolated_values (const Vector< double > &s, Vector< double > &values)
 No values are interpolated in this element (pure solid) More...
 
unsigned num_Z2_flux_terms ()
 Number of 'flux' terms for Z2 error estimation. More...
 
void get_Z2_flux (const Vector< double > &s, Vector< double > &flux)
 in strain tensor. More...
 
unsigned ncont_interpolated_values () const
 Number of continuously interpolated values: 0 (pure solid problem) More...
 
virtual Node * solid_pressure_node_pt (const unsigned &l)
 
void further_build ()
 Pass the generic stuff down to the sons. More...
 
void get_mass_matrix_diagonal (Vector< double > &mass_diag)
 
- Public Member Functions inherited from oomph::PVDEquationsWithPressure< DIM >
 PVDEquationsWithPressure ()
 Constructor, by default the element is NOT incompressible. More...
 
void get_stress (const Vector< double > &s, DenseMatrix< double > &sigma)
 
bool is_incompressible () const
 Return whether the material is incompressible. More...
 
void set_incompressible ()
 Set the material to be incompressible. More...
 
void set_compressible ()
 Set the material to be compressible. More...
 
virtual double solid_p (const unsigned &l)=0
 Return the lth solid pressure. More...
 
virtual void set_solid_p (const unsigned &l, const double &p_value)=0
 Set the lth solid pressure to p_value. More...
 
void fill_in_contribution_to_residuals (Vector< double > &residuals)
 Fill in the residuals. More...
 
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)
 
double interpolated_solid_p (const Vector< double > &s)
 Return the interpolated_solid_pressure. More...
 
void output (std::ostream &outfile)
 Output: x,y,[z],xi0,xi1,[xi2],p,gamma. More...
 
void output (std::ostream &outfile, const unsigned &n_plot)
 Output: x,y,[z],xi0,xi1,[xi2],p,gamma. More...
 
void output (FILE *file_pt)
 C-style output: x,y,[z],xi0,xi1,[xi2],p,gamma. More...
 
void output (FILE *file_pt, const unsigned &n_plot)
 C-style output: x,y,[z],xi0,xi1,[xi2],p,gamma. More...
 
void extended_output (std::ostream &outfile, const unsigned &n_plot)
 Output: x,y,[z],xi0,xi1,[xi2],gamma strain and stress components. More...
 
void get_mass_matrix_diagonal (Vector< double > &mass_diag)
 
unsigned ndof_types () const
 
void get_dof_numbers_for_unknowns (std::list< std::pair< unsigned long, unsigned >> &dof_lookup_list) const
 
- Public Member Functions inherited from oomph::PVDEquationsBase< DIM >
 PVDEquationsBase ()
 
ConstitutiveLaw *& constitutive_law_pt ()
 Return the constitutive law pointer. More...
 
const double & lambda_sq () const
 Access function for timescale ratio (nondim density) More...
 
double *& lambda_sq_pt ()
 Access function for pointer to timescale ratio (nondim density) More...
 
IsotropicGrowthFctPt & isotropic_growth_fct_pt ()
 Access function: Pointer to isotropic growth function. More...
 
PrestressFctPt & prestress_fct_pt ()
 Access function: Pointer to pre-stress function. More...
 
IsotropicGrowthFctPt isotropic_growth_fct_pt () const
 Access function: Pointer to isotropic growth function (const version) More...
 
BodyForceFctPt & body_force_fct_pt ()
 Access function: Pointer to body force function. More...
 
BodyForceFctPt body_force_fct_pt () const
 Access function: Pointer to body force function (const version) More...
 
void enable_inertia ()
 Switch on solid inertia. More...
 
void disable_inertia ()
 Switch off solid inertia. More...
 
bool is_inertia_enabled () const
 Access function to flag that switches inertia on/off (const version) More...
 
virtual unsigned npres_solid () const
 
virtual int solid_p_local_eqn (const unsigned &i) const
 
virtual int solid_p_nodal_index () const
 
virtual void unpin_elemental_solid_pressure_dofs ()=0
 Unpin all solid pressure dofs in the element. More...
 
virtual void pin_elemental_redundant_nodal_solid_pressures ()
 Pin the element's redundant solid pressures (needed for refinement) More...
 
void get_strain (const Vector< double > &s, DenseMatrix< double > &strain) const
 Return the strain tensor. More...
 
void get_energy (double &pot_en, double &kin_en)
 Get potential (strain) and kinetic energy. More...
 
void get_deformed_covariant_basis_vectors (const Vector< double > &s, DenseMatrix< double > &def_covariant_basis)
 
void get_principal_stress (const Vector< double > &s, DenseMatrix< double > &principal_stress_vector, Vector< double > &principal_stress)
 
virtual void get_isotropic_growth (const unsigned &ipt, const Vector< double > &s, const Vector< double > &xi, double &gamma) const
 
void body_force (const Vector< double > &xi, Vector< double > &b) const
 
void enable_evaluate_jacobian_by_fd ()
 Set Jacobian to be evaluated by FD? Else: Analytically. More...
 
void disable_evaluate_jacobian_by_fd ()
 Set Jacobian to be evaluated analytically Else: by FD. More...
 
bool is_jacobian_evaluated_by_fd () const
 Return the flag indicating whether the jacobian is evaluated by fd. More...
 
double prestress (const unsigned &i, const unsigned &j, const Vector< double > xi)
 
- Public Member Functions inherited from oomph::SolidFiniteElement
void set_lagrangian_dimension (const unsigned &lagrangian_dimension)
 
virtual bool has_internal_solid_data ()
 
 SolidFiniteElement ()
 Constructor: Set defaults. More...
 
virtual ~SolidFiniteElement ()
 Destructor to clean up any allocated memory. More...
 
 SolidFiniteElement (const SolidFiniteElement &)=delete
 Broken copy constructor. More...
 
double zeta_nodal (const unsigned &n, const unsigned &k, const unsigned &i) const
 
virtual void get_x_and_xi (const Vector< double > &s, Vector< double > &x_fe, Vector< double > &x, Vector< double > &xi_fe, Vector< double > &xi) const
 
virtual void set_macro_elem_pt (MacroElement *macro_elem_pt)
 
virtual void set_macro_elem_pt (MacroElement *macro_elem_pt, MacroElement *undeformed_macro_elem_pt)
 
void set_undeformed_macro_elem_pt (MacroElement *undeformed_macro_elem_pt)
 
MacroElement * undeformed_macro_elem_pt ()
 Access function to pointer to "undeformed" macro element. More...
 
double dshape_lagrangian (const Vector< double > &s, Shape &psi, DShape &dpsidxi) const
 
virtual double dshape_lagrangian_at_knot (const unsigned &ipt, Shape &psi, DShape &dpsidxi) const
 
double d2shape_lagrangian (const Vector< double > &s, Shape &psi, DShape &dpsidxi, DShape &d2psidxi) const
 
virtual double d2shape_lagrangian_at_knot (const unsigned &ipt, Shape &psi, DShape &dpsidxi, DShape &d2psidxi) const
 
unsigned lagrangian_dimension () const
 
unsigned nnodal_lagrangian_type () const
 
Node * construct_node (const unsigned &n)
 Construct the local node n and return a pointer to it. More...
 
Node * construct_node (const unsigned &n, TimeStepper *const &time_stepper_pt)
 
Node * construct_boundary_node (const unsigned &n)
 
Node * construct_boundary_node (const unsigned &n, TimeStepper *const &time_stepper_pt)
 
virtual void assign_all_generic_local_eqn_numbers (const bool &store_local_dof_pt)
 
void describe_local_dofs (std::ostream &out, const std::string &current_string) const
 
double raw_lagrangian_position (const unsigned &n, const unsigned &i) const
 
double raw_lagrangian_position_gen (const unsigned &n, const unsigned &k, const unsigned &i) const
 
double lagrangian_position (const unsigned &n, const unsigned &i) const
 Return i-th Lagrangian coordinate at local node n. More...
 
double lagrangian_position_gen (const unsigned &n, const unsigned &k, const unsigned &i) const
 
virtual double interpolated_xi (const Vector< double > &s, const unsigned &i) const
 
virtual void interpolated_xi (const Vector< double > &s, Vector< double > &xi) const
 
virtual void interpolated_dxids (const Vector< double > &s, DenseMatrix< double > &dxids) const
 
virtual void J_lagrangian (const Vector< double > &s) const
 
virtual double J_lagrangian_at_knot (const unsigned &ipt) const
 
SolidInitialCondition *& solid_ic_pt ()
 Pointer to object that describes the initial condition. More...
 
void enable_solve_for_consistent_newmark_accel ()
 
void disable_solve_for_consistent_newmark_accel ()
 Set to reset the problem being solved to be the standard problem. More...
 
MultiplierFctPt & multiplier_fct_pt ()
 
MultiplierFctPt multiplier_fct_pt () const
 
virtual void get_residuals_for_solid_ic (Vector< double > &residuals)
 
void fill_in_residuals_for_solid_ic (Vector< double > &residuals)
 
void fill_in_jacobian_for_solid_ic (Vector< double > &residuals, DenseMatrix< double > &jacobian)
 
void fill_in_jacobian_for_newmark_accel (DenseMatrix< double > &jacobian)
 
void compute_norm (double &el_norm)
 
int position_local_eqn (const unsigned &n, const unsigned &k, const unsigned &j) const
 
- Public Member Functions inherited from oomph::FiniteElement
void set_dimension (const unsigned &dim)
 
void set_nodal_dimension (const unsigned &nodal_dim)
 
void set_nnodal_position_type (const unsigned &nposition_type)
 Set the number of types required to interpolate the coordinate. More...
 
void set_n_node (const unsigned &n)
 
int nodal_local_eqn (const unsigned &n, const unsigned &i) const
 
double dJ_eulerian_at_knot (const unsigned &ipt, Shape &psi, DenseMatrix< double > &djacobian_dX) const
 
 FiniteElement ()
 Constructor. More...
 
virtual ~FiniteElement ()
 
 FiniteElement (const FiniteElement &)=delete
 Broken copy constructor. More...
 
virtual bool local_coord_is_valid (const Vector< double > &s)
 Broken assignment operator. More...
 
virtual void move_local_coord_back_into_element (Vector< double > &s) const
 
void get_centre_of_gravity_and_max_radius_in_terms_of_zeta (Vector< double > &cog, double &max_radius) const
 
virtual void local_coordinate_of_node (const unsigned &j, Vector< double > &s) const
 
virtual void local_fraction_of_node (const unsigned &j, Vector< double > &s_fraction)
 
virtual double local_one_d_fraction_of_node (const unsigned &n1d, const unsigned &i)
 
MacroElement * macro_elem_pt ()
 Access function to pointer to macro element. More...
 
void get_x (const Vector< double > &s, Vector< double > &x) const
 
void get_x (const unsigned &t, const Vector< double > &s, Vector< double > &x)
 
virtual void get_x_from_macro_element (const Vector< double > &s, Vector< double > &x) const
 
virtual void get_x_from_macro_element (const unsigned &t, const Vector< double > &s, Vector< double > &x)
 
virtual void set_integration_scheme (Integral *const &integral_pt)
 Set the spatial integration scheme. More...
 
Integral *const & integral_pt () const
 Return the pointer to the integration scheme (const version) More...
 
virtual void shape (const Vector< double > &s, Shape &psi) const =0
 
virtual void shape_at_knot (const unsigned &ipt, Shape &psi) const
 
virtual void dshape_local (const Vector< double > &s, Shape &psi, DShape &dpsids) const
 
virtual void dshape_local_at_knot (const unsigned &ipt, Shape &psi, DShape &dpsids) const
 
virtual void d2shape_local (const Vector< double > &s, Shape &psi, DShape &dpsids, DShape &d2psids) const
 
virtual void d2shape_local_at_knot (const unsigned &ipt, Shape &psi, DShape &dpsids, DShape &d2psids) const
 
virtual double J_eulerian (const Vector< double > &s) const
 
virtual double J_eulerian_at_knot (const unsigned &ipt) const
 
void check_J_eulerian_at_knots (bool &passed) const
 
void check_jacobian (const double &jacobian) const
 
double dshape_eulerian (const Vector< double > &s, Shape &psi, DShape &dpsidx) const
 
virtual double dshape_eulerian_at_knot (const unsigned &ipt, Shape &psi, DShape &dpsidx) const
 
virtual double dshape_eulerian_at_knot (const unsigned &ipt, Shape &psi, DShape &dpsi, DenseMatrix< double > &djacobian_dX, RankFourTensor< double > &d_dpsidx_dX) const
 
double d2shape_eulerian (const Vector< double > &s, Shape &psi, DShape &dpsidx, DShape &d2psidx) const
 
virtual double d2shape_eulerian_at_knot (const unsigned &ipt, Shape &psi, DShape &dpsidx, DShape &d2psidx) const
 
virtual void describe_nodal_local_dofs (std::ostream &out, const std::string &current_string) const
 
Node *& node_pt (const unsigned &n)
 Return a pointer to the local node n. More...
 
Node *const & node_pt (const unsigned &n) const
 Return a pointer to the local node n (const version) More...
 
unsigned nnode () const
 Return the number of nodes. More...
 
virtual unsigned nnode_1d () const
 
double raw_nodal_position (const unsigned &n, const unsigned &i) const
 
double raw_nodal_position (const unsigned &t, const unsigned &n, const unsigned &i) const
 
double raw_dnodal_position_dt (const unsigned &n, const unsigned &i) const
 
double raw_dnodal_position_dt (const unsigned &n, const unsigned &j, const unsigned &i) const
 
double raw_nodal_position_gen (const unsigned &n, const unsigned &k, const unsigned &i) const
 
double raw_nodal_position_gen (const unsigned &t, const unsigned &n, const unsigned &k, const unsigned &i) const
 
double raw_dnodal_position_gen_dt (const unsigned &n, const unsigned &k, const unsigned &i) const
 
double raw_dnodal_position_gen_dt (const unsigned &j, const unsigned &n, const unsigned &k, const unsigned &i) const
 
double nodal_position (const unsigned &n, const unsigned &i) const
 
double nodal_position (const unsigned &t, const unsigned &n, const unsigned &i) const
 
double dnodal_position_dt (const unsigned &n, const unsigned &i) const
 Return the i-th component of nodal velocity: dx/dt at local node n. More...
 
double dnodal_position_dt (const unsigned &n, const unsigned &j, const unsigned &i) const
 
double nodal_position_gen (const unsigned &n, const unsigned &k, const unsigned &i) const
 
double nodal_position_gen (const unsigned &t, const unsigned &n, const unsigned &k, const unsigned &i) const
 
double dnodal_position_gen_dt (const unsigned &n, const unsigned &k, const unsigned &i) const
 
double dnodal_position_gen_dt (const unsigned &j, const unsigned &n, const unsigned &k, const unsigned &i) const
 
virtual void disable_ALE ()
 
virtual void enable_ALE ()
 
virtual unsigned required_nvalue (const unsigned &n) const
 
unsigned nnodal_position_type () const
 
bool has_hanging_nodes () const
 
unsigned nodal_dimension () const
 Return the required Eulerian dimension of the nodes in this element. More...
 
int get_node_number (Node *const &node_pt) const
 
virtual Node * get_node_at_local_coordinate (const Vector< double > &s) const
 
double raw_nodal_value (const unsigned &n, const unsigned &i) const
 
double raw_nodal_value (const unsigned &t, const unsigned &n, const unsigned &i) const
 
double nodal_value (const unsigned &n, const unsigned &i) const
 
double nodal_value (const unsigned &t, const unsigned &n, const unsigned &i) const
 
unsigned dim () const
 
virtual ElementGeometry::ElementGeometry element_geometry () const
 Return the geometry type of the element (either Q or T usually). More...
 
virtual double interpolated_x (const Vector< double > &s, const unsigned &i) const
 Return FE interpolated coordinate x[i] at local coordinate s. More...
 
virtual double interpolated_x (const unsigned &t, const Vector< double > &s, const unsigned &i) const
 
virtual void interpolated_x (const Vector< double > &s, Vector< double > &x) const
 Return FE interpolated position x[] at local coordinate s as Vector. More...
 
virtual void interpolated_x (const unsigned &t, const Vector< double > &s, Vector< double > &x) const
 
virtual double interpolated_dxdt (const Vector< double > &s, const unsigned &i, const unsigned &t)
 
virtual void interpolated_dxdt (const Vector< double > &s, const unsigned &t, Vector< double > &dxdt)
 
void position (const Vector< double > &zeta, Vector< double > &r) const
 
void position (const unsigned &t, const Vector< double > &zeta, Vector< double > &r) const
 
void dposition_dt (const Vector< double > &zeta, const unsigned &t, Vector< double > &drdt)
 
void interpolated_zeta (const Vector< double > &s, Vector< double > &zeta) const
 
void locate_zeta (const Vector< double > &zeta, GeomObject *&geom_object_pt, Vector< double > &s, const bool &use_coordinate_as_initial_guess=false)
 
virtual void node_update ()
 
virtual double s_min () const
 Min value of local coordinate. More...
 
virtual double s_max () const
 Max. value of local coordinate. More...
 
double size () const
 
virtual double compute_physical_size () const
 
virtual void point_output_data (const Vector< double > &s, Vector< double > &data)
 
void point_output (std::ostream &outfile, const Vector< double > &s)
 
virtual unsigned nplot_points_paraview (const unsigned &nplot) const
 
virtual unsigned nsub_elements_paraview (const unsigned &nplot) const
 
void output_paraview (std::ofstream &file_out, const unsigned &nplot) const
 
virtual void write_paraview_output_offset_information (std::ofstream &file_out, const unsigned &nplot, unsigned &counter) const
 
virtual void write_paraview_type (std::ofstream &file_out, const unsigned &nplot) const
 
virtual void write_paraview_offsets (std::ofstream &file_out, const unsigned &nplot, unsigned &offset_sum) const
 
virtual unsigned nscalar_paraview () const
 
virtual void scalar_value_paraview (std::ofstream &file_out, const unsigned &i, const unsigned &nplot) const
 
virtual void scalar_value_fct_paraview (std::ofstream &file_out, const unsigned &i, const unsigned &nplot, FiniteElement::SteadyExactSolutionFctPt exact_soln_pt) const
 
virtual void scalar_value_fct_paraview (std::ofstream &file_out, const unsigned &i, const unsigned &nplot, const double &time, FiniteElement::UnsteadyExactSolutionFctPt exact_soln_pt) const
 
virtual std::string scalar_name_paraview (const unsigned &i) const
 
virtual void output (const unsigned &t, std::ostream &outfile, const unsigned &n_plot) const
 
virtual void output_fct (std::ostream &outfile, const unsigned &n_plot, FiniteElement::SteadyExactSolutionFctPt exact_soln_pt)
 Output an exact solution over the element. More...
 
virtual void output_fct (std::ostream &outfile, const unsigned &n_plot, const double &time, FiniteElement::UnsteadyExactSolutionFctPt exact_soln_pt)
 Output a time-dependent exact solution over the element. More...
 
virtual void output_fct (std::ostream &outfile, const unsigned &n_plot, const double &time, const SolutionFunctorBase &exact_soln) const
 Output a time-dependent exact solution over the element. More...
 
virtual void get_s_plot (const unsigned &i, const unsigned &nplot, Vector< double > &s, const bool &shifted_to_interior=false) const
 
virtual std::string tecplot_zone_string (const unsigned &nplot) const
 
virtual void write_tecplot_zone_footer (std::ostream &outfile, const unsigned &nplot) const
 
virtual void write_tecplot_zone_footer (FILE *file_pt, const unsigned &nplot) const
 
virtual unsigned nplot_points (const unsigned &nplot) const
 
virtual void compute_error (FiniteElement::SteadyExactSolutionFctPt exact_soln_pt, double &error, double &norm)
 Calculate the norm of the error and that of the exact solution. More...
 
virtual void compute_error (FiniteElement::UnsteadyExactSolutionFctPt exact_soln_pt, const double &time, double &error, double &norm)
 Calculate the norm of the error and that of the exact solution. More...
 
virtual void compute_error (FiniteElement::SteadyExactSolutionFctPt exact_soln_pt, Vector< double > &error, Vector< double > &norm)
 
virtual void compute_error (FiniteElement::UnsteadyExactSolutionFctPt exact_soln_pt, const double &time, Vector< double > &error, Vector< double > &norm)
 
virtual void compute_error (std::ostream &outfile, FiniteElement::SteadyExactSolutionFctPt exact_soln_pt, double &error, double &norm)
 
virtual void compute_error (std::ostream &outfile, FiniteElement::UnsteadyExactSolutionFctPt exact_soln_pt, const double &time, double &error, double &norm)
 
virtual void compute_error (std::ostream &outfile, FiniteElement::SteadyExactSolutionFctPt exact_soln_pt, Vector< double > &error, Vector< double > &norm)
 
virtual void compute_error (std::ostream &outfile, FiniteElement::UnsteadyExactSolutionFctPt exact_soln_pt, const double &time, Vector< double > &error, Vector< double > &norm)
 
virtual void compute_abs_error (std::ostream &outfile, FiniteElement::SteadyExactSolutionFctPt exact_soln_pt, double &error)
 
void integrate_fct (FiniteElement::SteadyExactSolutionFctPt integrand_fct_pt, Vector< double > &integral)
 Integrate Vector-valued function over element. More...
 
void integrate_fct (FiniteElement::UnsteadyExactSolutionFctPt integrand_fct_pt, const double &time, Vector< double > &integral)
 Integrate Vector-valued time-dep function over element. More...
 
virtual void build_face_element (const int &face_index, FaceElement *face_element_pt)
 
virtual unsigned self_test ()
 
virtual unsigned get_bulk_node_number (const int &face_index, const unsigned &i) const
 
virtual int face_outer_unit_normal_sign (const int &face_index) const
 Get the sign of the outer unit normal on the face given by face_index. More...
 
virtual unsigned nnode_on_face () const
 
void face_node_number_error_check (const unsigned &i) const
 Range check for face node numbers. More...
 
virtual CoordinateMappingFctPt face_to_bulk_coordinate_fct_pt (const int &face_index) const
 
virtual BulkCoordinateDerivativesFctPt bulk_coordinate_derivatives_fct_pt (const int &face_index) const
 
- Public Member Functions inherited from oomph::GeneralisedElement
 GeneralisedElement ()
 Constructor: Initialise all pointers and all values to zero. More...
 
virtual ~GeneralisedElement ()
 Virtual destructor to clean up any memory allocated by the object. More...
 
 GeneralisedElement (const GeneralisedElement &)=delete
 Broken copy constructor. More...
 
void operator= (const GeneralisedElement &)=delete
 Broken assignment operator. More...
 
Data *& internal_data_pt (const unsigned &i)
 Return a pointer to i-th internal data object. More...
 
Data *const & internal_data_pt (const unsigned &i) const
 Return a pointer to i-th internal data object (const version) More...
 
Data *& external_data_pt (const unsigned &i)
 Return a pointer to i-th external data object. More...
 
Data *const & external_data_pt (const unsigned &i) const
 Return a pointer to i-th external data object (const version) More...
 
unsigned long eqn_number (const unsigned &ieqn_local) const
 
int local_eqn_number (const unsigned long &ieqn_global) const
 
unsigned add_external_data (Data *const &data_pt, const bool &fd=true)
 
bool external_data_fd (const unsigned &i) const
 
void exclude_external_data_fd (const unsigned &i)
 
void include_external_data_fd (const unsigned &i)
 
void flush_external_data ()
 Flush all external data. More...
 
void flush_external_data (Data *const &data_pt)
 Flush the object addressed by data_pt from the external data array. More...
 
unsigned ninternal_data () const
 Return the number of internal data objects. More...
 
unsigned nexternal_data () const
 Return the number of external data objects. More...
 
unsigned ndof () const
 Return the number of equations/dofs in the element. More...
 
void dof_vector (const unsigned &t, Vector< double > &dof)
 Return the vector of dof values at time level t. More...
 
void dof_pt_vector (Vector< double * > &dof_pt)
 Return the vector of pointers to dof values. More...
 
void set_internal_data_time_stepper (const unsigned &i, TimeStepper *const &time_stepper_pt, const bool &preserve_existing_data)
 
void assign_internal_eqn_numbers (unsigned long &global_number, Vector< double * > &Dof_pt)
 
void describe_dofs (std::ostream &out, const std::string &current_string) const
 
void add_internal_value_pt_to_map (std::map< unsigned, double * > &map_of_value_pt)
 
virtual void assign_local_eqn_numbers (const bool &store_local_dof_pt)
 
virtual void complete_setup_of_dependencies ()
 
virtual void get_residuals (Vector< double > &residuals)
 
virtual void get_jacobian (Vector< double > &residuals, DenseMatrix< double > &jacobian)
 
virtual void get_mass_matrix (Vector< double > &residuals, DenseMatrix< double > &mass_matrix)
 
virtual void get_jacobian_and_mass_matrix (Vector< double > &residuals, DenseMatrix< double > &jacobian, DenseMatrix< double > &mass_matrix)
 
virtual void get_dresiduals_dparameter (double *const &parameter_pt, Vector< double > &dres_dparam)
 
virtual void get_djacobian_dparameter (double *const &parameter_pt, Vector< double > &dres_dparam, DenseMatrix< double > &djac_dparam)
 
virtual void get_djacobian_and_dmass_matrix_dparameter (double *const &parameter_pt, Vector< double > &dres_dparam, DenseMatrix< double > &djac_dparam, DenseMatrix< double > &dmass_matrix_dparam)
 
virtual void get_hessian_vector_products (Vector< double > const &Y, DenseMatrix< double > const &C, DenseMatrix< double > &product)
 
virtual void get_inner_products (Vector< std::pair< unsigned, unsigned >> const &history_index, Vector< double > &inner_product)
 
virtual void get_inner_product_vectors (Vector< unsigned > const &history_index, Vector< Vector< double >> &inner_product_vector)
 
virtual void compute_norm (Vector< double > &norm)
 
- Public Member Functions inherited from oomph::GeomObject
 GeomObject ()
 Default constructor. More...
 
 GeomObject (const unsigned &ndim)
 
 GeomObject (const unsigned &nlagrangian, const unsigned &ndim)
 
 GeomObject (const unsigned &nlagrangian, const unsigned &ndim, TimeStepper *time_stepper_pt)
 
 GeomObject (const GeomObject &dummy)=delete
 Broken copy constructor. More...
 
void operator= (const GeomObject &)=delete
 Broken assignment operator. More...
 
virtual ~GeomObject ()
 (Empty) destructor More...
 
unsigned nlagrangian () const
 Access function to # of Lagrangian coordinates. More...
 
unsigned ndim () const
 Access function to # of Eulerian coordinates. More...
 
void set_nlagrangian_and_ndim (const unsigned &n_lagrangian, const unsigned &n_dim)
 Set # of Lagrangian and Eulerian coordinates. More...
 
TimeStepper *& time_stepper_pt ()
 
TimeStepper * time_stepper_pt () const
 
virtual void position (const double &t, const Vector< double > &zeta, Vector< double > &r) const
 
virtual void dposition (const Vector< double > &zeta, DenseMatrix< double > &drdzeta) const
 
virtual void d2position (const Vector< double > &zeta, RankThreeTensor< double > &ddrdzeta) const
 
virtual void d2position (const Vector< double > &zeta, Vector< double > &r, DenseMatrix< double > &drdzeta, RankThreeTensor< double > &ddrdzeta) const
 
- Public Member Functions inherited from oomph::SolidElementWithDiagonalMassMatrix
 SolidElementWithDiagonalMassMatrix ()
 Empty constructor. More...
 
virtual ~SolidElementWithDiagonalMassMatrix ()
 Virtual destructor. More...
 
 SolidElementWithDiagonalMassMatrix (const SolidElementWithDiagonalMassMatrix &)=delete
 Broken copy constructor. More...
 
void operator= (const SolidElementWithDiagonalMassMatrix &)=delete
 Broken assignment operator. More...
 
- Public Member Functions inherited from oomph::RefineableSolidElement
 RefineableSolidElement ()
 Constructor. More...
 
virtual ~RefineableSolidElement ()
 Virtual Destructor, delete any allocated storage. More...
 
void assign_solid_local_eqn_numbers (const bool &store_local_dof_pt)
 
unsigned ngeom_data () const
 
Data * geom_data_pt (const unsigned &j)
 
void identify_geometric_data (std::set< Data * > &geometric_data_pt)
 
void fill_in_jacobian_from_solid_position_by_fd (Vector< double > &residuals, DenseMatrix< double > &jacobian)
 
bool is_undeformed_macro_element_used_for_new_lagrangian_coords () const
 
void enable_use_of_undeformed_macro_element_for_new_lagrangian_coords ()
 
void disable_use_of_undeformed_macro_element_for_new_lagrangian_coords ()
 
DenseMatrix< int > & local_position_hang_eqn (Node *const &node_pt)
 
- Public Member Functions inherited from oomph::RefineableElement
 RefineableElement ()
 
virtual ~RefineableElement ()
 Destructor, delete the allocated storage for the hanging equations. More...
 
 RefineableElement (const RefineableElement &)=delete
 Broken copy constructor. More...
 
void operator= (const RefineableElement &)=delete
 Broken assignment operator. More...
 
Tree * tree_pt ()
 Access function: Pointer to quadtree representation of this element. More...
 
void set_tree_pt (Tree *my_tree_pt)
 Set pointer to quadtree representation of this element. More...
 
virtual unsigned required_nsons () const
 
bool refinement_is_enabled ()
 Flag to indicate suppression of any refinement. More...
 
void disable_refinement ()
 Suppress of any refinement for this element. More...
 
void enable_refinement ()
 Emnable refinement for this element. More...
 
template<class ELEMENT >
void split (Vector< ELEMENT * > &son_pt) const
 
int local_hang_eqn (Node *const &node_pt, const unsigned &i)
 
virtual void build (Mesh *&mesh_pt, Vector< Node * > &new_node_pt, bool &was_already_built, std::ofstream &new_nodes_file)=0
 
void set_refinement_level (const int &refine_level)
 Set the refinement level. More...
 
unsigned refinement_level () const
 Return the Refinement level. More...
 
void select_for_refinement ()
 Select the element for refinement. More...
 
void deselect_for_refinement ()
 Deselect the element for refinement. More...
 
void select_sons_for_unrefinement ()
 Unrefinement will be performed by merging the four sons of this element. More...
 
void deselect_sons_for_unrefinement ()
 
bool to_be_refined ()
 Has the element been selected for refinement? More...
 
bool sons_to_be_unrefined ()
 Has the element been selected for unrefinement? More...
 
virtual void rebuild_from_sons (Mesh *&mesh_pt)=0
 
virtual void unbuild ()
 
virtual void deactivate_element ()
 
virtual bool nodes_built ()
 Return true if all the nodes have been built, false if not. More...
 
long number () const
 Element number (for debugging/plotting) More...
 
void set_number (const long &mynumber)
 Set element number (for debugging/plotting) More...
 
virtual Node * interpolating_node_pt (const unsigned &n, const int &value_id)
 
virtual double local_one_d_fraction_of_interpolating_node (const unsigned &n1d, const unsigned &i, const int &value_id)
 
virtual Node * get_interpolating_node_at_local_coordinate (const Vector< double > &s, const int &value_id)
 
virtual unsigned ninterpolating_node (const int &value_id)
 
virtual unsigned ninterpolating_node_1d (const int &value_id)
 
virtual void interpolating_basis (const Vector< double > &s, Shape &psi, const int &value_id) const
 
virtual void check_integrity (double &max_error)=0
 
void identify_field_data_for_interactions (std::set< std::pair< Data *, unsigned >> &paired_field_data)
 
void assign_nodal_local_eqn_numbers (const bool &store_local_dof_pt)
 
virtual RefineableElement * root_element_pt ()
 
virtual RefineableElement * father_element_pt () const
 Return a pointer to the father element. More...
 
void get_father_at_refinement_level (unsigned &refinement_level, RefineableElement *&father_at_reflevel_pt)
 
virtual void initial_setup (Tree *const &adopted_father_pt=0, const unsigned &initial_p_order=0)
 
virtual void pre_build (Mesh *&mesh_pt, Vector< Node * > &new_node_pt)
 Pre-build the element. More...
 
virtual void setup_hanging_nodes (Vector< std::ofstream * > &output_stream)
 
virtual void further_setup_hanging_nodes ()
 
void get_dresidual_dnodal_coordinates (RankThreeTensor< double > &dresidual_dnodal_coordinates)
 
unsigned nshape_controlling_nodes ()
 
std::map< Node *, unsigned > shape_controlling_node_lookup ()
 
- Public Member Functions inherited from oomph::ElementWithZ2ErrorEstimator
 ElementWithZ2ErrorEstimator ()
 Default empty constructor. More...
 
 ElementWithZ2ErrorEstimator (const ElementWithZ2ErrorEstimator &)=delete
 Broken copy constructor. More...
 
void operator= (const ElementWithZ2ErrorEstimator &)=delete
 Broken assignment operator. More...
 
virtual unsigned ncompound_fluxes ()
 
virtual void compute_exact_Z2_error (std::ostream &outfile, FiniteElement::SteadyExactSolutionFctPt exact_flux_pt, double &error, double &norm)
 
virtual void get_Z2_compound_flux_indices (Vector< unsigned > &flux_index)
 
virtual unsigned nvertex_node () const =0
 Number of vertex nodes in the element. More...
 
virtual Node * vertex_node_pt (const unsigned &j) const =0
 
virtual unsigned nrecovery_order ()=0
 Order of recovery shape functions. More...
 
virtual double geometric_jacobian (const Vector< double > &x)
 

Additional Inherited Members

- Public Types inherited from oomph::PVDEquationsBase< DIM >
typedef void(* IsotropicGrowthFctPt) (const Vector< double > &xi, double &gamma)
 
typedef double(* PrestressFctPt) (const unsigned &i, const unsigned &j, const Vector< double > &xi)
 
typedef void(* BodyForceFctPt) (const double &t, const Vector< double > &xi, Vector< double > &b)
 
- Public Types inherited from oomph::SolidFiniteElement
typedef double(* MultiplierFctPt) (const Vector< double > &xi)
 
- Public Types inherited from oomph::FiniteElement
typedef void(* SteadyExactSolutionFctPt) (const Vector< double > &, Vector< double > &)
 
typedef void(* UnsteadyExactSolutionFctPt) (const double &, const Vector< double > &, Vector< double > &)
 
- Static Public Member Functions inherited from oomph::PVDEquationsBase< DIM >
static void pin_redundant_nodal_solid_pressures (const Vector< GeneralisedElement * > &element_pt)
 
static void unpin_all_solid_pressure_dofs (const Vector< GeneralisedElement * > &element_pt)
 Unpin all pressure dofs in elements listed in vector. More...
 
- Static Public Member Functions inherited from oomph::RefineableElement
static double & max_integrity_tolerance ()
 Max. allowed discrepancy in element integrity check. More...
 
- Static Public Attributes inherited from oomph::FiniteElement
static double Tolerance_for_singular_jacobian = 1.0e-16
 Tolerance below which the jacobian is considered singular. More...
 
static bool Accept_negative_jacobian = false
 
static bool Suppress_output_while_checking_for_inverted_elements
 
- Static Public Attributes inherited from oomph::GeneralisedElement
static bool Suppress_warning_about_repeated_internal_data
 
static bool Suppress_warning_about_repeated_external_data = true
 
static double Default_fd_jacobian_step = 1.0e-8
 
- Protected Member Functions inherited from oomph::PVDEquationsWithPressure< DIM >
void get_stress (const DenseMatrix< double > &g, const DenseMatrix< double > &G, DenseMatrix< double > &sigma_dev, DenseMatrix< double > &Gcontra, double &gen_dil, double &inv_kappa)
 
void get_d_stress_dG_upper (const DenseMatrix< double > &g, const DenseMatrix< double > &G, const DenseMatrix< double > &sigma, const double &gen_dil, const double &inv_kappa, const double &interpolated_solid_p, RankFourTensor< double > &d_sigma_dG, DenseMatrix< double > &d_gen_dil_dG)
 
virtual void solid_pshape (const Vector< double > &s, Shape &psi) const =0
 Return the solid pressure shape functions. More...
 
void solid_pshape_at_knot (const unsigned &ipt, Shape &psi) const
 Return the stored solid shape functions at the knots. More...
 
void get_stress (const DenseMatrix< double > &g, const DenseMatrix< double > &G, DenseMatrix< double > &sigma_dev, DenseMatrix< double > &Gcontra, double &detG)
 
void get_d_stress_dG_upper (const DenseMatrix< double > &g, const DenseMatrix< double > &G, const DenseMatrix< double > &sigma, const double &detG, const double &interpolated_solid_p, RankFourTensor< double > &d_sigma_dG, DenseMatrix< double > &d_detG_dG)
 
- Protected Member Functions inherited from oomph::SolidFiniteElement
void fill_in_generic_jacobian_for_solid_ic (Vector< double > &residuals, DenseMatrix< double > &jacobian, const unsigned &flag)
 
void set_nnodal_lagrangian_type (const unsigned &nlagrangian_type)
 
virtual double local_to_lagrangian_mapping (const DShape &dpsids, DenseMatrix< double > &jacobian, DenseMatrix< double > &inverse_jacobian) const
 
double local_to_lagrangian_mapping (const DShape &dpsids, DenseMatrix< double > &inverse_jacobian) const
 
void describe_solid_local_dofs (std::ostream &out, const std::string &current_string) const
 Classifies dofs locally for solid specific aspects. More...
 
void fill_in_jacobian_from_solid_position_by_fd (DenseMatrix< double > &jacobian)
 
virtual void update_before_solid_position_fd ()
 
virtual void reset_after_solid_position_fd ()
 
virtual void update_in_solid_position_fd (const unsigned &i)
 
virtual void reset_in_solid_position_fd (const unsigned &i)
 
- Protected Member Functions inherited from oomph::FiniteElement
template<unsigned DIM>
double invert_jacobian (const DenseMatrix< double > &jacobian, DenseMatrix< double > &inverse_jacobian) const
 
virtual double invert_jacobian_mapping (const DenseMatrix< double > &jacobian, DenseMatrix< double > &inverse_jacobian) const
 
virtual double local_to_eulerian_mapping (const DShape &dpsids, DenseMatrix< double > &jacobian, DenseMatrix< double > &inverse_jacobian) const
 
double local_to_eulerian_mapping (const DShape &dpsids, DenseMatrix< double > &inverse_jacobian) const
 
virtual void dJ_eulerian_dnodal_coordinates (const DenseMatrix< double > &jacobian, const DShape &dpsids, DenseMatrix< double > &djacobian_dX) const
 
template<unsigned DIM>
void dJ_eulerian_dnodal_coordinates_templated_helper (const DenseMatrix< double > &jacobian, const DShape &dpsids, DenseMatrix< double > &djacobian_dX) const
 
virtual void d_dshape_eulerian_dnodal_coordinates (const double &det_jacobian, const DenseMatrix< double > &jacobian, const DenseMatrix< double > &djacobian_dX, const DenseMatrix< double > &inverse_jacobian, const DShape &dpsids, RankFourTensor< double > &d_dpsidx_dX) const
 
template<unsigned DIM>
void d_dshape_eulerian_dnodal_coordinates_templated_helper (const double &det_jacobian, const DenseMatrix< double > &jacobian, const DenseMatrix< double > &djacobian_dX, const DenseMatrix< double > &inverse_jacobian, const DShape &dpsids, RankFourTensor< double > &d_dpsidx_dX) const
 
virtual void transform_derivatives (const DenseMatrix< double > &inverse_jacobian, DShape &dbasis) const
 
void transform_derivatives_diagonal (const DenseMatrix< double > &inverse_jacobian, DShape &dbasis) const
 
virtual void transform_second_derivatives (const DenseMatrix< double > &jacobian, const DenseMatrix< double > &inverse_jacobian, const DenseMatrix< double > &jacobian2, DShape &dbasis, DShape &d2basis) const
 
template<unsigned DIM>
void transform_second_derivatives_template (const DenseMatrix< double > &jacobian, const DenseMatrix< double > &inverse_jacobian, const DenseMatrix< double > &jacobian2, DShape &dbasis, DShape &d2basis) const
 
template<unsigned DIM>
void transform_second_derivatives_diagonal (const DenseMatrix< double > &jacobian, const DenseMatrix< double > &inverse_jacobian, const DenseMatrix< double > &jacobian2, DShape &dbasis, DShape &d2basis) const
 
void fill_in_jacobian_from_nodal_by_fd (DenseMatrix< double > &jacobian)
 
virtual void update_before_nodal_fd ()
 
virtual void reset_after_nodal_fd ()
 
virtual void update_in_nodal_fd (const unsigned &i)
 
virtual void reset_in_nodal_fd (const unsigned &i)
 
template<>
double invert_jacobian (const DenseMatrix< double > &jacobian, DenseMatrix< double > &inverse_jacobian) const
 Zero-d specialisation of function to calculate inverse of jacobian mapping. More...
 
template<>
double invert_jacobian (const DenseMatrix< double > &jacobian, DenseMatrix< double > &inverse_jacobian) const
 One-d specialisation of function to calculate inverse of jacobian mapping. More...
 
template<>
double invert_jacobian (const DenseMatrix< double > &jacobian, DenseMatrix< double > &inverse_jacobian) const
 Two-d specialisation of function to calculate inverse of jacobian mapping. More...
 
template<>
double invert_jacobian (const DenseMatrix< double > &jacobian, DenseMatrix< double > &inverse_jacobian) const
 
template<>
void dJ_eulerian_dnodal_coordinates_templated_helper (const DenseMatrix< double > &jacobian, const DShape &dpsids, DenseMatrix< double > &djacobian_dX) const
 
template<>
void dJ_eulerian_dnodal_coordinates_templated_helper (const DenseMatrix< double > &jacobian, const DShape &dpsids, DenseMatrix< double > &djacobian_dX) const
 
template<>
void dJ_eulerian_dnodal_coordinates_templated_helper (const DenseMatrix< double > &jacobian, const DShape &dpsids, DenseMatrix< double > &djacobian_dX) const
 
template<>
void dJ_eulerian_dnodal_coordinates_templated_helper (const DenseMatrix< double > &jacobian, const DShape &dpsids, DenseMatrix< double > &djacobian_dX) const
 
template<>
void d_dshape_eulerian_dnodal_coordinates_templated_helper (const double &det_jacobian, const DenseMatrix< double > &jacobian, const DenseMatrix< double > &djacobian_dX, const DenseMatrix< double > &inverse_jacobian, const DShape &dpsids, RankFourTensor< double > &d_dpsidx_dX) const
 
template<>
void d_dshape_eulerian_dnodal_coordinates_templated_helper (const double &det_jacobian, const DenseMatrix< double > &jacobian, const DenseMatrix< double > &djacobian_dX, const DenseMatrix< double > &inverse_jacobian, const DShape &dpsids, RankFourTensor< double > &d_dpsidx_dX) const
 
template<>
void d_dshape_eulerian_dnodal_coordinates_templated_helper (const double &det_jacobian, const DenseMatrix< double > &jacobian, const DenseMatrix< double > &djacobian_dX, const DenseMatrix< double > &inverse_jacobian, const DShape &dpsids, RankFourTensor< double > &d_dpsidx_dX) const
 
template<>
void d_dshape_eulerian_dnodal_coordinates_templated_helper (const double &det_jacobian, const DenseMatrix< double > &jacobian, const DenseMatrix< double > &djacobian_dX, const DenseMatrix< double > &inverse_jacobian, const DShape &dpsids, RankFourTensor< double > &d_dpsidx_dX) const
 
template<>
void transform_second_derivatives_template (const DenseMatrix< double > &jacobian, const DenseMatrix< double > &inverse_jacobian, const DenseMatrix< double > &jacobian2, DShape &dbasis, DShape &d2basis) const
 
template<>
void transform_second_derivatives_template (const DenseMatrix< double > &jacobian, const DenseMatrix< double > &inverse_jacobian, const DenseMatrix< double > &jacobian2, DShape &dbasis, DShape &d2basis) const
 
template<>
void transform_second_derivatives_diagonal (const DenseMatrix< double > &jacobian, const DenseMatrix< double > &inverse_jacobian, const DenseMatrix< double > &jacobian2, DShape &dbasis, DShape &d2basis) const
 
template<>
void transform_second_derivatives_diagonal (const DenseMatrix< double > &jacobian, const DenseMatrix< double > &inverse_jacobian, const DenseMatrix< double > &jacobian2, DShape &dbasis, DShape &d2basis) const
 
- Protected Member Functions inherited from oomph::GeneralisedElement
unsigned add_internal_data (Data *const &data_pt, const bool &fd=true)
 
bool internal_data_fd (const unsigned &i) const
 
void exclude_internal_data_fd (const unsigned &i)
 
void include_internal_data_fd (const unsigned &i)
 
void clear_global_eqn_numbers ()
 
void add_global_eqn_numbers (std::deque< unsigned long > const &global_eqn_numbers, std::deque< double * > const &global_dof_pt)
 
virtual void assign_internal_and_external_local_eqn_numbers (const bool &store_local_dof_pt)
 
virtual void assign_additional_local_eqn_numbers ()
 
int internal_local_eqn (const unsigned &i, const unsigned &j) const
 
int external_local_eqn (const unsigned &i, const unsigned &j)
 
void fill_in_jacobian_from_internal_by_fd (Vector< double > &residuals, DenseMatrix< double > &jacobian, const bool &fd_all_data=false)
 
void fill_in_jacobian_from_internal_by_fd (DenseMatrix< double > &jacobian, const bool &fd_all_data=false)
 
void fill_in_jacobian_from_external_by_fd (Vector< double > &residuals, DenseMatrix< double > &jacobian, const bool &fd_all_data=false)
 
void fill_in_jacobian_from_external_by_fd (DenseMatrix< double > &jacobian, const bool &fd_all_data=false)
 
virtual void update_before_internal_fd ()
 
virtual void reset_after_internal_fd ()
 
virtual void update_in_internal_fd (const unsigned &i)
 
virtual void reset_in_internal_fd (const unsigned &i)
 
virtual void update_before_external_fd ()
 
virtual void reset_after_external_fd ()
 
virtual void update_in_external_fd (const unsigned &i)
 
virtual void reset_in_external_fd (const unsigned &i)
 
virtual void fill_in_contribution_to_mass_matrix (Vector< double > &residuals, DenseMatrix< double > &mass_matrix)
 
virtual void fill_in_contribution_to_dresiduals_dparameter (double *const &parameter_pt, Vector< double > &dres_dparam)
 
virtual void fill_in_contribution_to_djacobian_dparameter (double *const &parameter_pt, Vector< double > &dres_dparam, DenseMatrix< double > &djac_dparam)
 
virtual void fill_in_contribution_to_djacobian_and_dmass_matrix_dparameter (double *const &parameter_pt, Vector< double > &dres_dparam, DenseMatrix< double > &djac_dparam, DenseMatrix< double > &dmass_matrix_dparam)
 
virtual void fill_in_contribution_to_hessian_vector_products (Vector< double > const &Y, DenseMatrix< double > const &C, DenseMatrix< double > &product)
 
virtual void fill_in_contribution_to_inner_products (Vector< std::pair< unsigned, unsigned >> const &history_index, Vector< double > &inner_product)
 
virtual void fill_in_contribution_to_inner_product_vectors (Vector< unsigned > const &history_index, Vector< Vector< double >> &inner_product_vector)
 
- Protected Member Functions inherited from oomph::RefineableSolidElement
void assemble_local_to_lagrangian_jacobian (const DShape &dpsids, DenseMatrix< double > &jacobian) const
 
void assemble_local_to_lagrangian_jacobian2 (const DShape &d2psids, DenseMatrix< double > &jacobian2) const
 
double local_to_lagrangian_mapping_diagonal (const DShape &dpsids, DenseMatrix< double > &jacobian, DenseMatrix< double > &inverse_jacobian) const
 
- Protected Member Functions inherited from oomph::RefineableElement
void assemble_local_to_eulerian_jacobian (const DShape &dpsids, DenseMatrix< double > &jacobian) const
 
void assemble_local_to_eulerian_jacobian2 (const DShape &d2psids, DenseMatrix< double > &jacobian2) const
 
void assemble_eulerian_base_vectors (const DShape &dpsids, DenseMatrix< double > &interpolated_G) const
 
double local_to_eulerian_mapping_diagonal (const DShape &dpsids, DenseMatrix< double > &jacobian, DenseMatrix< double > &inverse_jacobian) const
 
void assign_hanging_local_eqn_numbers (const bool &store_local_dof_pt)
 Assign the local equation numbers for hanging node variables. More...
 
virtual void fill_in_jacobian_from_nodal_by_fd (Vector< double > &residuals, DenseMatrix< double > &jacobian)
 
- Static Protected Member Functions inherited from oomph::RefineableElement
static void check_value_id (const int &n_continuously_interpolated_values, const int &value_id)
 
- Protected Attributes inherited from oomph::PVDEquationsWithPressure< DIM >
bool Incompressible
 Boolean to determine whether the solid is incompressible or not. More...
 
- Protected Attributes inherited from oomph::PVDEquationsBase< DIM >
IsotropicGrowthFctPt Isotropic_growth_fct_pt
 Pointer to isotropic growth function. More...
 
PrestressFctPt Prestress_fct_pt
 Pointer to prestress function. More...
 
ConstitutiveLaw * Constitutive_law_pt
 Pointer to the constitutive law. More...
 
double * Lambda_sq_pt
 Timescale ratio (non-dim. density) More...
 
bool Unsteady
 Flag that switches inertia on/off. More...
 
BodyForceFctPt Body_force_fct_pt
 Pointer to body force function. More...
 
bool Evaluate_jacobian_by_fd
 Use FD to evaluate Jacobian. More...
 
- Protected Attributes inherited from oomph::SolidFiniteElement
MacroElement * Undeformed_macro_elem_pt
 Pointer to the element's "undeformed" macro element (NULL by default) More...
 
SolidInitialCondition * Solid_ic_pt
 Pointer to object that specifies the initial condition. More...
 
bool Solve_for_consistent_newmark_accel_flag
 
- Protected Attributes inherited from oomph::FiniteElement
MacroElement * Macro_elem_pt
 Pointer to the element's macro element (NULL by default) More...
 
- Protected Attributes inherited from oomph::GeomObject
unsigned NLagrangian
 Number of Lagrangian (intrinsic) coordinates. More...
 
unsigned Ndim
 Number of Eulerian coordinates. More...
 
TimeStepper * Geom_object_time_stepper_pt
 
- Protected Attributes inherited from oomph::RefineableSolidElement
bool Use_undeformed_macro_element_for_new_lagrangian_coords
 
- Protected Attributes inherited from oomph::RefineableElement
Tree * Tree_pt
 A pointer to a general tree object. More...
 
unsigned Refine_level
 Refinement level. More...
 
bool To_be_refined
 Flag for refinement. More...
 
bool Refinement_is_enabled
 Flag to indicate suppression of any refinement. More...
 
bool Sons_to_be_unrefined
 Flag for unrefinement. More...
 
long Number
 Global element number – for plotting/validation purposes. More...
 
- Static Protected Attributes inherited from oomph::PVDEquationsBase< DIM >
static double Default_lambda_sq_value = 1.0
 Static default value for timescale ratio (1.0 – for natural scaling) More...
 
- Static Protected Attributes inherited from oomph::FiniteElement
static const unsigned Default_Initial_Nvalue = 0
 Default value for the number of values at a node. More...
 
static const double Node_location_tolerance = 1.0e-14
 
static const unsigned N2deriv [] = {0, 1, 3, 6}
 
- Static Protected Attributes inherited from oomph::GeneralisedElement
static DenseMatrix< double > Dummy_matrix
 
static std::deque< double * > Dof_pt_deque
 
- Static Protected Attributes inherited from oomph::RefineableElement
static double Max_integrity_tolerance = 1.0e-8
 Max. allowed discrepancy in element integrity check. More...
 

Detailed Description

template<unsigned DIM>
class oomph::RefineablePVDEquationsWithPressure< DIM >

Class for Refineable solid mechanics elements in near-incompressible/ incompressible formulation, so a pressure is included! In this case, the pressure interpolation is discontinuous, a la Crouzeix Raviart

Constructor & Destructor Documentation

◆ RefineablePVDEquationsWithPressure()

template<unsigned DIM>
oomph::RefineablePVDEquationsWithPressure< DIM >::RefineablePVDEquationsWithPressure ( )
inline

Constructor:

288  : PVDEquationsWithPressure<DIM>(),
289  RefineableElement(),
290  RefineableSolidElement(),
291  ElementWithZ2ErrorEstimator()
292  {
293  }
oomph::ElementWithZ2ErrorEstimator::ElementWithZ2ErrorEstimator
ElementWithZ2ErrorEstimator()
Default empty constructor.
Definition: error_estimator.h:82
oomph::RefineableElement::RefineableElement
RefineableElement()
Definition: refineable_elements.h:188
oomph::RefineableSolidElement::RefineableSolidElement
RefineableSolidElement()
Constructor.
Definition: refineable_elements.h:928

Member Function Documentation

◆ fill_in_generic_residual_contribution_pvd_with_pressure()

template<unsigned DIM>
void oomph::RefineablePVDEquationsWithPressure< DIM >::fill_in_generic_residual_contribution_pvd_with_pressure ( Vector< double > &  residuals,
DenseMatrix< double > &  jacobian,
DenseMatrix< double > &  mass_matrix,
const unsigned &  flag 
)
virtual

Add element's contribution to elemental residual vector and/or Jacobian matrix flag=1: compute both flag=0: compute only residual vector

Fill in element's contribution to the elemental residual vector and/or Jacobian matrix. flag=0: compute only residual vector flag=1: compute both, fully analytically flag=2: compute both, using FD for the derivatives w.r.t. to the discrete displacment dofs. flag=3: compute residuals, jacobian (full analytic) and mass matrix flag=4: compute residuals, jacobian (FD for derivatives w.r.t. displacements) and mass matrix

Reimplemented from oomph::PVDEquationsWithPressure< DIM >.

681  {
682 #ifdef PARANOID
683  // Check if the constitutive equation requires the explicit imposition of an
684  // incompressibility constraint
685  if (this->Constitutive_law_pt->requires_incompressibility_constraint() &&
686  (!this->Incompressible))
687  {
688  throw OomphLibError("The constitutive law requires the use of the "
689  "incompressible formulation by setting the element's "
690  "member function set_incompressible()",
691  OOMPH_CURRENT_FUNCTION,
692  OOMPH_EXCEPTION_LOCATION);
693  }
694 #endif
695 
696 
697  // Simply set up initial condition?
698  if (Solid_ic_pt != 0)
699  {
700  get_residuals_for_solid_ic(residuals);
701  return;
702  }
703 
704  // Find out how many nodes there are
705  const unsigned n_node = nnode();
706 
707  // Find out how many position types of dof there are
708  const unsigned n_position_type = this->nnodal_position_type();
709 
710  // Find out how many pressure dofs there are
711  const unsigned n_solid_pres = this->npres_solid();
712 
713  // Find out the index of the solid dof
714  const int solid_p_index = this->solid_p_nodal_index();
715 
716  // Local array of booleans that is true if the l-th pressure value is
717  // hanging This is an optimization because it avoids repeated virtual
718  // function calls
719  bool solid_pressure_dof_is_hanging[n_solid_pres];
720 
721  // If the solid pressure is stored at a node
722  if (solid_p_index >= 0)
723  {
724  // Read out whether the solid pressure is hanging
725  for (unsigned l = 0; l < n_solid_pres; ++l)
726  {
727  solid_pressure_dof_is_hanging[l] =
728  solid_pressure_node_pt(l)->is_hanging(solid_p_index);
729  }
730  }
731  // Otherwise the pressure is not stored at a node and so
732  // it cannot hang
733  else
734  {
735  for (unsigned l = 0; l < n_solid_pres; ++l)
736  {
737  solid_pressure_dof_is_hanging[l] = false;
738  }
739  }
740 
741  // Integer for storage of local equation and unknown numbers
742  int local_eqn = 0, local_unknown = 0;
743 
744  // Timescale ratio (non-dim density)
745  double lambda_sq = this->lambda_sq();
746 
747 
748  // Time factor
749  double time_factor = 0.0;
750  if (lambda_sq > 0)
751  {
752  time_factor = this->node_pt(0)->position_time_stepper_pt()->weight(2, 0);
753  }
754 
755 
756  // Set up memory for the shape functions
757  Shape psi(n_node, n_position_type);
758  DShape dpsidxi(n_node, n_position_type, DIM);
759 
760  // Set up memory for the pressure shape functions
761  Shape psisp(n_solid_pres);
762 
763  // Set the value of n_intpt
764  const unsigned n_intpt = integral_pt()->nweight();
765 
766  // Set the vector to hold the local coordinates in the element
767  Vector<double> s(DIM);
768 
769  // Loop over the integration points
770  for (unsigned ipt = 0; ipt < n_intpt; ipt++)
771  {
772  // Assign the values of s
773  for (unsigned i = 0; i < DIM; ++i)
774  {
775  s[i] = integral_pt()->knot(ipt, i);
776  }
777 
778  // Get the integral weight
779  double w = integral_pt()->weight(ipt);
780 
781  // Call the derivatives of the shape functions
782  double J = dshape_lagrangian_at_knot(ipt, psi, dpsidxi);
783 
784  // Call the pressure shape functions
785  this->solid_pshape_at_knot(ipt, psisp);
786 
787  // Storage for Lagrangian coordinates (initialised to zero)
788  Vector<double> interpolated_xi(DIM, 0.0);
789 
790  // Deformed tangent vectors
791  DenseMatrix<double> interpolated_G(DIM, DIM, 0.0);
792 
793  // Setup memory for accelerations
794  Vector<double> accel(DIM, 0.0);
795 
796  // Calculate displacements and derivatives and lagrangian coordinates
797  for (unsigned l = 0; l < n_node; l++)
798  {
799  // Loop over positional dofs
800  for (unsigned k = 0; k < n_position_type; k++)
801  {
802  double psi_ = psi(l, k);
803  // Loop over displacement components (deformed position)
804  for (unsigned i = 0; i < DIM; i++)
805  {
806  // Calculate the lagrangian coordinates and the accelerations
807  interpolated_xi[i] += lagrangian_position_gen(l, k, i) * psi_;
808 
809  // Only compute accelerations if inertia is switched on
810  // otherwise the timestepper might not be able to
811  // work out dx_gen_dt(2,...)
812  if ((lambda_sq > 0.0) && (this->Unsteady))
813  {
814  accel[i] += dnodal_position_gen_dt(2, l, k, i) * psi_;
815  }
816 
817  // Loop over derivative directions
818  for (unsigned j = 0; j < DIM; j++)
819  {
820  interpolated_G(j, i) +=
821  nodal_position_gen(l, k, i) * dpsidxi(l, k, j);
822  }
823  }
824  }
825  }
826 
827  // Get isotropic growth factor
828  double gamma = 1.0;
829  this->get_isotropic_growth(ipt, s, interpolated_xi, gamma);
830 
831  // Get body force at current time
832  Vector<double> b(DIM);
833  this->body_force(interpolated_xi, b);
834 
835  // We use Cartesian coordinates as the reference coordinate
836  // system. In this case the undeformed metric tensor is always
837  // the identity matrix -- stretched by the isotropic growth
838  double diag_entry = pow(gamma, 2.0 / double(DIM));
839  DenseMatrix<double> g(DIM);
840  for (unsigned i = 0; i < DIM; i++)
841  {
842  for (unsigned j = 0; j < DIM; j++)
843  {
844  if (i == j)
845  {
846  g(i, j) = diag_entry;
847  }
848  else
849  {
850  g(i, j) = 0.0;
851  }
852  }
853  }
854 
855  // Premultiply the undeformed volume ratio (from the isotropic
856  // growth), the weights and the Jacobian
857  double W = gamma * w * J;
858 
859  // Calculate the interpolated solid pressure
860  double interpolated_solid_p = 0.0;
861  for (unsigned l = 0; l < n_solid_pres; l++)
862  {
863  interpolated_solid_p += this->solid_p(l) * psisp[l];
864  }
865 
866 
867  // Declare and calculate the deformed metric tensor
868  DenseMatrix<double> G(DIM);
869 
870  // Assign values of G
871  for (unsigned i = 0; i < DIM; i++)
872  {
873  // Do upper half of matrix
874  for (unsigned j = i; j < DIM; j++)
875  {
876  // Initialise G(i,j) to zero
877  G(i, j) = 0.0;
878  // Now calculate the dot product
879  for (unsigned k = 0; k < DIM; k++)
880  {
881  G(i, j) += interpolated_G(i, k) * interpolated_G(j, k);
882  }
883  }
884  // Matrix is symmetric so just copy lower half
885  for (unsigned j = 0; j < i; j++)
886  {
887  G(i, j) = G(j, i);
888  }
889  }
890 
891  // Now calculate the deviatoric stress and all pressure-related
892  // quantitites
893  DenseMatrix<double> sigma(DIM, DIM), sigma_dev(DIM, DIM), Gup(DIM, DIM);
894  double detG = 0.0;
895  double gen_dil = 0.0;
896  double inv_kappa = 0.0;
897 
898  // Get stress derivative by FD only needed for Jacobian
899 
900  // Stress etc derivatives
901  RankFourTensor<double> d_stress_dG(DIM, DIM, DIM, DIM, 0.0);
902  // RankFourTensor<double> d_Gup_dG(DIM,DIM,DIM,DIM,0.0);
903  DenseMatrix<double> d_detG_dG(DIM, DIM, 0.0);
904  DenseMatrix<double> d_gen_dil_dG(DIM, DIM, 0.0);
905 
906  // Derivative of metric tensor w.r.t. to nodal coords
907  RankFiveTensor<double> d_G_dX(
908  n_node, n_position_type, DIM, DIM, DIM, 0.0);
909 
910  // Get Jacobian too?
911  if ((flag == 1) || (flag == 3))
912  {
913  // Derivative of metric tensor w.r.t. to discrete positional dofs
914  // NOTE: Since G is symmetric we only compute the upper triangle
915  // and DO NOT copy the entries across. Subsequent computations
916  // must (and, in fact, do) therefore only operate with upper
917  // triangular entries
918  for (unsigned ll = 0; ll < n_node; ll++)
919  {
920  for (unsigned kk = 0; kk < n_position_type; kk++)
921  {
922  for (unsigned ii = 0; ii < DIM; ii++)
923  {
924  for (unsigned aa = 0; aa < DIM; aa++)
925  {
926  for (unsigned bb = aa; bb < DIM; bb++)
927  {
928  d_G_dX(ll, kk, ii, aa, bb) =
929  interpolated_G(aa, ii) * dpsidxi(ll, kk, bb) +
930  interpolated_G(bb, ii) * dpsidxi(ll, kk, aa);
931  }
932  }
933  }
934  }
935  }
936  }
937 
938 
939  // Incompressible: Compute the deviatoric part of the stress tensor, the
940  // contravariant deformed metric tensor and the determinant
941  // of the deformed covariant metric tensor.
942  if (this->Incompressible)
943  {
944  this->get_stress(g, G, sigma_dev, Gup, detG);
945 
946  // Get full stress
947  for (unsigned a = 0; a < DIM; a++)
948  {
949  for (unsigned b = 0; b < DIM; b++)
950  {
951  sigma(a, b) = sigma_dev(a, b) - interpolated_solid_p * Gup(a, b);
952  }
953  }
954 
955  // Get Jacobian too?
956  if ((flag == 1) || (flag == 3))
957  {
958  // Get the "upper triangular" entries of the
959  // derivatives of the stress tensor with
960  // respect to G
961  this->get_d_stress_dG_upper(
962  g, G, sigma, detG, interpolated_solid_p, d_stress_dG, d_detG_dG);
963  }
964  }
965  // Nearly incompressible: Compute the deviatoric part of the
966  // stress tensor, the contravariant deformed metric tensor,
967  // the generalised dilatation and the inverse bulk modulus.
968  else
969  {
970  this->get_stress(g, G, sigma_dev, Gup, gen_dil, inv_kappa);
971 
972  // Get full stress
973  for (unsigned a = 0; a < DIM; a++)
974  {
975  for (unsigned b = 0; b < DIM; b++)
976  {
977  sigma(a, b) = sigma_dev(a, b) - interpolated_solid_p * Gup(a, b);
978  }
979  }
980 
981  // Get Jacobian too?
982  if ((flag == 1) || (flag == 3))
983  {
984  // Get the "upper triangular" entries of the derivatives
985  // of the stress tensor with
986  // respect to G
987  this->get_d_stress_dG_upper(g,
988  G,
989  sigma,
990  gen_dil,
991  inv_kappa,
992  interpolated_solid_p,
993  d_stress_dG,
994  d_gen_dil_dG);
995  }
996  }
997 
998  // Add pre-stress
999  for (unsigned i = 0; i < DIM; i++)
1000  {
1001  for (unsigned j = 0; j < DIM; j++)
1002  {
1003  sigma(i, j) += this->prestress(i, j, interpolated_xi);
1004  }
1005  }
1006 
1007  //=====EQUATIONS OF ELASTICITY FROM PRINCIPLE OF VIRTUAL
1008  // DISPLACEMENTS========
1009 
1010  unsigned n_master = 1;
1011  double hang_weight = 1.0;
1012 
1013  // Loop over the test functions, nodes of the element
1014  for (unsigned l = 0; l < n_node; l++)
1015  {
1016  // Get pointer to local node l
1017  Node* local_node_pt = node_pt(l);
1018 
1019  // Cache hang status
1020  bool is_hanging = local_node_pt->is_hanging();
1021 
1022  // If the node is a hanging node
1023  if (is_hanging)
1024  {
1025  n_master = local_node_pt->hanging_pt()->nmaster();
1026  }
1027  // Otherwise the node is its own master
1028  else
1029  {
1030  n_master = 1;
1031  }
1032 
1033 
1034  // Storage for local equation numbers at node indexed by
1035  // type and direction
1036  DenseMatrix<int> position_local_eqn_at_node(n_position_type, DIM);
1037 
1038  // Loop over the master nodes
1039  for (unsigned m = 0; m < n_master; m++)
1040  {
1041  if (is_hanging)
1042  {
1043  // Find the equation numbers
1044  position_local_eqn_at_node = local_position_hang_eqn(
1045  local_node_pt->hanging_pt()->master_node_pt(m));
1046 
1047  // Find the hanging node weight
1048  hang_weight = local_node_pt->hanging_pt()->master_weight(m);
1049  }
1050  else
1051  {
1052  // Loop of types of dofs
1053  for (unsigned k = 0; k < n_position_type; k++)
1054  {
1055  // Loop over the displacement components
1056  for (unsigned i = 0; i < DIM; i++)
1057  {
1058  position_local_eqn_at_node(k, i) = position_local_eqn(l, k, i);
1059  }
1060  }
1061 
1062  // Hang weight is one
1063  hang_weight = 1.0;
1064  }
1065 
1066 
1067  // Loop of types of dofs
1068  for (unsigned k = 0; k < n_position_type; k++)
1069  {
1070  // Offset for faster access
1071  const unsigned offset5 = dpsidxi.offset(l, k);
1072 
1073  // Loop over the displacement components
1074  for (unsigned i = 0; i < DIM; i++)
1075  {
1076  local_eqn = position_local_eqn_at_node(k, i);
1077 
1078  /*IF it's not a boundary condition*/
1079  if (local_eqn >= 0)
1080  {
1081  // Initialise contribution to zero
1082  double sum = 0.0;
1083 
1084  // Acceleration and body force
1085  sum += (lambda_sq * accel[i] - b[i]) * psi(l, k);
1086 
1087  // Stress term
1088  for (unsigned a = 0; a < DIM; a++)
1089  {
1090  unsigned count = offset5;
1091  for (unsigned b = 0; b < DIM; b++)
1092  {
1093  // Add the stress terms to the residuals
1094  sum += sigma(a, b) * interpolated_G(a, i) *
1095  dpsidxi.raw_direct_access(count);
1096  ++count;
1097  }
1098  }
1099  residuals[local_eqn] += W * sum * hang_weight;
1100 
1101 
1102  // Get the mass matrix
1103  // This involves another loop over the points
1104  // because the jacobian may NOT be being calculated analytically
1105  // It could be made more efficient in th event that
1106  // we eventually decide not (never) to
1107  // use finite differences.
1108  if (flag > 2)
1109  {
1110  // Default setting for non-hanging node
1111  unsigned nn_master = 1;
1112  double hhang_weight = 1.0;
1113 
1114  // Loop over the nodes of the element again
1115  for (unsigned ll = 0; ll < n_node; ll++)
1116  {
1117  // Get pointer to local node ll
1118  Node* llocal_node_pt = node_pt(ll);
1119 
1120  // Cache hang status
1121  bool iis_hanging = llocal_node_pt->is_hanging();
1122 
1123  // If the node is a hanging node
1124  if (iis_hanging)
1125  {
1126  nn_master = llocal_node_pt->hanging_pt()->nmaster();
1127  }
1128  // Otherwise the node is its own master
1129  else
1130  {
1131  nn_master = 1;
1132  }
1133 
1134 
1135  // Storage for local unknown numbers at node indexed by
1136  // type and direction
1137  DenseMatrix<int> position_local_unk_at_node(n_position_type,
1138  DIM);
1139 
1140  // Loop over the master nodes
1141  for (unsigned mm = 0; mm < nn_master; mm++)
1142  {
1143  if (iis_hanging)
1144  {
1145  // Find the unknown numbers
1146  position_local_unk_at_node = local_position_hang_eqn(
1147  llocal_node_pt->hanging_pt()->master_node_pt(mm));
1148 
1149  // Find the hanging node weight
1150  hhang_weight =
1151  llocal_node_pt->hanging_pt()->master_weight(mm);
1152  }
1153  else
1154  {
1155  // Loop of types of dofs
1156  for (unsigned kk = 0; kk < n_position_type; kk++)
1157  {
1158  // Loop over the displacement components
1159  for (unsigned ii = 0; ii < DIM; ii++)
1160  {
1161  position_local_unk_at_node(kk, ii) =
1162  position_local_eqn(ll, kk, ii);
1163  }
1164  }
1165 
1166  // Hang weight is one
1167  hhang_weight = 1.0;
1168  }
1169 
1170 
1171  // Loop of types of dofs again
1172  for (unsigned kk = 0; kk < n_position_type; kk++)
1173  {
1174  // Get the number of the unknown
1175  int local_unknown = position_local_unk_at_node(kk, i);
1176 
1177  /*IF it's not a boundary condition*/
1178  if (local_unknown >= 0)
1179  {
1180  mass_matrix(local_eqn, local_unknown) +=
1181  lambda_sq * psi(l, k) * psi(ll, kk) * hang_weight *
1182  hhang_weight * W;
1183  }
1184  }
1185  }
1186  }
1187  }
1188 
1189 
1190  // Get Jacobian too?
1191  if ((flag == 1) || (flag == 3))
1192  {
1193  // Offset for faster access in general stress loop
1194  const unsigned offset1 = d_G_dX.offset(l, k, i);
1195 
1196  // Default setting for non-hanging node
1197  unsigned nn_master = 1;
1198  double hhang_weight = 1.0;
1199 
1200  // Loop over the nodes of the element again
1201  for (unsigned ll = 0; ll < n_node; ll++)
1202  {
1203  // Get pointer to local node ll
1204  Node* llocal_node_pt = node_pt(ll);
1205 
1206  // Cache hang status
1207  bool iis_hanging = llocal_node_pt->is_hanging();
1208 
1209  // If the node is a hanging node
1210  if (iis_hanging)
1211  {
1212  nn_master = llocal_node_pt->hanging_pt()->nmaster();
1213  }
1214  // Otherwise the node is its own master
1215  else
1216  {
1217  nn_master = 1;
1218  }
1219 
1220 
1221  // Storage for local unknown numbers at node indexed by
1222  // type and direction
1223  DenseMatrix<int> position_local_unk_at_node(n_position_type,
1224  DIM);
1225 
1226  // Loop over the master nodes
1227  for (unsigned mm = 0; mm < nn_master; mm++)
1228  {
1229  if (iis_hanging)
1230  {
1231  // Find the unknown numbers
1232  position_local_unk_at_node = local_position_hang_eqn(
1233  llocal_node_pt->hanging_pt()->master_node_pt(mm));
1234 
1235  // Find the hanging node weight
1236  hhang_weight =
1237  llocal_node_pt->hanging_pt()->master_weight(mm);
1238  }
1239  else
1240  {
1241  // Loop of types of dofs
1242  for (unsigned kk = 0; kk < n_position_type; kk++)
1243  {
1244  // Loop over the displacement components
1245  for (unsigned ii = 0; ii < DIM; ii++)
1246  {
1247  position_local_unk_at_node(kk, ii) =
1248  position_local_eqn(ll, kk, ii);
1249  }
1250  }
1251 
1252  // Hang weight is one
1253  hhang_weight = 1.0;
1254  }
1255 
1256 
1257  // Loop of types of dofs again
1258  for (unsigned kk = 0; kk < n_position_type; kk++)
1259  {
1260  // Loop over the displacement components again
1261  for (unsigned ii = 0; ii < DIM; ii++)
1262  {
1263  // Get the number of the unknown
1264  int local_unknown =
1265  position_local_unk_at_node(kk, ii);
1266 
1267  /*IF it's not a boundary condition*/
1268  if (local_unknown >= 0)
1269  {
1270  // Offset for faster access in general stress loop
1271  const unsigned offset2 = d_G_dX.offset(ll, kk, ii);
1272  const unsigned offset4 = dpsidxi.offset(ll, kk);
1273 
1274 
1275  // General stress term
1276  //--------------------
1277  double sum = 0.0;
1278  unsigned count1 = offset1;
1279  for (unsigned a = 0; a < DIM; a++)
1280  {
1281  // Bump up direct access because we're only
1282  // accessing upper triangle
1283  count1 += a;
1284  for (unsigned b = a; b < DIM; b++)
1285  {
1286  double factor =
1287  d_G_dX.raw_direct_access(count1);
1288  if (a == b) factor *= 0.5;
1289 
1290  // Offset for faster access
1291  unsigned offset3 = d_stress_dG.offset(a, b);
1292  unsigned count2 = offset2;
1293  unsigned count3 = offset3;
1294 
1295  for (unsigned aa = 0; aa < DIM; aa++)
1296  {
1297  // Bump up direct access because we're only
1298  // accessing upper triangle
1299  count2 += aa;
1300  count3 += aa;
1301 
1302  // Only upper half of derivatives w.r.t.
1303  // symm tensor
1304  for (unsigned bb = aa; bb < DIM; bb++)
1305  {
1306  sum +=
1307  factor *
1308  d_stress_dG.raw_direct_access(count3) *
1309  d_G_dX.raw_direct_access(count2);
1310  ++count2;
1311  ++count3;
1312  }
1313  }
1314  ++count1;
1315  }
1316  }
1317 
1318  // Multiply by weight and add contribution
1319  // (Add directly because this bit is nonsymmetric)
1320  jacobian(local_eqn, local_unknown) +=
1321  sum * W * hang_weight * hhang_weight;
1322 
1323  // Only upper triangle (no separate test for bc as
1324  // local_eqn is already nonnegative)
1325  if ((i == ii) && (local_unknown >= local_eqn))
1326  {
1327  // Initialise contribution
1328  double sum = 0.0;
1329 
1330  // Inertia term
1331  sum += lambda_sq * time_factor * psi(ll, kk) *
1332  psi(l, k);
1333 
1334  // Stress term
1335  unsigned count4 = offset4;
1336  for (unsigned a = 0; a < DIM; a++)
1337  {
1338  // Cache term
1339  const double factor =
1340  dpsidxi.raw_direct_access(count4); // ll ,kk
1341  ++count4;
1342 
1343  unsigned count5 = offset5;
1344  for (unsigned b = 0; b < DIM; b++)
1345  {
1346  sum +=
1347  sigma(a, b) * factor *
1348  dpsidxi.raw_direct_access(count5); // l ,k
1349  ++count5;
1350  }
1351  }
1352 
1353  // Multiply by weights to form contribution
1354  double sym_entry =
1355  sum * W * hang_weight * hhang_weight;
1356  // Add contribution to jacobian
1357  jacobian(local_eqn, local_unknown) += sym_entry;
1358  // Add to lower triangular entries
1359  if (local_eqn != local_unknown)
1360  {
1361  jacobian(local_unknown, local_eqn) += sym_entry;
1362  }
1363  }
1364  } // End of if not boundary condition
1365  }
1366  }
1367  }
1368  }
1369  }
1370 
1371  // Can add in the pressure jacobian terms
1372  if (flag > 0)
1373  {
1374  // Loop over the pressure nodes
1375  for (unsigned l2 = 0; l2 < n_solid_pres; l2++)
1376  {
1377  unsigned n_master2 = 1;
1378  double hang_weight2 = 1.0;
1379  HangInfo* hang_info2_pt = 0;
1380 
1381  bool is_hanging2 = solid_pressure_dof_is_hanging[l2];
1382  if (is_hanging2)
1383  {
1384  // Get the HangInfo object associated with the
1385  // hanging solid pressure
1386  hang_info2_pt =
1387  solid_pressure_node_pt(l2)->hanging_pt(solid_p_index);
1388 
1389  n_master2 = hang_info2_pt->nmaster();
1390  }
1391  else
1392  {
1393  n_master2 = 1;
1394  }
1395 
1396  // Loop over all the master nodes
1397  for (unsigned m2 = 0; m2 < n_master2; m2++)
1398  {
1399  if (is_hanging2)
1400  {
1401  // Get the equation numbers at the master node
1402  local_unknown = local_hang_eqn(
1403  hang_info2_pt->master_node_pt(m2), solid_p_index);
1404 
1405  // Find the hanging node weight at the node
1406  hang_weight2 = hang_info2_pt->master_weight(m2);
1407  }
1408  else
1409  {
1410  local_unknown = this->solid_p_local_eqn(l2);
1411  hang_weight2 = 1.0;
1412  }
1413 
1414  // If it's not a boundary condition
1415  if (local_unknown >= 0)
1416  {
1417  // Add the pressure terms to the jacobian
1418  for (unsigned a = 0; a < DIM; a++)
1419  {
1420  for (unsigned b = 0; b < DIM; b++)
1421  {
1422  jacobian(local_eqn, local_unknown) -=
1423  psisp[l2] * Gup(a, b) * interpolated_G(a, i) *
1424  dpsidxi(l, k, b) * W * hang_weight * hang_weight2;
1425  }
1426  }
1427  }
1428  } // End of loop over master nodes
1429  } // End of loop over pressure dofs
1430  } // End of Jacobian terms
1431 
1432  } // End of if not boundary condition
1433  }
1434  }
1435  } // End of loop of over master nodes
1436 
1437  } // End of loop over nodes
1438 
1439  //==============CONSTRAINT EQUATIONS FOR PRESSURE=====================
1440 
1441  // Now loop over the pressure degrees of freedom
1442  for (unsigned l = 0; l < n_solid_pres; l++)
1443  {
1444  bool is_hanging = solid_pressure_dof_is_hanging[l];
1445 
1446  unsigned n_master = 1;
1447  double hang_weight = 1.0;
1448  HangInfo* hang_info_pt = 0;
1449 
1450  // If the node is a hanging node
1451  if (is_hanging)
1452  {
1453  // Get a pointer to the HangInfo object associated with the
1454  // solid pressure (stored at solid_p_index)
1455  hang_info_pt = solid_pressure_node_pt(l)->hanging_pt(solid_p_index);
1456 
1457  // Number of master nodes
1458  n_master = hang_info_pt->nmaster();
1459  }
1460  // Otherwise the node is its own master
1461  else
1462  {
1463  n_master = 1;
1464  }
1465 
1466  // Loop over all the master nodes
1467  // Note that the pressure is stored at the inded solid_p_index
1468  for (unsigned m = 0; m < n_master; m++)
1469  {
1470  if (is_hanging)
1471  {
1472  // Get the equation numbers at the master node
1473  local_eqn =
1474  local_hang_eqn(hang_info_pt->master_node_pt(m), solid_p_index);
1475 
1476  // Find the hanging node weight at the node
1477  hang_weight = hang_info_pt->master_weight(m);
1478  }
1479  else
1480  {
1481  local_eqn = this->solid_p_local_eqn(l);
1482  }
1483 
1484  // Pinned (unlikely, actually) or real dof?
1485  if (local_eqn >= 0)
1486  {
1487  // For true incompressibility we need to conserve volume
1488  // so the determinant of the deformed metric tensor
1489  // needs to be equal to that of the undeformed one, which
1490  // is equal to the volumetric growth factor
1491  if (this->Incompressible)
1492  {
1493  residuals[local_eqn] +=
1494  (detG - gamma) * psisp[l] * W * hang_weight;
1495 
1496  // Get Jacobian too?
1497  if ((flag == 1) || (flag == 3))
1498  {
1499  // Default setting for non-hanging node
1500  unsigned nn_master = 1;
1501  double hhang_weight = 1.0;
1502 
1503  // Loop over the nodes of the element again
1504  for (unsigned ll = 0; ll < n_node; ll++)
1505  {
1506  // Get pointer to local node ll
1507  Node* llocal_node_pt = node_pt(ll);
1508 
1509  // Cache hang status
1510  bool iis_hanging = llocal_node_pt->is_hanging();
1511 
1512  // If the node is a hanging node
1513  if (iis_hanging)
1514  {
1515  nn_master = llocal_node_pt->hanging_pt()->nmaster();
1516  }
1517  // Otherwise the node is its own master
1518  else
1519  {
1520  nn_master = 1;
1521  }
1522 
1523  // Storage for local unknown numbers at node indexed by
1524  // type and direction
1525  DenseMatrix<int> position_local_unk_at_node(n_position_type,
1526  DIM);
1527 
1528  // Loop over the master nodes
1529  for (unsigned mm = 0; mm < nn_master; mm++)
1530  {
1531  if (iis_hanging)
1532  {
1533  // Find the unknown numbers
1534  position_local_unk_at_node = local_position_hang_eqn(
1535  llocal_node_pt->hanging_pt()->master_node_pt(mm));
1536 
1537  // Find the hanging node weight
1538  hhang_weight =
1539  llocal_node_pt->hanging_pt()->master_weight(mm);
1540  }
1541  else
1542  {
1543  // Loop of types of dofs
1544  for (unsigned kk = 0; kk < n_position_type; kk++)
1545  {
1546  // Loop over the displacement components
1547  for (unsigned ii = 0; ii < DIM; ii++)
1548  {
1549  position_local_unk_at_node(kk, ii) =
1550  position_local_eqn(ll, kk, ii);
1551  }
1552  }
1553 
1554  // Hang weight is one
1555  hhang_weight = 1.0;
1556  }
1557 
1558 
1559  // Loop of types of dofs again
1560  for (unsigned kk = 0; kk < n_position_type; kk++)
1561  {
1562  // Loop over the displacement components again
1563  for (unsigned ii = 0; ii < DIM; ii++)
1564  {
1565  // Get the number of the unknown
1566  int local_unknown = position_local_unk_at_node(kk, ii);
1567 
1568  /*IF it's not a boundary condition*/
1569  if (local_unknown >= 0)
1570  {
1571  // Offset for faster access
1572  const unsigned offset = d_G_dX.offset(ll, kk, ii);
1573 
1574  // General stress term
1575  double sum = 0.0;
1576  unsigned count = offset;
1577  for (unsigned aa = 0; aa < DIM; aa++)
1578  {
1579  // Bump up direct access because we're only
1580  // accessing upper triangle
1581  count += aa;
1582 
1583  // Only upper half
1584  for (unsigned bb = aa; bb < DIM; bb++)
1585  {
1586  sum += d_detG_dG(aa, bb) *
1587  d_G_dX.raw_direct_access(count) * psisp(l);
1588  ++count;
1589  }
1590  }
1591  jacobian(local_eqn, local_unknown) +=
1592  sum * W * hang_weight * hhang_weight;
1593  }
1594  }
1595  }
1596  }
1597  }
1598 
1599  // No Jacobian terms due to pressure since it does not feature
1600  // in the incompressibility constraint
1601  }
1602  }
1603  // Nearly incompressible: (Neg.) pressure given by product of
1604  // bulk modulus and generalised dilatation
1605  else
1606  {
1607  residuals[local_eqn] +=
1608  (inv_kappa * interpolated_solid_p + gen_dil) * psisp[l] * W *
1609  hang_weight;
1610 
1611  // Add in the jacobian terms
1612  if ((flag == 1) || (flag == 3))
1613  {
1614  // Default setting for non-hanging node
1615  unsigned nn_master = 1;
1616  double hhang_weight = 1.0;
1617 
1618  // Loop over the nodes of the element again
1619  for (unsigned ll = 0; ll < n_node; ll++)
1620  {
1621  // Get pointer to local node ll
1622  Node* llocal_node_pt = node_pt(ll);
1623 
1624  // Cache hang status
1625  bool iis_hanging = llocal_node_pt->is_hanging();
1626 
1627  // If the node is a hanging node
1628  if (iis_hanging)
1629  {
1630  nn_master = llocal_node_pt->hanging_pt()->nmaster();
1631  }
1632  // Otherwise the node is its own master
1633  else
1634  {
1635  nn_master = 1;
1636  }
1637 
1638 
1639  // Storage for local unknown numbers at node indexed by
1640  // type and direction
1641  DenseMatrix<int> position_local_unk_at_node(n_position_type,
1642  DIM);
1643 
1644  // Loop over the master nodes
1645  for (unsigned mm = 0; mm < nn_master; mm++)
1646  {
1647  if (iis_hanging)
1648  {
1649  // Find the unknown numbers
1650  position_local_unk_at_node = local_position_hang_eqn(
1651  llocal_node_pt->hanging_pt()->master_node_pt(mm));
1652 
1653  // Find the hanging node weight
1654  hhang_weight =
1655  llocal_node_pt->hanging_pt()->master_weight(mm);
1656  }
1657  else
1658  {
1659  // Loop of types of dofs
1660  for (unsigned kk = 0; kk < n_position_type; kk++)
1661  {
1662  // Loop over the displacement components
1663  for (unsigned ii = 0; ii < DIM; ii++)
1664  {
1665  position_local_unk_at_node(kk, ii) =
1666  position_local_eqn(ll, kk, ii);
1667  }
1668  }
1669 
1670  // Hang weight is one
1671  hhang_weight = 1.0;
1672  }
1673 
1674 
1675  // Loop of types of dofs again
1676  for (unsigned kk = 0; kk < n_position_type; kk++)
1677  {
1678  // Loop over the displacement components again
1679  for (unsigned ii = 0; ii < DIM; ii++)
1680  {
1681  // Get the number of the unknown
1682  int local_unknown = position_local_unk_at_node(kk, ii);
1683 
1684  /*IF it's not a boundary condition*/
1685  if (local_unknown >= 0)
1686  {
1687  // Offset for faster access
1688  const unsigned offset = d_G_dX.offset(ll, kk, ii);
1689 
1690  // General stress term
1691  double sum = 0.0;
1692  unsigned count = offset;
1693  for (unsigned aa = 0; aa < DIM; aa++)
1694  {
1695  // Bump up direct access because we're only
1696  // accessing upper triangle
1697  count += aa;
1698 
1699  // Only upper half
1700  for (unsigned bb = aa; bb < DIM; bb++)
1701  {
1702  sum += d_gen_dil_dG(aa, bb) *
1703  d_G_dX.raw_direct_access(count) * psisp(l);
1704  ++count;
1705  }
1706  }
1707  jacobian(local_eqn, local_unknown) +=
1708  sum * W * hang_weight * hhang_weight;
1709  }
1710  }
1711  }
1712  }
1713  }
1714  }
1715 
1716 
1717  // Add in the pressure jacobian terms
1718  if (flag > 0)
1719  {
1720  // Loop over the pressure nodes again
1721  for (unsigned l2 = 0; l2 < n_solid_pres; l2++)
1722  {
1723  bool is_hanging2 = solid_pressure_dof_is_hanging[l2];
1724 
1725  unsigned n_master2 = 1;
1726  double hang_weight2 = 1.0;
1727  HangInfo* hang_info2_pt = 0;
1728 
1729  if (is_hanging2)
1730  {
1731  // Get pointer to hang info object
1732  // Note that the pressure is stored at
1733  // the index solid_p_index
1734  hang_info2_pt =
1735  solid_pressure_node_pt(l2)->hanging_pt(solid_p_index);
1736 
1737  n_master2 = hang_info2_pt->nmaster();
1738  }
1739  else
1740  {
1741  n_master2 = 1;
1742  }
1743 
1744  // Loop over all the master nodes
1745  for (unsigned m2 = 0; m2 < n_master2; m2++)
1746  {
1747  if (is_hanging2)
1748  {
1749  // Get the equation numbers at the master node
1750  local_unknown = local_hang_eqn(
1751  hang_info2_pt->master_node_pt(m2), solid_p_index);
1752 
1753  // Find the hanging node weight at the node
1754  hang_weight2 = hang_info2_pt->master_weight(m2);
1755  }
1756  else
1757  {
1758  local_unknown = this->solid_p_local_eqn(l2);
1759  hang_weight2 = 1.0;
1760  }
1761 
1762  // If it's not a boundary condition
1763  if (local_unknown >= 0)
1764  {
1765  jacobian(local_eqn, local_unknown) +=
1766  inv_kappa * psisp[l2] * psisp[l] * W * hang_weight *
1767  hang_weight2;
1768  }
1769 
1770  } // End of loop over master nodes
1771  } // End of loop over pressure dofs
1772  } // End of pressure Jacobian
1773 
1774 
1775  } // End of nearly incompressible case
1776  } // End of if not boundary condition
1777  } // End of loop over master nodes
1778  } // End of loop over pressure dofs
1779  } // End of loop over integration points
1780  }
i
int i
Definition: BiCGSTAB_step_by_step.cpp:9
G
JacobiRotation< float > G
Definition: Jacobi_makeGivens.cpp:2
J
JacobiRotation< float > J
Definition: Jacobi_makeJacobi.cpp:3
w
RowVector3d w
Definition: Matrix_resize_int.cpp:3
m2
MatrixType m2(n_dims)
b
Scalar * b
Definition: benchVecAdd.cpp:17
oomph::ConstitutiveLaw::requires_incompressibility_constraint
virtual bool requires_incompressibility_constraint()=0
oomph::FiniteElement::node_pt
Node *& node_pt(const unsigned &n)
Return a pointer to the local node n.
Definition: elements.h:2175
oomph::FiniteElement::nnodal_position_type
unsigned nnodal_position_type() const
Definition: elements.h:2463
oomph::FiniteElement::dnodal_position_gen_dt
double dnodal_position_gen_dt(const unsigned &n, const unsigned &k, const unsigned &i) const
Definition: elements.h:2369
oomph::FiniteElement::nodal_position_gen
double nodal_position_gen(const unsigned &n, const unsigned &k, const unsigned &i) const
Definition: elements.h:2349
oomph::FiniteElement::nnode
unsigned nnode() const
Return the number of nodes.
Definition: elements.h:2210
oomph::FiniteElement::integral_pt
Integral *const & integral_pt() const
Return the pointer to the integration scheme (const version)
Definition: elements.h:1963
oomph::Integral::knot
virtual double knot(const unsigned &i, const unsigned &j) const =0
Return local coordinate s[j] of i-th integration point.
oomph::Integral::nweight
virtual unsigned nweight() const =0
Return the number of integration points of the scheme.
oomph::Integral::weight
virtual double weight(const unsigned &i) const =0
Return weight of i-th integration point.
oomph::Node::hanging_pt
HangInfo *const & hanging_pt() const
Definition: nodes.h:1228
oomph::Node::position_time_stepper_pt
TimeStepper *& position_time_stepper_pt()
Return a pointer to the position timestepper.
Definition: nodes.h:1022
oomph::Node::is_hanging
bool is_hanging() const
Test whether the node is geometrically hanging.
Definition: nodes.h:1285
oomph::PVDEquationsBase::Unsteady
bool Unsteady
Flag that switches inertia on/off.
Definition: solid_elements.h:421
oomph::PVDEquationsBase::solid_p_nodal_index
virtual int solid_p_nodal_index() const
Definition: solid_elements.h:186
oomph::PVDEquationsBase::solid_p_local_eqn
virtual int solid_p_local_eqn(const unsigned &i) const
Definition: solid_elements.h:178
oomph::PVDEquationsBase::Constitutive_law_pt
ConstitutiveLaw * Constitutive_law_pt
Pointer to the constitutive law.
Definition: solid_elements.h:415
oomph::PVDEquationsBase::prestress
double prestress(const unsigned &i, const unsigned &j, const Vector< double > xi)
Definition: solid_elements.h:393
oomph::PVDEquationsBase::get_isotropic_growth
virtual void get_isotropic_growth(const unsigned &ipt, const Vector< double > &s, const Vector< double > &xi, double &gamma) const
Definition: solid_elements.h:267
oomph::PVDEquationsBase::npres_solid
virtual unsigned npres_solid() const
Definition: solid_elements.h:171
oomph::PVDEquationsBase::body_force
void body_force(const Vector< double > &xi, Vector< double > &b) const
Definition: solid_elements.h:287
oomph::PVDEquationsBase::lambda_sq
const double & lambda_sq() const
Access function for timescale ratio (nondim density)
Definition: solid_elements.h:108
oomph::PVDEquationsWithPressure::get_stress
void get_stress(const Vector< double > &s, DenseMatrix< double > &sigma)
Definition: solid_elements.cc:2267
oomph::PVDEquationsWithPressure::solid_p
virtual double solid_p(const unsigned &l)=0
Return the lth solid pressure.
oomph::PVDEquationsWithPressure::get_d_stress_dG_upper
void get_d_stress_dG_upper(const DenseMatrix< double > &g, const DenseMatrix< double > &G, const DenseMatrix< double > &sigma, const double &gen_dil, const double &inv_kappa, const double &interpolated_solid_p, RankFourTensor< double > &d_sigma_dG, DenseMatrix< double > &d_gen_dil_dG)
Definition: solid_elements.h:1177
oomph::PVDEquationsWithPressure::solid_pshape_at_knot
void solid_pshape_at_knot(const unsigned &ipt, Shape &psi) const
Return the stored solid shape functions at the knots.
Definition: solid_elements.h:1220
oomph::PVDEquationsWithPressure::interpolated_solid_p
double interpolated_solid_p(const Vector< double > &s)
Return the interpolated_solid_pressure.
Definition: solid_elements.h:1011
oomph::PVDEquationsWithPressure::Incompressible
bool Incompressible
Boolean to determine whether the solid is incompressible or not.
Definition: solid_elements.h:1237
oomph::RefineableElement::local_hang_eqn
int local_hang_eqn(Node *const &node_pt, const unsigned &i)
Definition: refineable_elements.h:278
oomph::RefineablePVDEquationsWithPressure::solid_pressure_node_pt
virtual Node * solid_pressure_node_pt(const unsigned &l)
Definition: refineable_solid_elements.h:379
oomph::RefineableSolidElement::local_position_hang_eqn
DenseMatrix< int > & local_position_hang_eqn(Node *const &node_pt)
Definition: refineable_elements.h:1005
oomph::SolidFiniteElement::lagrangian_position_gen
double lagrangian_position_gen(const unsigned &n, const unsigned &k, const unsigned &i) const
Definition: elements.h:3912
oomph::SolidFiniteElement::Solid_ic_pt
SolidInitialCondition * Solid_ic_pt
Pointer to object that specifies the initial condition.
Definition: elements.h:4131
oomph::SolidFiniteElement::position_local_eqn
int position_local_eqn(const unsigned &n, const unsigned &k, const unsigned &j) const
Definition: elements.h:4137
oomph::SolidFiniteElement::get_residuals_for_solid_ic
virtual void get_residuals_for_solid_ic(Vector< double > &residuals)
Definition: elements.h:4003
oomph::SolidFiniteElement::interpolated_xi
virtual double interpolated_xi(const Vector< double > &s, const unsigned &i) const
Definition: elements.cc:7104
oomph::SolidFiniteElement::dshape_lagrangian_at_knot
virtual double dshape_lagrangian_at_knot(const unsigned &ipt, Shape &psi, DShape &dpsidxi) const
Definition: elements.cc:6737
oomph::TimeStepper::weight
virtual double weight(const unsigned &i, const unsigned &j) const
Access function for j-th weight for the i-th derivative.
Definition: timesteppers.h:594
s
RealScalar s
Definition: level1_cplx_impl.h:130
a
const Scalar * a
Definition: level2_cplx_impl.h:32
m
int * m
Definition: level2_cplx_impl.h:294
k
char char char int int * k
Definition: level2_impl.h:374
DIM
#define DIM
Definition: linearised_navier_stokes_elements.h:44
Eigen::bfloat16_impl::pow
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 pow(const bfloat16 &a, const bfloat16 &b)
Definition: BFloat16.h:625
calibrate.sigma
int sigma
Definition: calibrate.py:179
mathsFunc::gamma
Mdouble gamma(Mdouble gamma_in)
This is the gamma function returns the true value for the half integer value.
Definition: ExtendedMath.cc:116
oomph::QuadTreeNames::W
@ W
Definition: quadtree.h:63
OOMPH_EXCEPTION_LOCATION
#define OOMPH_EXCEPTION_LOCATION
Definition: oomph_definitions.h:61
OOMPH_CURRENT_FUNCTION
#define OOMPH_CURRENT_FUNCTION
Definition: oomph_definitions.h:86
j
std::ptrdiff_t j
Definition: tut_arithmetic_redux_minmax.cpp:2

References a, b, Global_Parameters::body_force(), Constitutive::Constitutive_law_pt, DIM, G, mathsFunc::gamma(), oomph::Node::hanging_pt(), i, oomph::Node::is_hanging(), J, j, k, m, m2(), oomph::HangInfo::master_node_pt(), oomph::HangInfo::master_weight(), oomph::HangInfo::nmaster(), oomph::RankFourTensor< T >::offset(), oomph::DShape::offset(), oomph::RankFiveTensor< T >::offset(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, Eigen::bfloat16_impl::pow(), oomph::RankFourTensor< T >::raw_direct_access(), oomph::RankFiveTensor< T >::raw_direct_access(), oomph::DShape::raw_direct_access(), oomph::ConstitutiveLaw::requires_incompressibility_constraint(), s, calibrate::sigma, w, and oomph::QuadTreeNames::W.

◆ further_build()

template<unsigned DIM>
void oomph::RefineablePVDEquationsWithPressure< DIM >::further_build ( )
inlinevirtual

Pass the generic stuff down to the sons.

Reimplemented from oomph::RefineableSolidElement.

Reimplemented in oomph::RefineableQPVDElementWithPressure< DIM >, oomph::RefineableQPVDElementWithPressure< DIM >, and oomph::RefineableQPVDElementWithPressure< DIM >.

387  {
388  RefineablePVDEquationsWithPressure<DIM>* cast_father_element_pt =
389  dynamic_cast<RefineablePVDEquationsWithPressure<DIM>*>(
390  this->father_element_pt());
391 
392  // Do whatever needs to be done in the base class
393  RefineableSolidElement::further_build();
394 
395  // Set pointer to isotropic growth function
396  this->Isotropic_growth_fct_pt =
397  cast_father_element_pt->isotropic_growth_fct_pt();
398 
399  // Set pointer to body force function
400  this->Body_force_fct_pt = cast_father_element_pt->body_force_fct_pt();
401 
402  // Set pointer to the contitutive law
403  this->Constitutive_law_pt = cast_father_element_pt->constitutive_law_pt();
404 
405  // Set the timescale ratio (non-dim. density)
406  this->Lambda_sq_pt = cast_father_element_pt->lambda_sq_pt();
407 
408  // Set the flag that switches inertia on/off
409  this->Unsteady = cast_father_element_pt->is_inertia_enabled();
410 
411  // Set the incompressibility flag
412  this->Incompressible = cast_father_element_pt->is_incompressible();
413 
414  // Evaluation of Jacobian by same method as father
415  this->Evaluate_jacobian_by_fd =
416  cast_father_element_pt->is_jacobian_evaluated_by_fd();
417  }
oomph::PVDEquationsBase::Body_force_fct_pt
BodyForceFctPt Body_force_fct_pt
Pointer to body force function.
Definition: solid_elements.h:424
oomph::PVDEquationsBase::Isotropic_growth_fct_pt
IsotropicGrowthFctPt Isotropic_growth_fct_pt
Pointer to isotropic growth function.
Definition: solid_elements.h:409
oomph::PVDEquationsBase::Evaluate_jacobian_by_fd
bool Evaluate_jacobian_by_fd
Use FD to evaluate Jacobian.
Definition: solid_elements.h:430
oomph::PVDEquationsBase::Lambda_sq_pt
double * Lambda_sq_pt
Timescale ratio (non-dim. density)
Definition: solid_elements.h:418
oomph::RefineableElement::father_element_pt
virtual RefineableElement * father_element_pt() const
Return a pointer to the father element.
Definition: refineable_elements.h:539
oomph::RefineableSolidElement::further_build
virtual void further_build()
Definition: refineable_elements.h:1014

References oomph::PVDEquationsBase< DIM >::body_force_fct_pt(), oomph::PVDEquationsBase< DIM >::Body_force_fct_pt, oomph::PVDEquationsBase< DIM >::constitutive_law_pt(), oomph::PVDEquationsBase< DIM >::Constitutive_law_pt, oomph::PVDEquationsBase< DIM >::Evaluate_jacobian_by_fd, oomph::RefineableElement::father_element_pt(), oomph::RefineableSolidElement::further_build(), oomph::PVDEquationsWithPressure< DIM >::Incompressible, oomph::PVDEquationsWithPressure< DIM >::is_incompressible(), oomph::PVDEquationsBase< DIM >::is_inertia_enabled(), oomph::PVDEquationsBase< DIM >::is_jacobian_evaluated_by_fd(), oomph::PVDEquationsBase< DIM >::isotropic_growth_fct_pt(), oomph::PVDEquationsBase< DIM >::Isotropic_growth_fct_pt, oomph::PVDEquationsBase< DIM >::lambda_sq_pt(), oomph::PVDEquationsBase< DIM >::Lambda_sq_pt, and oomph::PVDEquationsBase< DIM >::Unsteady.

Referenced by oomph::RefineableQPVDElementWithPressure< DIM >::further_build().

◆ get_interpolated_values() [1/2]

template<unsigned DIM>
void oomph::RefineablePVDEquationsWithPressure< DIM >::get_interpolated_values ( const unsigned &  t,
const Vector< double > &  s,
Vector< double > &  values 
)
inlinevirtual

No values are interpolated in this element (pure solid)

Implements oomph::RefineableElement.

Reimplemented in oomph::RefineableQPVDElementWithContinuousPressure< DIM >.

309  {
310  values.clear();
311  }

◆ get_interpolated_values() [2/2]

template<unsigned DIM>
void oomph::RefineablePVDEquationsWithPressure< DIM >::get_interpolated_values ( const Vector< double > &  s,
Vector< double > &  values 
)
inlinevirtual

No values are interpolated in this element (pure solid)

Reimplemented from oomph::RefineableElement.

Reimplemented in oomph::RefineableQPVDElementWithContinuousPressure< DIM >.

316  {
317  values.clear();
318  }

◆ get_mass_matrix_diagonal()

template<unsigned DIM>
void oomph::RefineablePVDEquationsWithPressure< DIM >::get_mass_matrix_diagonal ( Vector< double > &  mass_diag)
virtual

Compute the diagonal of the displacement mass matrix for LSC preconditioner

Compute the diagonal of the velocity mass matrix for LSC preconditioner.

Implements oomph::SolidElementWithDiagonalMassMatrix.

553  {
554  // Resize and initialise
555  mass_diag.assign(this->ndof(), 0.0);
556 
557  // find out how many nodes there are
558  unsigned n_node = this->nnode();
559 
560  // Find out how many position types of dof there are
561  const unsigned n_position_type = this->nnodal_position_type();
562 
563  // Set up memory for the shape functions
564  Shape psi(n_node, n_position_type);
565  DShape dpsidxi(n_node, n_position_type, DIM);
566 
567  // Number of integration points
568  unsigned n_intpt = this->integral_pt()->nweight();
569 
570  // Integer to store the local equations no
571  int local_eqn = 0;
572 
573  // Loop over the integration points
574  for (unsigned ipt = 0; ipt < n_intpt; ipt++)
575  {
576  // Get the integral weight
577  double w = this->integral_pt()->weight(ipt);
578 
579  // Call the derivatives of the shape functions
580  double J = this->dshape_lagrangian_at_knot(ipt, psi, dpsidxi);
581 
582  // Premultiply weights and Jacobian
583  double W = w * J;
584 
585  unsigned n_master = 1;
586  double hang_weight = 1.0;
587 
588  // Loop over the nodes
589  for (unsigned l = 0; l < n_node; l++)
590  {
591  // Get pointer to local node l
592  Node* local_node_pt = node_pt(l);
593 
594  // Cache hang status
595  bool is_hanging = local_node_pt->is_hanging();
596 
597  // If the node is a hanging node
598  if (is_hanging)
599  {
600  n_master = local_node_pt->hanging_pt()->nmaster();
601  }
602  // Otherwise the node is its own master
603  else
604  {
605  n_master = 1;
606  }
607 
608  // Storage for local equation numbers at node indexed by
609  // type and direction
610  DenseMatrix<int> position_local_eqn_at_node(n_position_type, DIM);
611 
612  // Loop over the master nodes
613  for (unsigned m = 0; m < n_master; m++)
614  {
615  if (is_hanging)
616  {
617  // Find the equation numbers
618  position_local_eqn_at_node = local_position_hang_eqn(
619  local_node_pt->hanging_pt()->master_node_pt(m));
620 
621  // Find the hanging node weight
622  hang_weight = local_node_pt->hanging_pt()->master_weight(m);
623  }
624  else
625  {
626  // Loop of types of dofs
627  for (unsigned k = 0; k < n_position_type; k++)
628  {
629  // Loop over the displacement components
630  for (unsigned i = 0; i < DIM; i++)
631  {
632  position_local_eqn_at_node(k, i) = position_local_eqn(l, k, i);
633  }
634  }
635 
636  // Hang weight is one
637  hang_weight = 1.0;
638  }
639 
640  // Loop over the types of dof
641  for (unsigned k = 0; k < n_position_type; k++)
642  {
643  // Loop over the directions
644  for (unsigned i = 0; i < DIM; i++)
645  {
646  // Get the equation number
647  local_eqn = position_local_eqn_at_node(k, i);
648 
649  // If not a boundary condition
650  if (local_eqn >= 0)
651  {
652  // Add the contribution
653  mass_diag[local_eqn] += pow(psi(l, k) * hang_weight, 2) * W;
654  } // End of if not boundary condition statement
655  } // End of loop over dimension
656  } // End of dof type
657  } // End of loop over master nodes
658  } // End of loop over basis functions (nodes)
659  } // End integration loop
660  }
oomph::GeneralisedElement::ndof
unsigned ndof() const
Return the number of equations/dofs in the element.
Definition: elements.h:835

References DIM, oomph::Node::hanging_pt(), i, oomph::Node::is_hanging(), J, k, m, oomph::HangInfo::master_node_pt(), oomph::HangInfo::master_weight(), oomph::HangInfo::nmaster(), Eigen::bfloat16_impl::pow(), w, and oomph::QuadTreeNames::W.

◆ get_Z2_flux()

template<unsigned DIM>
void oomph::RefineablePVDEquationsWithPressure< DIM >::get_Z2_flux ( const Vector< double > &  s,
Vector< double > &  flux 
)
inlinevirtual

in strain tensor.

Implements oomph::ElementWithZ2ErrorEstimator.

331  {
332  // Find the dimension of the problem
333 #ifdef PARANOID
334  unsigned num_entries = DIM + ((DIM * DIM) - DIM) / 2;
335  if (flux.size() != num_entries)
336  {
337  std::ostringstream error_message;
338  error_message << "The flux vector has the wrong number of entries, "
339  << flux.size() << ", whereas it should be " << num_entries
340  << std::endl;
341  throw OomphLibError(error_message.str(),
342  OOMPH_CURRENT_FUNCTION,
343  OOMPH_EXCEPTION_LOCATION);
344  }
345 #endif
346 
347  // Get strain matrix
348  DenseMatrix<double> strain(DIM);
349  this->get_strain(s, strain);
350 
351  // Pack into flux Vector
352  unsigned icount = 0;
353 
354  // Start with diagonal terms
355  for (unsigned i = 0; i < DIM; i++)
356  {
357  flux[icount] = strain(i, i);
358  icount++;
359  }
360 
361  // Off diagonals row by row
362  for (unsigned i = 0; i < DIM; i++)
363  {
364  for (unsigned j = i + 1; j < DIM; j++)
365  {
366  flux[icount] = strain(i, j);
367  icount++;
368  }
369  }
370  }
oomph::PVDEquationsBase::get_strain
void get_strain(const Vector< double > &s, DenseMatrix< double > &strain) const
Return the strain tensor.
Definition: solid_elements.cc:47
ProblemParameters::flux
void flux(const double &time, const Vector< double > &x, double &flux)
Get flux applied along boundary x=0.
Definition: pretend_melt.cc:59

References DIM, ProblemParameters::flux(), oomph::PVDEquationsBase< DIM >::get_strain(), i, j, OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

◆ ncont_interpolated_values()

template<unsigned DIM>
unsigned oomph::RefineablePVDEquationsWithPressure< DIM >::ncont_interpolated_values ( ) const
inlinevirtual

Number of continuously interpolated values: 0 (pure solid problem)

Implements oomph::RefineableElement.

Reimplemented in oomph::RefineableQPVDElementWithContinuousPressure< DIM >, and oomph::RefineableQPVDElementWithPressure< DIM >.

374  {
375  return 0;
376  }

◆ num_Z2_flux_terms()

template<unsigned DIM>
unsigned oomph::RefineablePVDEquationsWithPressure< DIM >::num_Z2_flux_terms ( )
inlinevirtual

Number of 'flux' terms for Z2 error estimation.

Implements oomph::ElementWithZ2ErrorEstimator.

322  {
323  // DIM Diagonal strain rates and DIM*(DIM-1)/2 off diagonal terms
324  return DIM + DIM * (DIM - 1) / 2;
325  }

References DIM.

◆ solid_pressure_node_pt()

template<unsigned DIM>
virtual Node* oomph::RefineablePVDEquationsWithPressure< DIM >::solid_pressure_node_pt ( const unsigned &  l)
inlinevirtual

Reimplemented in oomph::RefineableQPVDElementWithContinuousPressure< DIM >.

380  {
381  return 0;
382  }
The documentation for this class was generated from the following files: