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

#include <pml_time_harmonic_linear_elasticity_elements.h>

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

Public Member Functions

 PMLTimeHarmonicLinearElasticityEquations ()
 Constructor. More...
 
unsigned required_nvalue (const unsigned &n) const
 Number of values required at node n. More...
 
void fill_in_contribution_to_residuals (Vector< double > &residuals)
 
void fill_in_contribution_to_jacobian (Vector< double > &residuals, DenseMatrix< double > &jacobian)
 
void get_stress (const Vector< double > &s, DenseMatrix< std::complex< double >> &sigma) const
 
void output_fct (std::ostream &outfile, const unsigned &nplot, FiniteElement::SteadyExactSolutionFctPt exact_soln_pt)
 Output exact solution x,y,[z],u_r,v_r,[w_r],u_i,v_i,[w_i]. More...
 
void output (std::ostream &outfile)
 Output: x,y,[z],u_r,v_r,[w_r],u_i,v_i,[w_i]. More...
 
void output (std::ostream &outfile, const unsigned &n_plot)
 Output: x,y,[z],u_r,v_r,[w_r],u_i,v_i,[w_i]. More...
 
void output (FILE *file_pt)
 C-style output: x,y,[z],u_r,v_r,[w_r],u_i,v_i,[w_i]. More...
 
void output (FILE *file_pt, const unsigned &n_plot)
 Output: x,y,[z],u_r,v_r,[w_r],u_i,v_i,[w_i]. More...
 
void output_total_real (std::ostream &outfile, FiniteElement::SteadyExactSolutionFctPt incoming_wave_fct_pt, const double &phi, const unsigned &nplot)
 
void output_real (std::ostream &outfile, const double &phi, const unsigned &n_plot)
 
void output_imag (std::ostream &outfile, const double &phi, const unsigned &n_plot)
 
void compute_norm (double &norm)
 Compute norm of solution: square of the L2 norm. More...
 
void compute_error (std::ostream &outfile, FiniteElement::SteadyExactSolutionFctPt exact_soln_pt, double &error, double &norm)
 Get error against and norm of exact solution. More...
 
void compute_error (std::ostream &outfile, FiniteElement::UnsteadyExactSolutionFctPt exact_soln_pt, const double &time, double &error, double &norm)
 Dummy, time dependent error checker. More...
 
- Public Member Functions inherited from oomph::PMLTimeHarmonicLinearElasticityEquationsBase< DIM >
 PMLTimeHarmonicLinearElasticityEquationsBase ()
 
virtual std::complex< unsigned > u_index_time_harmonic_linear_elasticity (const unsigned i) const
 
void interpolated_u_time_harmonic_linear_elasticity (const Vector< double > &s, Vector< std::complex< double >> &disp) const
 Compute vector of FE interpolated displacement u at local coordinate s. More...
 
std::complex< double > interpolated_u_time_harmonic_linear_elasticity (const Vector< double > &s, const unsigned &i) const
 Return FE interpolated displacement u[i] at local coordinate s. More...
 
PMLTimeHarmonicIsotropicElasticityTensor *& elasticity_tensor_pt ()
 Return the pointer to the elasticity_tensor. More...
 
std::complex< double > E (const unsigned &i, const unsigned &j, const unsigned &k, const unsigned &l) const
 Access function to the entries in the elasticity tensor. More...
 
double nu () const
 Access function to nu in the elasticity tensor. More...
 
const double & omega_sq () const
 Access function for square of non-dim frequency. More...
 
double *& omega_sq_pt ()
 Access function for square of non-dim frequency. 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 get_strain (const Vector< double > &s, DenseMatrix< std::complex< double >> &strain) const
 Return the strain tensor. More...
 
void body_force (const Vector< double > &x, Vector< std::complex< double >> &b) const
 
void values_to_be_pinned_on_outer_pml_boundary (Vector< unsigned > &values_to_pin)
 
unsigned ndof_types () const
 
void get_dof_numbers_for_unknowns (std::list< std::pair< unsigned long, unsigned >> &dof_lookup_list) const
 
void compute_pml_coefficients (const unsigned &ipt, const Vector< double > &x, Vector< std::complex< double >> &pml_inverse_jacobian_diagonal, std::complex< double > &pml_jacobian_det)
 
PMLMapping *& pml_mapping_pt ()
 Return a pointer to the PML Mapping object. More...
 
PMLMapping *const & pml_mapping_pt () const
 Return a pointer to the PML Mapping object (const version) More...
 
- Public Member Functions inherited from oomph::PMLElementBase< DIM >
 PMLElementBase ()
 Constructor. More...
 
virtual ~PMLElementBase ()
 Virtual destructor. More...
 
void disable_pml ()
 
void enable_pml (const int &direction, const double &interface_border_value, const double &outer_domain_border_value)
 
- 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)
 
virtual void set_macro_elem_pt (MacroElement *macro_elem_pt)
 
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 assign_nodal_local_eqn_numbers (const bool &store_local_dof_pt)
 
virtual void describe_local_dofs (std::ostream &out, const std::string &current_string) const
 
virtual void describe_nodal_local_dofs (std::ostream &out, const std::string &current_string) const
 
virtual void assign_all_generic_local_eqn_numbers (const bool &store_local_dof_pt)
 
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 get_dresidual_dnodal_coordinates (RankThreeTensor< double > &dresidual_dnodal_coordinates)
 
virtual void disable_ALE ()
 
virtual void enable_ALE ()
 
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...
 
virtual unsigned nvertex_node () const
 
virtual Node * vertex_node_pt (const unsigned &j) const
 
virtual Node * construct_node (const unsigned &n)
 
virtual Node * construct_node (const unsigned &n, TimeStepper *const &time_stepper_pt)
 
virtual Node * construct_boundary_node (const unsigned &n)
 
virtual Node * construct_boundary_node (const unsigned &n, TimeStepper *const &time_stepper_pt)
 
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)
 
unsigned ngeom_data () const
 
Data * geom_data_pt (const unsigned &j)
 
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)
 
virtual double zeta_nodal (const unsigned &n, const unsigned &k, const unsigned &i) const
 
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 void identify_field_data_for_interactions (std::set< std::pair< Data *, unsigned >> &paired_field_data)
 
virtual void identify_geometric_data (std::set< Data * > &geometric_data_pt)
 
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, 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, 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
 

Private Member Functions

virtual void fill_in_generic_contribution_to_residuals_time_harmonic_linear_elasticity (Vector< double > &residuals, DenseMatrix< double > &jacobian, unsigned flag)
 

Additional Inherited Members

- Public Types inherited from oomph::PMLTimeHarmonicLinearElasticityEquationsBase< DIM >
typedef void(* BodyForceFctPt) (const Vector< double > &x, Vector< std::complex< double >> &b)
 
- 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 Attributes inherited from oomph::PMLTimeHarmonicLinearElasticityEquationsBase< DIM >
static ContinuousBermudezPMLMapping Default_pml_mapping
 
- 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::FiniteElement
virtual void assemble_local_to_eulerian_jacobian (const DShape &dpsids, DenseMatrix< double > &jacobian) const
 
virtual void assemble_local_to_eulerian_jacobian2 (const DShape &d2psids, DenseMatrix< double > &jacobian2) const
 
virtual void assemble_eulerian_base_vectors (const DShape &dpsids, DenseMatrix< double > &interpolated_G) const
 
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 double local_to_eulerian_mapping_diagonal (const DShape &dpsids, DenseMatrix< double > &jacobian, 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
 
virtual void fill_in_jacobian_from_nodal_by_fd (Vector< double > &residuals, DenseMatrix< double > &jacobian)
 
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_jacobian_and_mass_matrix (Vector< double > &residuals, DenseMatrix< double > &jacobian, 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 Attributes inherited from oomph::PMLTimeHarmonicLinearElasticityEquationsBase< DIM >
PMLTimeHarmonicIsotropicElasticityTensor * Elasticity_tensor_pt
 Pointer to the elasticity tensor. More...
 
double * Omega_sq_pt
 Square of nondim frequency. More...
 
BodyForceFctPt Body_force_fct_pt
 Pointer to body force function. More...
 
PMLMapping * Pml_mapping_pt
 
- Protected Attributes inherited from oomph::PMLElementBase< DIM >
bool Pml_is_enabled
 Boolean indicating if element is used in pml mode. More...
 
std::vector< bool > Pml_direction_active
 
Vector< double > Pml_inner_boundary
 
Vector< double > Pml_outer_boundary
 
- 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
 
- Static Protected Attributes inherited from oomph::PMLTimeHarmonicLinearElasticityEquationsBase< DIM >
static double Default_omega_sq_value
 Static default value for square of frequency. 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
 

Detailed Description

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

//////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// A class for elements that solve the equations of linear elasticity in cartesian coordinates.

Constructor & Destructor Documentation

◆ PMLTimeHarmonicLinearElasticityEquations()

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

Constructor.

451 {}

Member Function Documentation

◆ compute_error() [1/2]

template<unsigned DIM>
void oomph::PMLTimeHarmonicLinearElasticityEquations< DIM >::compute_error ( std::ostream &  outfile,
FiniteElement::SteadyExactSolutionFctPt  exact_soln_pt,
double &  error,
double &  norm 
)
virtual

Get error against and norm of exact solution.

Validate against exact solution

Solution is provided via function pointer.

Reimplemented from oomph::FiniteElement.

928  {
929  // Initialise
930  error = 0.0;
931  norm = 0.0;
932 
933  // Vector of local coordinates
934  Vector<double> s(DIM);
935 
936  // Vector for coordintes
937  Vector<double> x(DIM);
938 
939  // Displacement vector
940  Vector<std::complex<double>> disp(DIM);
941 
942  // Find out how many nodes there are in the element
943  unsigned n_node = this->nnode();
944 
945  Shape psi(n_node);
946 
947  // Set the value of n_intpt
948  unsigned n_intpt = this->integral_pt()->nweight();
949 
950  // Exact solution Vector
951  Vector<double> exact_soln(2 * DIM);
952 
953  // Loop over the integration points
954  for (unsigned ipt = 0; ipt < n_intpt; ipt++)
955  {
956  // Assign values of s
957  for (unsigned i = 0; i < DIM; i++)
958  {
959  s[i] = this->integral_pt()->knot(ipt, i);
960  }
961 
962  // Get the integral weight
963  double w = this->integral_pt()->weight(ipt);
964 
965  // Get jacobian of mapping
966  double J = this->J_eulerian(s);
967 
968  // Premultiply the weights and the Jacobian
969  double W = w * J;
970 
971  // Get x position as Vector
972  this->interpolated_x(s, x);
973 
974  // Get exact solution at this point
975  (*exact_soln_pt)(x, exact_soln);
976 
977  // Get FE function value
978  this->interpolated_u_time_harmonic_linear_elasticity(s, disp);
979 
980  // Add to norm
981  for (unsigned ii = 0; ii < DIM; ii++)
982  {
983  // Add to error and norm
984  error += ((exact_soln[ii] - disp[ii].real()) *
985  (exact_soln[ii] - disp[ii].real()) +
986  (exact_soln[ii + DIM] - disp[ii].imag()) *
987  (exact_soln[ii + DIM] - disp[ii].imag())) *
988  W;
989  norm += (disp[ii].real() * disp[ii].real() +
990  disp[ii].imag() * disp[ii].imag()) *
991  W;
992  }
993  }
994  }
imag
AnnoyingScalar imag(const AnnoyingScalar &)
Definition: AnnoyingScalar.h:132
i
int i
Definition: BiCGSTAB_step_by_step.cpp:9
J
JacobiRotation< float > J
Definition: Jacobi_makeJacobi.cpp:3
w
RowVector3d w
Definition: Matrix_resize_int.cpp:3
oomph::FiniteElement::interpolated_x
virtual double interpolated_x(const Vector< double > &s, const unsigned &i) const
Return FE interpolated coordinate x[i] at local coordinate s.
Definition: elements.cc:3962
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::FiniteElement::J_eulerian
virtual double J_eulerian(const Vector< double > &s) const
Definition: elements.cc:4103
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::PMLTimeHarmonicLinearElasticityEquationsBase::interpolated_u_time_harmonic_linear_elasticity
void interpolated_u_time_harmonic_linear_elasticity(const Vector< double > &s, Vector< std::complex< double >> &disp) const
Compute vector of FE interpolated displacement u at local coordinate s.
Definition: pml_time_harmonic_linear_elasticity_elements.h:105
real
float real
Definition: datatypes.h:10
s
RealScalar s
Definition: level1_cplx_impl.h:130
DIM
#define DIM
Definition: linearised_navier_stokes_elements.h:44
ProblemParameters::exact_soln
void exact_soln(const double &time, const Vector< double > &x, Vector< double > &soln)
Definition: unstructured_two_d_curved.cc:301
calibrate.error
int error
Definition: calibrate.py:297
oomph::QuadTreeNames::W
@ W
Definition: quadtree.h:63
plotDoE.x
list x
Definition: plotDoE.py:28

References DIM, calibrate::error, ProblemParameters::exact_soln(), i, imag(), J, s, w, oomph::QuadTreeNames::W, and plotDoE::x.

◆ compute_error() [2/2]

template<unsigned DIM>
void oomph::PMLTimeHarmonicLinearElasticityEquations< DIM >::compute_error ( std::ostream &  outfile,
FiniteElement::UnsteadyExactSolutionFctPt  exact_soln_pt,
const double &  time,
double &  error,
double &  norm 
)
inlinevirtual

Dummy, time dependent error checker.

Reimplemented from oomph::FiniteElement.

556  {
557  std::ostringstream error_stream;
558  error_stream << "There is no time-dependent compute_error() " << std::endl
559  << "for pml time harmonic linear elasticity elements"
560  << std::endl;
561  throw OomphLibError(
562  error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
563  }
OOMPH_EXCEPTION_LOCATION
#define OOMPH_EXCEPTION_LOCATION
Definition: oomph_definitions.h:61
OOMPH_CURRENT_FUNCTION
#define OOMPH_CURRENT_FUNCTION
Definition: oomph_definitions.h:86

References OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

◆ compute_norm()

template<unsigned DIM>
void oomph::PMLTimeHarmonicLinearElasticityEquations< DIM >::compute_norm ( double &  norm)
virtual

Compute norm of solution: square of the L2 norm.

Compute norm of the solution.

Reimplemented from oomph::GeneralisedElement.

864  {
865  // Initialise
866  norm = 0.0;
867 
868  // Vector of local coordinates
869  Vector<double> s(DIM);
870 
871  // Vector for coordintes
872  Vector<double> x(DIM);
873 
874  // Displacement vector
875  Vector<std::complex<double>> disp(DIM);
876 
877  // Find out how many nodes there are in the element
878  unsigned n_node = this->nnode();
879 
880  Shape psi(n_node);
881 
882  // Set the value of n_intpt
883  unsigned n_intpt = this->integral_pt()->nweight();
884 
885  // Loop over the integration points
886  for (unsigned ipt = 0; ipt < n_intpt; ipt++)
887  {
888  // Assign values of s
889  for (unsigned i = 0; i < DIM; i++)
890  {
891  s[i] = this->integral_pt()->knot(ipt, i);
892  }
893 
894  // Get the integral weight
895  double w = this->integral_pt()->weight(ipt);
896 
897  // Get jacobian of mapping
898  double J = this->J_eulerian(s);
899 
900  // Premultiply the weights and the Jacobian
901  double W = w * J;
902 
903  // Get FE function value
904  this->interpolated_u_time_harmonic_linear_elasticity(s, disp);
905 
906  // Add to norm
907  for (unsigned ii = 0; ii < DIM; ii++)
908  {
909  norm += (disp[ii].real() * disp[ii].real() +
910  disp[ii].imag() * disp[ii].imag()) *
911  W;
912  }
913  }
914  }

References DIM, i, J, s, w, oomph::QuadTreeNames::W, and plotDoE::x.

◆ fill_in_contribution_to_jacobian()

template<unsigned DIM>
void oomph::PMLTimeHarmonicLinearElasticityEquations< DIM >::fill_in_contribution_to_jacobian ( Vector< double > &  residuals,
DenseMatrix< double > &  jacobian 
)
inlinevirtual

The jacobian is calculated by finite differences by default, We need only to take finite differences w.r.t. positional variables For this element

Reimplemented from oomph::FiniteElement.

472  {
473  // Add the contribution to the residuals
474  this
475  ->fill_in_generic_contribution_to_residuals_time_harmonic_linear_elasticity(
476  residuals, jacobian, 1);
477  }

◆ fill_in_contribution_to_residuals()

template<unsigned DIM>
void oomph::PMLTimeHarmonicLinearElasticityEquations< DIM >::fill_in_contribution_to_residuals ( Vector< double > &  residuals)
inlinevirtual

Return the residuals for the solid equations (the discretised principle of virtual displacements)

Reimplemented from oomph::GeneralisedElement.

462  {
463  fill_in_generic_contribution_to_residuals_time_harmonic_linear_elasticity(
464  residuals, GeneralisedElement::Dummy_matrix, 0);
465  }
oomph::GeneralisedElement::Dummy_matrix
static DenseMatrix< double > Dummy_matrix
Definition: elements.h:227
oomph::PMLTimeHarmonicLinearElasticityEquations::fill_in_generic_contribution_to_residuals_time_harmonic_linear_elasticity
virtual void fill_in_generic_contribution_to_residuals_time_harmonic_linear_elasticity(Vector< double > &residuals, DenseMatrix< double > &jacobian, unsigned flag)
Definition: pml_time_harmonic_linear_elasticity_elements.cc:197

References oomph::GeneralisedElement::Dummy_matrix, and oomph::PMLTimeHarmonicLinearElasticityEquations< DIM >::fill_in_generic_contribution_to_residuals_time_harmonic_linear_elasticity().

◆ fill_in_generic_contribution_to_residuals_time_harmonic_linear_elasticity()

template<unsigned DIM>
void oomph::PMLTimeHarmonicLinearElasticityEquations< DIM >::fill_in_generic_contribution_to_residuals_time_harmonic_linear_elasticity ( Vector< double > &  residuals,
DenseMatrix< double > &  jacobian,
unsigned  flag 
)
privatevirtual

Private helper function to compute residuals and (if requested via flag) also the Jacobian matrix.

Compute the residuals for the linear elasticity equations in cartesian coordinates. Flag indicates if we want Jacobian too.

All the PML weights that participate in the assemby process are computed here. pml_inverse_jacobian_diagonals are are used to transform derivatives in real x to derivatives in transformed space \(\tilde x \). pml_jacobian_det allows us to transform volume integrals in transformed space to real space. If the PML is not enabled via enable_pml, both default to 1.0.

199  {
200  // Find out how many nodes there are
201  unsigned n_node = this->nnode();
202 
203 #ifdef PARANOID
204  // Find out how many positional dofs there are
205  unsigned n_position_type = this->nnodal_position_type();
206 
207  if (n_position_type != 1)
208  {
209  std::ostringstream error_message;
210  error_message << "PMLTimeHarmonicLinearElasticity is not yet "
211  << "implemented for more than one position type"
212  << std::endl;
213  throw OomphLibError(
214  error_message.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
215  }
216 
217  // Throw and error if an elasticity tensor has not been set
218  if (this->Elasticity_tensor_pt == 0)
219  {
220  throw OomphLibError("No elasticity tensor set.",
221  OOMPH_CURRENT_FUNCTION,
222  OOMPH_EXCEPTION_LOCATION);
223  }
224 #endif
225 
226  // Find the indices at which the local velocities are stored
227  std::complex<unsigned> u_nodal_index[DIM];
228  for (unsigned i = 0; i < DIM; i++)
229  {
230  u_nodal_index[i] = this->u_index_time_harmonic_linear_elasticity(i);
231  }
232 
233 
234  // Square of non-dimensional frequency
235  const double omega_sq_local = this->omega_sq();
236 
237  // Set up memory for the shape functions
238  Shape psi(n_node);
239  DShape dpsidx(n_node, DIM);
240 
241  // Set the value of Nintpt -- the number of integration points
242  unsigned n_intpt = this->integral_pt()->nweight();
243 
244  // Set the vector to hold the local coordinates in the element
245  Vector<double> s(DIM);
246 
247  // Integers to store the local equation numbers
248  int local_eqn_real = 0, local_unknown_real = 0;
249  int local_eqn_imag = 0, local_unknown_imag = 0;
250 
251  // Loop over the integration points
252  for (unsigned ipt = 0; ipt < n_intpt; ipt++)
253  {
254  // Assign the values of s
255  for (unsigned i = 0; i < DIM; ++i)
256  {
257  s[i] = this->integral_pt()->knot(ipt, i);
258  }
259 
260  // Get the integral weight
261  double w = this->integral_pt()->weight(ipt);
262 
263  // Call the derivatives of the shape functions (and get Jacobian)
264  double J = this->dshape_eulerian_at_knot(ipt, psi, dpsidx);
265 
266  // Storage for Eulerian coordinates (initialised to zero)
267  Vector<double> interpolated_x(DIM, 0.0);
268 
269  // Displacement
270  Vector<std::complex<double>> interpolated_u(
271  DIM, std::complex<double>(0.0, 0.0));
272 
273  // Calculate interpolated values of the derivative of global position
274  // wrt lagrangian coordinates
275  DenseMatrix<std::complex<double>> interpolated_dudx(
276  DIM, DIM, std::complex<double>(0.0, 0.0));
277 
278  // Calculate displacements and derivatives
279  for (unsigned l = 0; l < n_node; l++)
280  {
281  // Loop over displacement components (deformed position)
282  for (unsigned i = 0; i < DIM; i++)
283  {
284  // Calculate the Lagrangian coordinates and the accelerations
285  interpolated_x[i] += this->raw_nodal_position(l, i) * psi(l);
286 
287 
288  // Get the nodal displacements
289  const std::complex<double> u_value = std::complex<double>(
290  this->raw_nodal_value(l, u_nodal_index[i].real()),
291  this->raw_nodal_value(l, u_nodal_index[i].imag()));
292 
293  interpolated_u[i] += u_value * psi(l);
294 
295  // Loop over derivative directions
296  for (unsigned j = 0; j < DIM; j++)
297  {
298  interpolated_dudx(i, j) += u_value * dpsidx(l, j);
299  }
300  }
301  }
302 
303  // Get body force
304  Vector<std::complex<double>> body_force_vec(DIM);
305  this->body_force(interpolated_x, body_force_vec);
306 
307  // Premultiply the weights and the Jacobian
308  double W = w * J;
309 
310 
318  Vector<std::complex<double>> pml_inverse_jacobian_diagonal(DIM);
319  std::complex<double> pml_jacobian_det;
320  this->compute_pml_coefficients(
321  ipt, interpolated_x, pml_inverse_jacobian_diagonal, pml_jacobian_det);
322 
323  // Loop over the test functions, nodes of the element
324  for (unsigned l = 0; l < n_node; l++)
325  {
326  // Loop over the displacement components
327  for (unsigned a = 0; a < DIM; a++)
328  {
329  // Get real and imaginary equation numbers
330  local_eqn_real = this->nodal_local_eqn(l, u_nodal_index[a].real());
331  local_eqn_imag = this->nodal_local_eqn(l, u_nodal_index[a].imag());
332 
333  //===== EQUATIONS OF PML TIME HARMONIC LINEAR ELASTICITY ========
334  // (This is where the maths happens)
335 
336  // Calculate jacobian and residual contributions from acceleration and
337  // body force
338  std::complex<double> mass_jacobian_contribution =
339  -omega_sq_local * pml_jacobian_det;
340  std::complex<double> mass_residual_contribution =
341  (-omega_sq_local * interpolated_u[a] - body_force_vec[a]) *
342  pml_jacobian_det;
343 
344  // Calculate jacobian and residual contributions from stress term
345  std::complex<double> stress_jacobian_contributions[DIM][DIM][DIM];
346  std::complex<double> stress_residual_contributions[DIM];
347  for (unsigned b = 0; b < DIM; b++)
348  {
349  stress_residual_contributions[b] = 0.0;
350  for (unsigned c = 0; c < DIM; c++)
351  {
352  for (unsigned d = 0; d < DIM; d++)
353  {
354  stress_jacobian_contributions[b][c][d] =
355  this->E(a, b, c, d) * pml_jacobian_det *
356  pml_inverse_jacobian_diagonal[b] *
357  pml_inverse_jacobian_diagonal[d];
358 
359  stress_residual_contributions[b] +=
360  stress_jacobian_contributions[b][c][d] *
361  interpolated_dudx(c, d);
362  }
363  }
364  }
365 
366  //===== ADD CONTRIBUTIONS TO GLOBAL RESIDUALS AND JACOBIAN ========
367 
368  /*IF it's not a boundary condition*/
369  if (local_eqn_real >= 0)
370  {
371  // Acceleration and body force
372  residuals[local_eqn_real] +=
373  mass_residual_contribution.real() * psi(l) * W;
374 
375  // Stress term
376  for (unsigned b = 0; b < DIM; b++)
377  {
378  // Add the stress terms to the residuals
379  residuals[local_eqn_real] +=
380  stress_residual_contributions[b].real() * dpsidx(l, b) * W;
381  }
382 
383  // Jacobian entries
384  if (flag)
385  {
386  // Loop over the displacement basis functions again
387  for (unsigned l2 = 0; l2 < n_node; l2++)
388  {
389  // Loop over the displacement components again
390  for (unsigned c = 0; c < DIM; c++)
391  {
392  local_unknown_real =
393  this->nodal_local_eqn(l2, u_nodal_index[c].real());
394  local_unknown_imag =
395  this->nodal_local_eqn(l2, u_nodal_index[c].imag());
396  // If it's not pinned
397  if (local_unknown_real >= 0)
398  {
399  // Inertial term
400  if (a == c)
401  {
402  jacobian(local_eqn_real, local_unknown_real) +=
403  mass_jacobian_contribution.real() * psi(l) * psi(l2) *
404  W;
405  }
406 
407  // Stress term
408  for (unsigned b = 0; b < DIM; b++)
409  {
410  for (unsigned d = 0; d < DIM; d++)
411  {
412  // Add the contribution to the Jacobian matrix
413  jacobian(local_eqn_real, local_unknown_real) +=
414  stress_jacobian_contributions[b][c][d].real() *
415  dpsidx(l2, d) * dpsidx(l, b) * W;
416  }
417  }
418  } // End of if not boundary condition
419 
420  if (local_unknown_imag >= 0)
421  {
422  // Inertial term
423  if (a == c)
424  {
425  jacobian(local_eqn_real, local_unknown_imag) -=
426  mass_jacobian_contribution.imag() * psi(l) * psi(l2) *
427  W;
428  }
429 
430  // Stress term
431  for (unsigned b = 0; b < DIM; b++)
432  {
433  for (unsigned d = 0; d < DIM; d++)
434  {
435  // Add the contribution to the Jacobian matrix
436  jacobian(local_eqn_real, local_unknown_imag) -=
437  stress_jacobian_contributions[b][c][d].imag() *
438  dpsidx(l2, d) * dpsidx(l, b) * W;
439  }
440  }
441  } // End of if not boundary condition
442  }
443  }
444  } // End of jacobian calculation
445 
446  } // End of if not boundary condition for real eqn
447 
448 
449  /*IF it's not a boundary condition*/
450  if (local_eqn_imag >= 0)
451  {
452  // Acceleration and body force
453  residuals[local_eqn_imag] +=
454  mass_residual_contribution.imag() * psi(l) * W;
455 
456  // Stress term
457  for (unsigned b = 0; b < DIM; b++)
458  {
459  // Add the stress terms to the residuals
460  residuals[local_eqn_imag] +=
461  stress_residual_contributions[b].imag() * dpsidx(l, b) * W;
462  }
463 
464  // Jacobian entries
465  if (flag)
466  {
467  // Loop over the displacement basis functions again
468  for (unsigned l2 = 0; l2 < n_node; l2++)
469  {
470  // Loop over the displacement components again
471  for (unsigned c = 0; c < DIM; c++)
472  {
473  local_unknown_imag =
474  this->nodal_local_eqn(l2, u_nodal_index[c].imag());
475  local_unknown_real =
476  this->nodal_local_eqn(l2, u_nodal_index[c].real());
477  // If it's not pinned
478  if (local_unknown_imag >= 0)
479  {
480  // Inertial term
481  if (a == c)
482  {
483  jacobian(local_eqn_imag, local_unknown_imag) +=
484  mass_jacobian_contribution.real() * psi(l) * psi(l2) *
485  W;
486  }
487 
488  // Stress term
489  for (unsigned b = 0; b < DIM; b++)
490  {
491  for (unsigned d = 0; d < DIM; d++)
492  {
493  // Add the contribution to the Jacobian matrix
494  jacobian(local_eqn_imag, local_unknown_imag) +=
495  stress_jacobian_contributions[b][c][d].real() *
496  dpsidx(l2, d) * dpsidx(l, b) * W;
497  }
498  }
499  } // End of if not boundary condition
500 
501  if (local_unknown_real >= 0)
502  {
503  // Inertial term
504  if (a == c)
505  {
506  jacobian(local_eqn_imag, local_unknown_real) +=
507  mass_jacobian_contribution.imag() * psi(l) * psi(l2) *
508  W;
509  }
510 
511  // Stress term
512  for (unsigned b = 0; b < DIM; b++)
513  {
514  for (unsigned d = 0; d < DIM; d++)
515  {
516  // Add the contribution to the Jacobian matrix
517  jacobian(local_eqn_imag, local_unknown_real) +=
518  stress_jacobian_contributions[b][c][d].imag() *
519  dpsidx(l2, d) * dpsidx(l, b) * W;
520  }
521  }
522  } // End of if not boundary condition
523  }
524  }
525  } // End of jacobian calculation
526 
527  } // End of if not boundary condition for imag eqn
528 
529  } // End of loop over coordinate directions
530  } // End of loop over shape functions
531  } // End of loop over integration points
532  }
b
Scalar * b
Definition: benchVecAdd.cpp:17
oomph::FiniteElement::nnodal_position_type
unsigned nnodal_position_type() const
Definition: elements.h:2463
oomph::FiniteElement::nodal_local_eqn
int nodal_local_eqn(const unsigned &n, const unsigned &i) const
Definition: elements.h:1432
oomph::FiniteElement::dshape_eulerian_at_knot
virtual double dshape_eulerian_at_knot(const unsigned &ipt, Shape &psi, DShape &dpsidx) const
Definition: elements.cc:3325
oomph::FiniteElement::raw_nodal_value
double raw_nodal_value(const unsigned &n, const unsigned &i) const
Definition: elements.h:2576
oomph::FiniteElement::raw_nodal_position
double raw_nodal_position(const unsigned &n, const unsigned &i) const
Definition: elements.cc:1686
oomph::PMLTimeHarmonicLinearElasticityEquationsBase::body_force
void body_force(const Vector< double > &x, Vector< std::complex< double >> &b) const
Definition: pml_time_harmonic_linear_elasticity_elements.h:236
oomph::PMLTimeHarmonicLinearElasticityEquationsBase::E
std::complex< double > E(const unsigned &i, const unsigned &j, const unsigned &k, const unsigned &l) const
Access function to the entries in the elasticity tensor.
Definition: pml_time_harmonic_linear_elasticity_elements.h:185
oomph::PMLTimeHarmonicLinearElasticityEquationsBase::u_index_time_harmonic_linear_elasticity
virtual std::complex< unsigned > u_index_time_harmonic_linear_elasticity(const unsigned i) const
Definition: pml_time_harmonic_linear_elasticity_elements.h:98
oomph::PMLTimeHarmonicLinearElasticityEquationsBase::omega_sq
const double & omega_sq() const
Access function for square of non-dim frequency.
Definition: pml_time_harmonic_linear_elasticity_elements.h:200
oomph::PMLTimeHarmonicLinearElasticityEquationsBase::Elasticity_tensor_pt
PMLTimeHarmonicIsotropicElasticityTensor * Elasticity_tensor_pt
Pointer to the elasticity tensor.
Definition: pml_time_harmonic_linear_elasticity_elements.h:419
oomph::PMLTimeHarmonicLinearElasticityEquationsBase::compute_pml_coefficients
void compute_pml_coefficients(const unsigned &ipt, const Vector< double > &x, Vector< std::complex< double >> &pml_inverse_jacobian_diagonal, std::complex< double > &pml_jacobian_det)
Definition: pml_time_harmonic_linear_elasticity_elements.h:331
a
const Scalar * a
Definition: level2_cplx_impl.h:32
calibrate.c
int c
Definition: calibrate.py:100
j
std::ptrdiff_t j
Definition: tut_arithmetic_redux_minmax.cpp:2

References a, b, Global_Parameters::body_force(), calibrate::c, DIM, Global_Physical_Variables::E, i, imag(), J, j, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, s, w, and oomph::QuadTreeNames::W.

Referenced by oomph::PMLTimeHarmonicLinearElasticityEquations< DIM >::fill_in_contribution_to_residuals().

◆ get_stress()

template<unsigned DIM>
void oomph::PMLTimeHarmonicLinearElasticityEquations< DIM >::get_stress ( const Vector< double > &  s,
DenseMatrix< std::complex< double >> &  stress 
) const
virtual

Return the Cauchy stress tensor, as calculated from the elasticity tensor at specified local coordinate

Compute the Cauchy stress tensor at local coordinate s for displacement formulation.

Implements oomph::PMLTimeHarmonicLinearElasticityEquationsBase< DIM >.

154  {
155 #ifdef PARANOID
156  if ((stress.ncol() != DIM) || (stress.nrow() != DIM))
157  {
158  std::ostringstream error_message;
159  error_message << "Stress matrix is " << stress.ncol() << " x "
160  << stress.nrow() << ", but dimension of the equations is "
161  << DIM << std::endl;
162  throw OomphLibError(
163  error_message.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
164  }
165 #endif
166 
167  // Get strain
168  DenseMatrix<std::complex<double>> strain(DIM, DIM);
169  this->get_strain(s, strain);
170 
171  // Now fill in the entries of the stress tensor without exploiting
172  // symmetry -- sorry too lazy. This fct is only used for
173  // postprocessing anyway...
174  for (unsigned i = 0; i < DIM; i++)
175  {
176  for (unsigned j = 0; j < DIM; j++)
177  {
178  stress(i, j) = 0.0;
179  for (unsigned k = 0; k < DIM; k++)
180  {
181  for (unsigned l = 0; l < DIM; l++)
182  {
183  stress(i, j) += this->E(i, j, k, l) * strain(k, l);
184  }
185  }
186  }
187  }
188  }
oomph::PMLTimeHarmonicLinearElasticityEquationsBase::get_strain
void get_strain(const Vector< double > &s, DenseMatrix< std::complex< double >> &strain) const
Return the strain tensor.
Definition: pml_time_harmonic_linear_elasticity_elements.cc:49
k
char char char int int * k
Definition: level2_impl.h:374

References DIM, Global_Physical_Variables::E, i, j, k, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, and s.

◆ output() [1/4]

template<unsigned DIM>
void oomph::PMLTimeHarmonicLinearElasticityEquations< DIM >::output ( FILE *  file_pt)
inlinevirtual

C-style output: x,y,[z],u_r,v_r,[w_r],u_i,v_i,[w_i].

Reimplemented from oomph::FiniteElement.

Reimplemented in oomph::TPMLTimeHarmonicLinearElasticityElement< DIM, NNODE_1D >, oomph::QPMLTimeHarmonicLinearElasticityElement< DIM, NNODE_1D >, and oomph::QPMLTimeHarmonicLinearElasticityElement< 2, NNODE_1D >.

502  {
503  unsigned n_plot = 5;
504  output(file_pt, n_plot);
505  }
oomph::PMLTimeHarmonicLinearElasticityEquations::output
void output(std::ostream &outfile)
Output: x,y,[z],u_r,v_r,[w_r],u_i,v_i,[w_i].
Definition: pml_time_harmonic_linear_elasticity_elements.h:490

References oomph::PMLTimeHarmonicLinearElasticityEquations< DIM >::output().

◆ output() [2/4]

template<unsigned DIM>
void oomph::PMLTimeHarmonicLinearElasticityEquations< DIM >::output ( FILE *  file_pt,
const unsigned &  n_plot 
)
virtual

Output: x,y,[z],u_r,v_r,[w_r],u_i,v_i,[w_i].

C-style output: x,y,[z],u,v,[w].

Reimplemented from oomph::FiniteElement.

Reimplemented in oomph::TPMLTimeHarmonicLinearElasticityElement< DIM, NNODE_1D >, oomph::QPMLTimeHarmonicLinearElasticityElement< DIM, NNODE_1D >, and oomph::QPMLTimeHarmonicLinearElasticityElement< 2, NNODE_1D >.

816  {
817  // Vector of local coordinates
818  Vector<double> s(DIM);
819 
820  // Tecplot header info
821  fprintf(file_pt, "%s", this->tecplot_zone_string(nplot).c_str());
822 
823  // Loop over plot points
824  unsigned num_plot_points = this->nplot_points(nplot);
825  for (unsigned iplot = 0; iplot < num_plot_points; iplot++)
826  {
827  // Get local coordinates of plot point
828  this->get_s_plot(iplot, nplot, s);
829 
830  // Coordinates
831  for (unsigned i = 0; i < DIM; i++)
832  {
833  fprintf(file_pt, "%g ", this->interpolated_x(s, i));
834  }
835 
836  // Displacement
837  for (unsigned i = 0; i < DIM; i++)
838  {
839  fprintf(
840  file_pt,
841  "%g ",
842  this->interpolated_u_time_harmonic_linear_elasticity(s, i).real());
843  }
844  for (unsigned i = 0; i < DIM; i++)
845  {
846  fprintf(
847  file_pt,
848  "%g ",
849  this->interpolated_u_time_harmonic_linear_elasticity(s, i).imag());
850  }
851  }
852  fprintf(file_pt, "\n");
853 
854  // Write tecplot footer (e.g. FE connectivity lists)
855  this->write_tecplot_zone_footer(file_pt, nplot);
856  }
oomph::FiniteElement::tecplot_zone_string
virtual std::string tecplot_zone_string(const unsigned &nplot) const
Definition: elements.h:3161
oomph::FiniteElement::get_s_plot
virtual void get_s_plot(const unsigned &i, const unsigned &nplot, Vector< double > &s, const bool &shifted_to_interior=false) const
Definition: elements.h:3148
oomph::FiniteElement::nplot_points
virtual unsigned nplot_points(const unsigned &nplot) const
Definition: elements.h:3186
oomph::FiniteElement::write_tecplot_zone_footer
virtual void write_tecplot_zone_footer(std::ostream &outfile, const unsigned &nplot) const
Definition: elements.h:3174

References DIM, i, imag(), and s.

◆ output() [3/4]

template<unsigned DIM>
void oomph::PMLTimeHarmonicLinearElasticityEquations< DIM >::output ( std::ostream &  outfile)
inlinevirtual

Output: x,y,[z],u_r,v_r,[w_r],u_i,v_i,[w_i].

Reimplemented from oomph::FiniteElement.

Reimplemented in oomph::TPMLTimeHarmonicLinearElasticityElement< DIM, NNODE_1D >, oomph::QPMLTimeHarmonicLinearElasticityElement< DIM, NNODE_1D >, and oomph::QPMLTimeHarmonicLinearElasticityElement< 2, NNODE_1D >.

491  {
492  unsigned n_plot = 5;
493  output(outfile, n_plot);
494  }

Referenced by oomph::PMLTimeHarmonicLinearElasticityEquations< DIM >::output(), oomph::QPMLTimeHarmonicLinearElasticityElement< DIM, NNODE_1D >::output(), and oomph::TPMLTimeHarmonicLinearElasticityElement< DIM, NNODE_1D >::output().

◆ output() [4/4]

template<unsigned DIM>
void oomph::PMLTimeHarmonicLinearElasticityEquations< DIM >::output ( std::ostream &  outfile,
const unsigned &  n_plot 
)
virtual

Output: x,y,[z],u_r,v_r,[w_r],u_i,v_i,[w_i].

Output: x,y,[z],u,v,[w].

Reimplemented from oomph::FiniteElement.

Reimplemented in oomph::TPMLTimeHarmonicLinearElasticityElement< DIM, NNODE_1D >, oomph::QPMLTimeHarmonicLinearElasticityElement< DIM, NNODE_1D >, and oomph::QPMLTimeHarmonicLinearElasticityElement< 2, NNODE_1D >.

591  {
592  // Initialise local coord, global coord and solution vectors
593  Vector<double> s(DIM);
594  Vector<double> x(DIM);
595  Vector<std::complex<double>> u(DIM);
596 
597  // Tecplot header info
598  outfile << this->tecplot_zone_string(nplot);
599 
600  // Loop over plot points
601  unsigned num_plot_points = this->nplot_points(nplot);
602  for (unsigned iplot = 0; iplot < num_plot_points; iplot++)
603  {
604  // Get local coordinates of plot point
605  this->get_s_plot(iplot, nplot, s);
606 
607  // Get Eulerian coordinates and displacements
608  this->interpolated_x(s, x);
609  this->interpolated_u_time_harmonic_linear_elasticity(s, u);
610 
611  // Output the x,y,..
612  for (unsigned i = 0; i < DIM; i++)
613  {
614  outfile << x[i] << " ";
615  }
616 
617  // Output u,v,..
618  for (unsigned i = 0; i < DIM; i++)
619  {
620  outfile << u[i].real() << " ";
621  }
622 
623  // Output u,v,..
624  for (unsigned i = 0; i < DIM; i++)
625  {
626  outfile << u[i].imag() << " ";
627  }
628 
629  outfile << std::endl;
630  }
631 
632  // Write tecplot footer (e.g. FE connectivity lists)
633  this->write_tecplot_zone_footer(outfile, nplot);
634  }

References DIM, i, s, and plotDoE::x.

◆ output_fct()

template<unsigned DIM>
void oomph::PMLTimeHarmonicLinearElasticityEquations< DIM >::output_fct ( std::ostream &  outfile,
const unsigned &  nplot,
FiniteElement::SteadyExactSolutionFctPt  exact_soln_pt 
)
virtual

Output exact solution x,y,[z],u_r,v_r,[w_r],u_i,v_i,[w_i].

Reimplemented from oomph::FiniteElement.

542  {
543  // Vector of local coordinates
544  Vector<double> s(DIM);
545 
546  // Vector for coordintes
547  Vector<double> x(DIM);
548 
549  // Tecplot header info
550  outfile << this->tecplot_zone_string(nplot);
551 
552  // Exact solution Vector
553  Vector<double> exact_soln(2 * DIM);
554 
555  // Loop over plot points
556  unsigned num_plot_points = this->nplot_points(nplot);
557  for (unsigned iplot = 0; iplot < num_plot_points; iplot++)
558  {
559  // Get local coordinates of plot point
560  this->get_s_plot(iplot, nplot, s);
561 
562  // Get x position as Vector
563  this->interpolated_x(s, x);
564 
565  // Get exact solution at this point
566  (*exact_soln_pt)(x, exact_soln);
567 
568  // Output x,y,...,u_exact,...
569  for (unsigned i = 0; i < DIM; i++)
570  {
571  outfile << x[i] << " ";
572  }
573  for (unsigned i = 0; i < 2 * DIM; i++)
574  {
575  outfile << exact_soln[i] << " ";
576  }
577  outfile << std::endl;
578  }
579 
580  // Write tecplot footer (e.g. FE connectivity lists)
581  this->write_tecplot_zone_footer(outfile, nplot);
582  }

References DIM, ProblemParameters::exact_soln(), i, s, and plotDoE::x.

◆ output_imag()

template<unsigned DIM>
void oomph::PMLTimeHarmonicLinearElasticityEquations< DIM >::output_imag ( std::ostream &  outfile,
const double &  phi,
const unsigned &  nplot 
)

Output function for imaginary part of full time-dependent solution u = Im( (u_r +i u_i) exp(-i omega t) ) at phase angle omega t = phi. x,y,u or x,y,z,u at n_plot plot points in each coordinate direction

Output function for imaginary part of full time-dependent solution

u = Im( (u_r +i u_i) exp(-i omega t))

at phase angle omega t = phi.

x,y,u or x,y,z,u

Output at nplot points in each coordinate direction

770  {
771  // Initialise local coord, global coord and solution vectors
772  Vector<double> s(DIM);
773  Vector<double> x(DIM);
774  Vector<std::complex<double>> u(DIM);
775 
776  // Tecplot header info
777  outfile << this->tecplot_zone_string(nplot);
778 
779  // Loop over plot points
780  unsigned num_plot_points = this->nplot_points(nplot);
781  for (unsigned iplot = 0; iplot < num_plot_points; iplot++)
782  {
783  // Get local coordinates of plot point
784  this->get_s_plot(iplot, nplot, s);
785 
786  // Get Eulerian coordinates and displacements
787  this->interpolated_x(s, x);
788  this->interpolated_u_time_harmonic_linear_elasticity(s, u);
789 
790  // Output the x,y,..
791  for (unsigned i = 0; i < DIM; i++)
792  {
793  outfile << x[i] << " ";
794  }
795 
796  // Output u,v,..
797  for (unsigned i = 0; i < DIM; i++)
798  {
799  outfile << u[i].imag() * cos(phi) - u[i].real() * sin(phi) << " ";
800  }
801 
802  outfile << std::endl;
803  }
804 
805  // Write tecplot footer (e.g. FE connectivity lists)
806  this->write_tecplot_zone_footer(outfile, nplot);
807  }
cos
AnnoyingScalar cos(const AnnoyingScalar &x)
Definition: AnnoyingScalar.h:136
sin
AnnoyingScalar sin(const AnnoyingScalar &x)
Definition: AnnoyingScalar.h:137

References cos(), DIM, i, s, sin(), and plotDoE::x.

◆ output_real()

template<unsigned DIM>
void oomph::PMLTimeHarmonicLinearElasticityEquations< DIM >::output_real ( std::ostream &  outfile,
const double &  phi,
const unsigned &  nplot 
)

Output function for real part of full time-dependent solution u = Re( (u_r +i u_i) exp(-i omega t)) at phase angle omega t = phi. x,y,u or x,y,z,u at n_plot plot points in each coordinate direction

Output function for imaginary part of full time-dependent solution

u = Im( (u_r +i u_i) exp(-i omega t))

at phase angle omega t = phi.

x,y,u or x,y,z,u

Output at nplot points in each coordinate direction

717  {
718  // Initialise local coord, global coord and solution vectors
719  Vector<double> s(DIM);
720  Vector<double> x(DIM);
721  Vector<std::complex<double>> u(DIM);
722 
723  // Tecplot header info
724  outfile << this->tecplot_zone_string(nplot);
725 
726  // Loop over plot points
727  unsigned num_plot_points = this->nplot_points(nplot);
728  for (unsigned iplot = 0; iplot < num_plot_points; iplot++)
729  {
730  // Get local coordinates of plot point
731  this->get_s_plot(iplot, nplot, s);
732 
733  // Get Eulerian coordinates and displacements
734  this->interpolated_x(s, x);
735  this->interpolated_u_time_harmonic_linear_elasticity(s, u);
736 
737  // Output the x,y,..
738  for (unsigned i = 0; i < DIM; i++)
739  {
740  outfile << x[i] << " ";
741  }
742 
743  // Output u,v,..
744  for (unsigned i = 0; i < DIM; i++)
745  {
746  outfile << u[i].real() * cos(phi) + u[i].imag() * sin(phi) << " ";
747  }
748 
749  outfile << std::endl;
750  }
751 
752  // Write tecplot footer (e.g. FE connectivity lists)
753  this->write_tecplot_zone_footer(outfile, nplot);
754  }

References cos(), DIM, i, s, sin(), and plotDoE::x.

◆ output_total_real()

template<unsigned DIM>
void oomph::PMLTimeHarmonicLinearElasticityEquations< DIM >::output_total_real ( std::ostream &  outfile,
FiniteElement::SteadyExactSolutionFctPt  incoming_wave_fct_pt,
const double &  phi,
const unsigned &  nplot 
)

Output function for real part of full time-dependent solution constructed by adding the scattered field u = Re( (u_r +i u_i) exp(-i omega t) at phase angle omega t = phi computed here, to the corresponding incoming wave specified via the function pointer.

Output function for real part of full time-dependent solution constructed by adding the scattered field

u = Re( (u_r +i u_i) exp(-i omega t)

at phase angle omega t = phi computed here, to the corresponding incoming wave specified via the function pointer.

x,y,u or x,y,z,u

Output at nplot points in each coordinate direction

656  {
657  // Initialise local coord, global coord and solution vectors
658  Vector<double> s(DIM);
659  Vector<double> x(DIM);
660  Vector<std::complex<double>> u(DIM);
661 
662  // Real and imag part of incoming wave
663  Vector<double> incoming_soln(2 * DIM);
664 
665  // Tecplot header info
666  outfile << this->tecplot_zone_string(nplot);
667 
668  // Loop over plot points
669  unsigned num_plot_points = this->nplot_points(nplot);
670  for (unsigned iplot = 0; iplot < num_plot_points; iplot++)
671  {
672  // Get local coordinates of plot point
673  this->get_s_plot(iplot, nplot, s);
674 
675  // Get Eulerian coordinates and displacements
676  this->interpolated_x(s, x);
677  this->interpolated_u_time_harmonic_linear_elasticity(s, u);
678 
679  // Get exact solution at this point
680  (*incoming_wave_fct_pt)(x, incoming_soln);
681 
682  // Output the x,y,..
683  for (unsigned i = 0; i < DIM; i++)
684  {
685  outfile << x[i] << " ";
686  }
687 
688  // Output u,v,..
689  for (unsigned i = 0; i < DIM; i++)
690  {
691  outfile << (u[i].real() + incoming_soln[2 * i]) * cos(phi) +
692  (u[i].imag() + incoming_soln[2 * i + 1]) * sin(phi)
693  << " ";
694  }
695 
696  outfile << std::endl;
697  }
698 
699  // Write tecplot footer (e.g. FE connectivity lists)
700  this->write_tecplot_zone_footer(outfile, nplot);
701  }

References cos(), DIM, i, s, sin(), and plotDoE::x.

◆ required_nvalue()

template<unsigned DIM>
unsigned oomph::PMLTimeHarmonicLinearElasticityEquations< DIM >::required_nvalue ( const unsigned &  n) const
inlinevirtual

Number of values required at node n.

Reimplemented from oomph::FiniteElement.

455  {
456  return 2 * DIM;
457  }

References DIM.

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