Public Types | Public Member Functions | Static Public Attributes | Protected Member Functions | Protected Attributes | Static Protected Attributes | List of all members
oomph::PMLHelmholtzEquations< DIM > Class Template Referenceabstract

#include <pml_helmholtz_elements.h>

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

Public Types

typedef void(* PMLHelmholtzSourceFctPt) (const Vector< double > &x, std::complex< double > &f)
 
- Public Types inherited from oomph::FiniteElement
typedef void(* SteadyExactSolutionFctPt) (const Vector< double > &, Vector< double > &)
 
typedef void(* UnsteadyExactSolutionFctPt) (const double &, const Vector< double > &, Vector< double > &)
 

Public Member Functions

 PMLHelmholtzEquations ()
 Constructor. More...
 
 PMLHelmholtzEquations (const PMLHelmholtzEquations &dummy)=delete
 Broken copy constructor. More...
 
virtual std::complex< unsigned > u_index_helmholtz () const
 Broken assignment operator. More...
 
double *& k_squared_pt ()
 Get pointer to k_squared. More...
 
double k_squared ()
 Get the square of wavenumber. More...
 
const double & alpha () const
 Alpha, wavenumber complex shift. More...
 
double *& alpha_pt ()
 Pointer to Alpha, wavenumber complex shift. More...
 
unsigned nscalar_paraview () const
 
void scalar_value_paraview (std::ofstream &file_out, const unsigned &i, const unsigned &nplot) const
 
void scalar_value_fct_paraview (std::ofstream &file_out, const unsigned &i, const unsigned &nplot, FiniteElement::SteadyExactSolutionFctPt exact_soln_pt) const
 
std::string scalar_name_paraview (const unsigned &i) const
 
void output (std::ostream &outfile)
 Output with default number of plot points. More...
 
void output (std::ostream &outfile, const unsigned &n_plot)
 
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 output (FILE *file_pt)
 C_style output with default number of plot points. More...
 
void output (FILE *file_pt, const unsigned &n_plot)
 
void output_fct (std::ostream &outfile, const unsigned &n_plot, FiniteElement::SteadyExactSolutionFctPt exact_soln_pt)
 
virtual void output_fct (std::ostream &outfile, const unsigned &n_plot, const double &time, FiniteElement::UnsteadyExactSolutionFctPt exact_soln_pt)
 
void output_real_fct (std::ostream &outfile, const double &phi, const unsigned &n_plot, FiniteElement::SteadyExactSolutionFctPt exact_soln_pt)
 
void output_imag_fct (std::ostream &outfile, const double &phi, const unsigned &n_plot, FiniteElement::SteadyExactSolutionFctPt exact_soln_pt)
 
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...
 
void compute_norm (double &norm)
 Compute norm of fe solution. More...
 
PMLHelmholtzSourceFctPt & source_fct_pt ()
 Access function: Pointer to source function. More...
 
PMLHelmholtzSourceFctPt source_fct_pt () const
 Access function: Pointer to source function. Const version. More...
 
virtual void get_source_helmholtz (const unsigned &ipt, const Vector< double > &x, std::complex< double > &source) const
 
void values_to_be_pinned_on_outer_pml_boundary (Vector< unsigned > &values_to_pin)
 
void get_flux (const Vector< double > &s, Vector< std::complex< double >> &flux) const
 Get flux: flux[i] = du/dx_i for real and imag part. More...
 
void fill_in_contribution_to_residuals (Vector< double > &residuals)
 Add the element's contribution to its residual vector (wrapper) More...
 
void fill_in_contribution_to_jacobian (Vector< double > &residuals, DenseMatrix< double > &jacobian)
 
std::complex< double > interpolated_u_pml_helmholtz (const Vector< double > &s) const
 
unsigned self_test ()
 Self-test: Return 0 for OK. More...
 
void compute_pml_coefficients (const unsigned &ipt, const Vector< double > &x, Vector< std::complex< double >> &pml_laplace_factor, std::complex< double > &pml_k_squared_factor)
 
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...
 
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::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 ()
 
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...
 
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 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 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, 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 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
 

Static Public Attributes

static BermudezPMLMapping 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

virtual double dshape_and_dtest_eulerian_helmholtz (const Vector< double > &s, Shape &psi, DShape &dpsidx, Shape &test, DShape &dtestdx) const =0
 
virtual double dshape_and_dtest_eulerian_at_knot_helmholtz (const unsigned &ipt, Shape &psi, DShape &dpsidx, Shape &test, DShape &dtestdx) const =0
 
virtual void fill_in_generic_residual_contribution_helmholtz (Vector< double > &residuals, DenseMatrix< double > &jacobian, const unsigned &flag)
 
- 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

double * Alpha_pt
 Pointer to wavenumber complex shift. More...
 
PMLHelmholtzSourceFctPt Source_fct_pt
 Pointer to source function: More...
 
double * K_squared_pt
 Pointer to wave number (must be set!) 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

static double Default_Physical_Constant_Value
 Static default value for the physical constants (initialised to zero) 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::PMLHelmholtzEquations< DIM >

A class for all isoparametric elements that solve the Helmholtz equations with pml capabilities. This contains the generic maths. Shape functions, geometric mapping etc. must get implemented in derived class.

Member Typedef Documentation

◆ PMLHelmholtzSourceFctPt

template<unsigned DIM>
typedef void(* oomph::PMLHelmholtzEquations< DIM >::PMLHelmholtzSourceFctPt) (const Vector< double > &x, std::complex< double > &f)

Function pointer to source function fct(x,f(x)) – x is a Vector!

Constructor & Destructor Documentation

◆ PMLHelmholtzEquations() [1/2]

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

Constructor.

70  : Source_fct_pt(0), K_squared_pt(0)
71  {
72  // Provide pointer to static method (Save memory)
73  Pml_mapping_pt = &PMLHelmholtzEquations::Default_pml_mapping;
74  Alpha_pt = &Default_Physical_Constant_Value;
75  }
oomph::PMLHelmholtzEquations::Source_fct_pt
PMLHelmholtzSourceFctPt Source_fct_pt
Pointer to source function:
Definition: pml_helmholtz_elements.h:727
oomph::PMLHelmholtzEquations::Pml_mapping_pt
PMLMapping * Pml_mapping_pt
Definition: pml_helmholtz_elements.h:734
oomph::PMLHelmholtzEquations::Default_pml_mapping
static BermudezPMLMapping Default_pml_mapping
Definition: pml_helmholtz_elements.h:635
oomph::PMLHelmholtzEquations::Alpha_pt
double * Alpha_pt
Pointer to wavenumber complex shift.
Definition: pml_helmholtz_elements.h:724
oomph::PMLHelmholtzEquations::K_squared_pt
double * K_squared_pt
Pointer to wave number (must be set!)
Definition: pml_helmholtz_elements.h:730
oomph::PMLHelmholtzEquations::Default_Physical_Constant_Value
static double Default_Physical_Constant_Value
Static default value for the physical constants (initialised to zero)
Definition: pml_helmholtz_elements.h:737

References oomph::PMLHelmholtzEquations< DIM >::Alpha_pt, oomph::PMLHelmholtzEquations< DIM >::Default_Physical_Constant_Value, oomph::PMLHelmholtzEquations< DIM >::Default_pml_mapping, and oomph::PMLHelmholtzEquations< DIM >::Pml_mapping_pt.

◆ PMLHelmholtzEquations() [2/2]

template<unsigned DIM>
oomph::PMLHelmholtzEquations< DIM >::PMLHelmholtzEquations ( const PMLHelmholtzEquations< DIM > &  dummy)
delete

Broken copy constructor.

Member Function Documentation

◆ alpha()

template<unsigned DIM>
const double& oomph::PMLHelmholtzEquations< DIM >::alpha ( ) const
inline

Alpha, wavenumber complex shift.

120  {
121  return *Alpha_pt;
122  }

References oomph::PMLHelmholtzEquations< DIM >::Alpha_pt.

Referenced by oomph::PMLHelmholtzEquations< DIM >::compute_pml_coefficients().

◆ alpha_pt()

template<unsigned DIM>
double*& oomph::PMLHelmholtzEquations< DIM >::alpha_pt ( )
inline

Pointer to Alpha, wavenumber complex shift.

126  {
127  return Alpha_pt;
128  }

References oomph::PMLHelmholtzEquations< DIM >::Alpha_pt.

Referenced by oomph::HelmholtzMGPreconditioner< DIM >::setup_mg_structures().

◆ compute_error() [1/2]

template<unsigned DIM>
void oomph::PMLHelmholtzEquations< 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. Plot error at a given number of plot points.

Reimplemented from oomph::FiniteElement.

733  {
734  // Initialise
735  error = 0.0;
736  norm = 0.0;
737 
738  // Vector of local coordinates
739  Vector<double> s(DIM);
740 
741  // Vector for coordintes
742  Vector<double> x(DIM);
743 
744  // Find out how many nodes there are in the element
745  unsigned n_node = nnode();
746 
747  Shape psi(n_node);
748 
749  // Set the value of n_intpt
750  unsigned n_intpt = integral_pt()->nweight();
751 
752  // Tecplot
753  outfile << "ZONE" << std::endl;
754 
755  // Exact solution Vector
756  Vector<double> exact_soln(2);
757 
758  // Loop over the integration points
759  for (unsigned ipt = 0; ipt < n_intpt; ipt++)
760  {
761  // Assign values of s
762  for (unsigned i = 0; i < DIM; i++)
763  {
764  s[i] = integral_pt()->knot(ipt, i);
765  }
766 
767  // Get the integral weight
768  double w = integral_pt()->weight(ipt);
769 
770  // Get jacobian of mapping
771  double J = J_eulerian(s);
772 
773  // Premultiply the weights and the Jacobian
774  double W = w * J;
775 
776  // Get x position as Vector
777  interpolated_x(s, x);
778 
779  // Get FE function value
780  std::complex<double> u_fe = interpolated_u_pml_helmholtz(s);
781 
782  // Get exact solution at this point
783  (*exact_soln_pt)(x, exact_soln);
784 
785  // Output x,y,...,error
786  for (unsigned i = 0; i < DIM; i++)
787  {
788  outfile << x[i] << " ";
789  }
790  outfile << exact_soln[0] << " " << exact_soln[1] << " "
791  << exact_soln[0] - u_fe.real() << " "
792  << exact_soln[1] - u_fe.imag() << std::endl;
793 
794  // Add to error and norm
795  norm +=
796  (exact_soln[0] * exact_soln[0] + exact_soln[1] * exact_soln[1]) * W;
797  error += ((exact_soln[0] - u_fe.real()) * (exact_soln[0] - u_fe.real()) +
798  (exact_soln[1] - u_fe.imag()) * (exact_soln[1] - u_fe.imag())) *
799  W;
800  }
801  }
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::PMLHelmholtzEquations::interpolated_u_pml_helmholtz
std::complex< double > interpolated_u_pml_helmholtz(const Vector< double > &s) const
Definition: pml_helmholtz_elements.h:505
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, J, s, w, oomph::QuadTreeNames::W, and plotDoE::x.

◆ compute_error() [2/2]

template<unsigned DIM>
void oomph::PMLHelmholtzEquations< 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.

388  {
389  throw OomphLibError(
390  "There is no time-dependent compute_error() for PMLHelmholtz elements.",
391  OOMPH_CURRENT_FUNCTION,
392  OOMPH_EXCEPTION_LOCATION);
393  }
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::PMLHelmholtzEquations< DIM >::compute_norm ( double &  norm)
virtual

Compute norm of fe solution.

Reimplemented from oomph::GeneralisedElement.

809  {
810  // Initialise
811  norm = 0.0;
812 
813  // Vector of local coordinates
814  Vector<double> s(2);
815 
816  // Vector for coordintes
817  Vector<double> x(2);
818 
819  // Find out how many nodes there are in the element
820  unsigned n_node = nnode();
821 
822  Shape psi(n_node);
823 
824  // Set the value of n_intpt
825  unsigned n_intpt = integral_pt()->nweight();
826 
827  // Loop over the integration points
828  for (unsigned ipt = 0; ipt < n_intpt; ipt++)
829  {
830  // Assign values of s
831  for (unsigned i = 0; i < 2; i++)
832  {
833  s[i] = integral_pt()->knot(ipt, i);
834  }
835 
836  // Get the integral weight
837  double w = integral_pt()->weight(ipt);
838 
839  // Get jacobian of mapping
840  double J = J_eulerian(s);
841 
842  // Premultiply the weights and the Jacobian
843  double W = w * J;
844 
845  // Get FE function value
846  std::complex<double> u_fe = interpolated_u_pml_helmholtz(s);
847 
848  // Add to norm
849  norm += (u_fe.real() * u_fe.real() + u_fe.imag() * u_fe.imag()) * W;
850  }
851  }

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

◆ compute_pml_coefficients()

template<unsigned DIM>
void oomph::PMLHelmholtzEquations< DIM >::compute_pml_coefficients ( const unsigned &  ipt,
const Vector< double > &  x,
Vector< std::complex< double >> &  pml_laplace_factor,
std::complex< double > &  pml_k_squared_factor 
)
inline

Compute pml coefficients at position x and integration point ipt. pml_laplace_factor is used in the residual contribution from the laplace operator, similarly pml_k_squared_factor is used in the contribution from the k^2 of the Helmholtz operator.

Vector which points from the inner boundary to x

Vector which points from the inner boundary to the edge of the boundary

for 2D, in order: g_y/g_x, g_x/g_y for Laplace bit and g_x*g_y for Helmholtz bit for 3D, in order: g_y*g_x/g_x, g*x*g_z/g_y, g_x*g_y/g_z for Laplace bit and g_x*g_y*g_z for Helmholtz bit

The weights all default to 1.0 as if the propagation medium is the physical domain

551  {
553  Vector<double> nu(DIM);
554  for (unsigned k = 0; k < DIM; k++)
555  {
556  nu[k] = x[k] - this->Pml_inner_boundary[k];
557  }
558 
561  Vector<double> pml_width(DIM);
562  for (unsigned k = 0; k < DIM; k++)
563  {
564  pml_width[k] =
565  this->Pml_outer_boundary[k] - this->Pml_inner_boundary[k];
566  }
567 
568  // Declare gamma_i vectors of complex numbers for PML weights
569  Vector<std::complex<double>> pml_gamma(DIM);
570 
571  if (this->Pml_is_enabled)
572  {
573  // Cache k_squared to pass into mapping function
574  double k_squared_local = k_squared();
575 
576  for (unsigned k = 0; k < DIM; k++)
577  {
578  // If PML is enabled in the respective direction
579  if (this->Pml_direction_active[k])
580  {
581  pml_gamma[k] = Pml_mapping_pt->gamma(
582  nu[k], pml_width[k], k_squared_local, alpha());
583  }
584  else
585  {
586  pml_gamma[k] = 1.0;
587  }
588  }
589 
594  if (DIM == 2)
595  {
596  pml_laplace_factor[0] = pml_gamma[1] / pml_gamma[0];
597  pml_laplace_factor[1] = pml_gamma[0] / pml_gamma[1];
598  pml_k_squared_factor = pml_gamma[0] * pml_gamma[1];
599  }
600  else // if (DIM == 3)
601  {
602  pml_laplace_factor[0] = pml_gamma[1] * pml_gamma[2] / pml_gamma[0];
603  pml_laplace_factor[1] = pml_gamma[0] * pml_gamma[2] / pml_gamma[1];
604  pml_laplace_factor[2] = pml_gamma[0] * pml_gamma[1] / pml_gamma[2];
605  pml_k_squared_factor = pml_gamma[0] * pml_gamma[1] * pml_gamma[2];
606  }
607  }
608  else
609  {
612  for (unsigned k = 0; k < DIM; k++)
613  {
614  pml_laplace_factor[k] = std::complex<double>(1.0, 0.0);
615  }
616 
617  pml_k_squared_factor = std::complex<double>(1.0, 0.0);
618  }
619  }
oomph::PMLElementBase::Pml_is_enabled
bool Pml_is_enabled
Boolean indicating if element is used in pml mode.
Definition: pml_meshes.h:119
oomph::PMLElementBase::Pml_direction_active
std::vector< bool > Pml_direction_active
Definition: pml_meshes.h:124
oomph::PMLElementBase::Pml_outer_boundary
Vector< double > Pml_outer_boundary
Definition: pml_meshes.h:134
oomph::PMLElementBase::Pml_inner_boundary
Vector< double > Pml_inner_boundary
Definition: pml_meshes.h:129
oomph::PMLHelmholtzEquations::k_squared
double k_squared()
Get the square of wavenumber.
Definition: pml_helmholtz_elements.h:104
oomph::PMLHelmholtzEquations::alpha
const double & alpha() const
Alpha, wavenumber complex shift.
Definition: pml_helmholtz_elements.h:119
oomph::PMLMapping::gamma
virtual std::complex< double > gamma(const double &nu_i, const double &pml_width_i, const double &wavenumber_squared, const double &alpha_shift=0.0)=0
k
char char char int int * k
Definition: level2_impl.h:374

References oomph::PMLHelmholtzEquations< DIM >::alpha(), DIM, oomph::PMLMapping::gamma(), k, oomph::PMLHelmholtzEquations< DIM >::k_squared(), oomph::PMLElementBase< DIM >::Pml_direction_active, oomph::PMLElementBase< DIM >::Pml_inner_boundary, oomph::PMLElementBase< DIM >::Pml_is_enabled, oomph::PMLHelmholtzEquations< DIM >::Pml_mapping_pt, oomph::PMLElementBase< DIM >::Pml_outer_boundary, and plotDoE::x.

◆ dshape_and_dtest_eulerian_at_knot_helmholtz()

template<unsigned DIM>
virtual double oomph::PMLHelmholtzEquations< DIM >::dshape_and_dtest_eulerian_at_knot_helmholtz ( const unsigned &  ipt,
Shape &  psi,
DShape &  dpsidx,
Shape &  test,
DShape &  dtestdx 
) const
protectedpure virtual

Shape/test functions and derivs w.r.t. to global coords at integration point ipt; return Jacobian of mapping

Implemented in oomph::TPMLHelmholtzElement< DIM, NNODE_1D >, oomph::QPMLHelmholtzElement< DIM, NNODE_1D >, and oomph::QPMLHelmholtzElement< 2, NNODE_1D >.

◆ dshape_and_dtest_eulerian_helmholtz()

template<unsigned DIM>
virtual double oomph::PMLHelmholtzEquations< DIM >::dshape_and_dtest_eulerian_helmholtz ( const Vector< double > &  s,
Shape &  psi,
DShape &  dpsidx,
Shape &  test,
DShape &  dtestdx 
) const
protectedpure virtual

Shape/test functions and derivs w.r.t. to global coords at local coord. s; return Jacobian of mapping

Implemented in oomph::TPMLHelmholtzElement< DIM, NNODE_1D >, oomph::QPMLHelmholtzElement< DIM, NNODE_1D >, and oomph::QPMLHelmholtzElement< 2, NNODE_1D >.

◆ fill_in_contribution_to_jacobian()

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

Add the element's contribution to its residual vector and element Jacobian matrix (wrapper)

Reimplemented from oomph::FiniteElement.

497  {
498  // Call the generic routine with the flag set to 1
499  fill_in_generic_residual_contribution_helmholtz(residuals, jacobian, 1);
500  }
oomph::PMLHelmholtzEquations::fill_in_generic_residual_contribution_helmholtz
virtual void fill_in_generic_residual_contribution_helmholtz(Vector< double > &residuals, DenseMatrix< double > &jacobian, const unsigned &flag)
Definition: pml_helmholtz_elements.cc:56

References oomph::PMLHelmholtzEquations< DIM >::fill_in_generic_residual_contribution_helmholtz().

◆ fill_in_contribution_to_residuals()

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

Add the element's contribution to its residual vector (wrapper)

Reimplemented from oomph::GeneralisedElement.

485  {
486  // Call the generic residuals function with flag set to 0
487  // using a dummy matrix argument
488  fill_in_generic_residual_contribution_helmholtz(
489  residuals, GeneralisedElement::Dummy_matrix, 0);
490  }
oomph::GeneralisedElement::Dummy_matrix
static DenseMatrix< double > Dummy_matrix
Definition: elements.h:227

References oomph::GeneralisedElement::Dummy_matrix, and oomph::PMLHelmholtzEquations< DIM >::fill_in_generic_residual_contribution_helmholtz().

◆ fill_in_generic_residual_contribution_helmholtz()

template<unsigned DIM>
void oomph::PMLHelmholtzEquations< DIM >::fill_in_generic_residual_contribution_helmholtz ( Vector< double > &  residuals,
DenseMatrix< double > &  jacobian,
const unsigned &  flag 
)
protectedvirtual

Compute element residual Vector only (if flag=and/or element Jacobian matrix

Compute element residual Vector and/or element Jacobian matrix

flag=1: compute both flag=0: compute only residual Vector

Pure version without hanging nodes

Reimplemented in oomph::RefineablePMLHelmholtzEquations< DIM >.

60  {
61  // Find out how many nodes there are
62  const unsigned n_node = nnode();
63 
64  // Set up memory for the shape and test functions
65  Shape psi(n_node), test(n_node);
66  DShape dpsidx(n_node, DIM), dtestdx(n_node, DIM);
67 
68  // Set the value of n_intpt
69  const unsigned n_intpt = integral_pt()->nweight();
70 
71  // Integers to store the local equation and unknown numbers
72  int local_eqn_real = 0, local_unknown_real = 0;
73  int local_eqn_imag = 0, local_unknown_imag = 0;
74 
75  // Loop over the integration points
76  for (unsigned ipt = 0; ipt < n_intpt; ipt++)
77  {
78  // Get the integral weight
79  double w = integral_pt()->weight(ipt);
80 
81  // Call the derivatives of the shape and test functions
82  double J = dshape_and_dtest_eulerian_at_knot_helmholtz(
83  ipt, psi, dpsidx, test, dtestdx);
84 
85  // Premultiply the weights and the Jacobian
86  double W = w * J;
87 
88  // Calculate local values of unknown
89  // Allocate and initialise to zero
90  std::complex<double> interpolated_u(0.0, 0.0);
91  Vector<double> interpolated_x(DIM, 0.0);
92  Vector<std::complex<double>> interpolated_dudx(DIM);
93 
94  // Calculate function value and derivatives:
95  //-----------------------------------------
96  // Loop over nodes
97  for (unsigned l = 0; l < n_node; l++)
98  {
99  // Loop over directions
100  for (unsigned j = 0; j < DIM; j++)
101  {
102  interpolated_x[j] += raw_nodal_position(l, j) * psi(l);
103  }
104 
105  // Get the nodal value of the helmholtz unknown
106  const std::complex<double> u_value(
107  raw_nodal_value(l, u_index_helmholtz().real()),
108  raw_nodal_value(l, u_index_helmholtz().imag()));
109 
110  // Add to the interpolated value
111  interpolated_u += u_value * psi(l);
112 
113  // Loop over directions
114  for (unsigned j = 0; j < DIM; j++)
115  {
116  interpolated_dudx[j] += u_value * dpsidx(l, j);
117  }
118  }
119 
120  // Get source function
121  //-------------------
122  std::complex<double> source(0.0, 0.0);
123  get_source_helmholtz(ipt, interpolated_x, source);
124 
125 
126  // Declare a vector of complex numbers for pml weights on the Laplace bit
127  Vector<std::complex<double>> pml_laplace_factor(DIM);
128  // Declare a complex number for pml weights on the mass matrix bit
129  std::complex<double> pml_k_squared_factor =
130  std::complex<double>(1.0, 0.0);
131 
132  // All the PML weights that participate in the assemby process
133  // are computed here. pml_laplace_factor will contain the entries
134  // for the Laplace bit, while pml_k_squared_factor contains the
135  // contributions to the Helmholtz bit. Both default to 1.0, should the PML
136  // not be enabled via enable_pml.
137  compute_pml_coefficients(
138  ipt, interpolated_x, pml_laplace_factor, pml_k_squared_factor);
139 
140  // Alpha adjusts the pml factors, the imaginary part produces cross terms
141  std::complex<double> alpha_pml_k_squared_factor = std::complex<double>(
142  pml_k_squared_factor.real() - alpha() * pml_k_squared_factor.imag(),
143  alpha() * pml_k_squared_factor.real() + pml_k_squared_factor.imag());
144 
145 
146  // std::complex<double> alpha_pml_k_squared_factor
147  // if(alpha_pt() == 0)
148  // {
149  // std::complex<double> alpha_pml_k_squared_factor =
150  // std::complex<double>(
151  // pml_k_squared_factor.real() - alpha() *
152  // pml_k_squared_factor.imag(), alpha() * pml_k_squared_factor.real() +
153  // pml_k_squared_factor.imag()
154  // );
155  // }
156  // Assemble residuals and Jacobian
157  //--------------------------------
158  // Loop over the test functions
159  for (unsigned l = 0; l < n_node; l++)
160  {
161  // first, compute the real part contribution
162  //-------------------------------------------
163 
164  // Get the local equation
165  local_eqn_real = nodal_local_eqn(l, u_index_helmholtz().real());
166  local_eqn_imag = nodal_local_eqn(l, u_index_helmholtz().imag());
167 
168  /*IF it's not a boundary condition*/
169  if (local_eqn_real >= 0)
170  {
171  // Add body force/source term and Helmholtz bit
172  residuals[local_eqn_real] +=
173  (source.real() - (alpha_pml_k_squared_factor.real() * k_squared() *
174  interpolated_u.real() -
175  alpha_pml_k_squared_factor.imag() * k_squared() *
176  interpolated_u.imag())) *
177  test(l) * W;
178 
179  // The Laplace bit
180  for (unsigned k = 0; k < DIM; k++)
181  {
182  residuals[local_eqn_real] +=
183  (pml_laplace_factor[k].real() * interpolated_dudx[k].real() -
184  pml_laplace_factor[k].imag() * interpolated_dudx[k].imag()) *
185  dtestdx(l, k) * W;
186  }
187 
188  // Calculate the jacobian
189  //-----------------------
190  if (flag)
191  {
192  // Loop over the velocity shape functions again
193  for (unsigned l2 = 0; l2 < n_node; l2++)
194  {
195  local_unknown_real =
196  nodal_local_eqn(l2, u_index_helmholtz().real());
197  local_unknown_imag =
198  nodal_local_eqn(l2, u_index_helmholtz().imag());
199 
200  // If at a non-zero degree of freedom add in the entry
201  if (local_unknown_real >= 0)
202  {
203  // Add contribution to Elemental Matrix
204  for (unsigned i = 0; i < DIM; i++)
205  {
206  jacobian(local_eqn_real, local_unknown_real) +=
207  pml_laplace_factor[i].real() * dpsidx(l2, i) *
208  dtestdx(l, i) * W;
209  }
210  // Add the helmholtz contribution
211  jacobian(local_eqn_real, local_unknown_real) +=
212  -alpha_pml_k_squared_factor.real() * k_squared() * psi(l2) *
213  test(l) * W;
214  }
215  // If at a non-zero degree of freedom add in the entry
216  if (local_unknown_imag >= 0)
217  {
218  // Add contribution to Elemental Matrix
219  for (unsigned i = 0; i < DIM; i++)
220  {
221  jacobian(local_eqn_real, local_unknown_imag) -=
222  pml_laplace_factor[i].imag() * dpsidx(l2, i) *
223  dtestdx(l, i) * W;
224  }
225  // Add the helmholtz contribution
226  jacobian(local_eqn_real, local_unknown_imag) +=
227  alpha_pml_k_squared_factor.imag() * k_squared() * psi(l2) *
228  test(l) * W;
229  }
230  }
231  }
232  }
233 
234  // Second, compute the imaginary part contribution
235  //------------------------------------------------
236 
237  // Get the local equation
238  local_eqn_imag = nodal_local_eqn(l, u_index_helmholtz().imag());
239  local_eqn_real = nodal_local_eqn(l, u_index_helmholtz().real());
240 
241  /*IF it's not a boundary condition*/
242  if (local_eqn_imag >= 0)
243  {
244  // Add body force/source term and Helmholtz bit
245  residuals[local_eqn_imag] +=
246  (source.imag() - (alpha_pml_k_squared_factor.imag() * k_squared() *
247  interpolated_u.real() +
248  alpha_pml_k_squared_factor.real() * k_squared() *
249  interpolated_u.imag())) *
250  test(l) * W;
251 
252  // The Laplace bit
253  for (unsigned k = 0; k < DIM; k++)
254  {
255  residuals[local_eqn_imag] +=
256  (pml_laplace_factor[k].imag() * interpolated_dudx[k].real() +
257  pml_laplace_factor[k].real() * interpolated_dudx[k].imag()) *
258  dtestdx(l, k) * W;
259  }
260 
261  // Calculate the jacobian
262  //-----------------------
263  if (flag)
264  {
265  // Loop over the velocity shape functions again
266  for (unsigned l2 = 0; l2 < n_node; l2++)
267  {
268  local_unknown_imag =
269  nodal_local_eqn(l2, u_index_helmholtz().imag());
270  local_unknown_real =
271  nodal_local_eqn(l2, u_index_helmholtz().real());
272 
273  // If at a non-zero degree of freedom add in the entry
274  if (local_unknown_imag >= 0)
275  {
276  // Add contribution to Elemental Matrix
277  for (unsigned i = 0; i < DIM; i++)
278  {
279  jacobian(local_eqn_imag, local_unknown_imag) +=
280  pml_laplace_factor[i].real() * dpsidx(l2, i) *
281  dtestdx(l, i) * W;
282  }
283  // Add the helmholtz contribution
284  jacobian(local_eqn_imag, local_unknown_imag) +=
285  -alpha_pml_k_squared_factor.real() * k_squared() * psi(l2) *
286  test(l) * W;
287  }
288  if (local_unknown_real >= 0)
289  {
290  // Add contribution to Elemental Matrix
291  for (unsigned i = 0; i < DIM; i++)
292  {
293  jacobian(local_eqn_imag, local_unknown_real) +=
294  pml_laplace_factor[i].imag() * dpsidx(l2, i) *
295  dtestdx(l, i) * W;
296  }
297  // Add the helmholtz contribution
298  jacobian(local_eqn_imag, local_unknown_real) +=
299  -alpha_pml_k_squared_factor.imag() * k_squared() * psi(l2) *
300  test(l) * W;
301  }
302  }
303  }
304  }
305  }
306  } // End of loop over integration points
307  }
imag
AnnoyingScalar imag(const AnnoyingScalar &)
Definition: AnnoyingScalar.h:132
oomph::FiniteElement::nodal_local_eqn
int nodal_local_eqn(const unsigned &n, const unsigned &i) const
Definition: elements.h:1432
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::PMLHelmholtzEquations::dshape_and_dtest_eulerian_at_knot_helmholtz
virtual double dshape_and_dtest_eulerian_at_knot_helmholtz(const unsigned &ipt, Shape &psi, DShape &dpsidx, Shape &test, DShape &dtestdx) const =0
oomph::PMLHelmholtzEquations::get_source_helmholtz
virtual void get_source_helmholtz(const unsigned &ipt, const Vector< double > &x, std::complex< double > &source) const
Definition: pml_helmholtz_elements.h:416
oomph::PMLHelmholtzEquations::u_index_helmholtz
virtual std::complex< unsigned > u_index_helmholtz() const
Broken assignment operator.
Definition: pml_helmholtz_elements.h:91
oomph::PMLHelmholtzEquations::compute_pml_coefficients
void compute_pml_coefficients(const unsigned &ipt, const Vector< double > &x, Vector< std::complex< double >> &pml_laplace_factor, std::complex< double > &pml_k_squared_factor)
Definition: pml_helmholtz_elements.h:546
real
float real
Definition: datatypes.h:10
Eigen::test
squared absolute sa ArrayBase::abs2 DOXCOMMA MatrixBase::cwiseAbs2 sa Eigen::abs2 DOXCOMMA Eigen::pow DOXCOMMA ArrayBase::square nearest sa Eigen::floor DOXCOMMA Eigen::ceil DOXCOMMA ArrayBase::round nearest integer not less than the given sa Eigen::floor DOXCOMMA ArrayBase::ceil not a number test
Definition: GlobalFunctions.h:109
TestProblem::source
void source(const Vector< double > &x, Vector< double > &f)
Source function.
Definition: unstructured_two_d_circle.cc:46
test
Definition: indexed_view.cpp:20
j
std::ptrdiff_t j
Definition: tut_arithmetic_redux_minmax.cpp:2

References alpha, DIM, i, imag(), J, j, k, TestProblem::source(), Eigen::test, w, and oomph::QuadTreeNames::W.

Referenced by oomph::PMLHelmholtzEquations< DIM >::fill_in_contribution_to_jacobian(), and oomph::PMLHelmholtzEquations< DIM >::fill_in_contribution_to_residuals().

◆ get_dof_numbers_for_unknowns()

template<unsigned DIM>
void oomph::PMLHelmholtzEquations< DIM >::get_dof_numbers_for_unknowns ( std::list< std::pair< unsigned long, unsigned >> &  dof_lookup_list) const
inlinevirtual

Create a list of pairs for all unknowns in this element, so that the first entry in each pair contains the global equation number of the unknown, while the second one contains the number of the "DOF type" that this unknown is associated with. (Function can obviously only be called if the equation numbering scheme has been set up.) Real=0; Imag=1

Reimplemented from oomph::GeneralisedElement.

652  {
653  // temporary pair (used to store dof lookup prior to being added to list)
654  std::pair<unsigned, unsigned> dof_lookup;
655 
656  // number of nodes
657  unsigned n_node = this->nnode();
658 
659  // loop over the nodes
660  for (unsigned n = 0; n < n_node; n++)
661  {
662  // determine local eqn number for real part
663  int local_eqn_number =
664  this->nodal_local_eqn(n, u_index_helmholtz().real());
665 
666  // ignore pinned values
667  if (local_eqn_number >= 0)
668  {
669  // store dof lookup in temporary pair: First entry in pair
670  // is global equation number; second entry is dof type
671  dof_lookup.first = this->eqn_number(local_eqn_number);
672  dof_lookup.second = 0;
673 
674  // add to list
675  dof_lookup_list.push_front(dof_lookup);
676  }
677 
678  // determine local eqn number for imag part
679  local_eqn_number = this->nodal_local_eqn(n, u_index_helmholtz().imag());
680 
681  // ignore pinned values
682  if (local_eqn_number >= 0)
683  {
684  // store dof lookup in temporary pair: First entry in pair
685  // is global equation number; second entry is dof type
686  dof_lookup.first = this->eqn_number(local_eqn_number);
687  dof_lookup.second = 1;
688 
689  // add to list
690  dof_lookup_list.push_front(dof_lookup);
691  }
692  }
693  }
n
const unsigned n
Definition: CG3DPackingUnitTest.cpp:11
oomph::GeneralisedElement::eqn_number
unsigned long eqn_number(const unsigned &ieqn_local) const
Definition: elements.h:704
oomph::GeneralisedElement::local_eqn_number
int local_eqn_number(const unsigned long &ieqn_global) const
Definition: elements.h:726

References oomph::GeneralisedElement::eqn_number(), imag(), oomph::GeneralisedElement::local_eqn_number(), n, oomph::FiniteElement::nnode(), oomph::FiniteElement::nodal_local_eqn(), and oomph::PMLHelmholtzEquations< DIM >::u_index_helmholtz().

◆ get_flux()

template<unsigned DIM>
void oomph::PMLHelmholtzEquations< DIM >::get_flux ( const Vector< double > &  s,
Vector< std::complex< double >> &  flux 
) const
inline

Get flux: flux[i] = du/dx_i for real and imag part.

448  {
449  // Find out how many nodes there are in the element
450  const unsigned n_node = nnode();
451 
452 
453  // Set up memory for the shape and test functions
454  Shape psi(n_node);
455  DShape dpsidx(n_node, DIM);
456 
457  // Call the derivatives of the shape and test functions
458  dshape_eulerian(s, psi, dpsidx);
459 
460  // Initialise to zero
461  const std::complex<double> zero(0.0, 0.0);
462  for (unsigned j = 0; j < DIM; j++)
463  {
464  flux[j] = zero;
465  }
466 
467  // Loop over nodes
468  for (unsigned l = 0; l < n_node; l++)
469  {
470  // Cache the complex value of the unknown
471  const std::complex<double> u_value(
472  this->nodal_value(l, u_index_helmholtz().real()),
473  this->nodal_value(l, u_index_helmholtz().imag()));
474  // Loop over derivative directions
475  for (unsigned j = 0; j < DIM; j++)
476  {
477  flux[j] += u_value * dpsidx(l, j);
478  }
479  }
480  }
oomph::FiniteElement::nodal_value
double nodal_value(const unsigned &n, const unsigned &i) const
Definition: elements.h:2593
oomph::FiniteElement::dshape_eulerian
double dshape_eulerian(const Vector< double > &s, Shape &psi, DShape &dpsidx) const
Definition: elements.cc:3298
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
zero
EIGEN_DONT_INLINE Scalar zero()
Definition: svd_common.h:232

References DIM, oomph::FiniteElement::dshape_eulerian(), ProblemParameters::flux(), imag(), j, oomph::FiniteElement::nnode(), oomph::FiniteElement::nodal_value(), s, oomph::PMLHelmholtzEquations< DIM >::u_index_helmholtz(), and zero().

Referenced by oomph::RefineablePMLHelmholtzEquations< DIM >::get_Z2_flux(), and oomph::TPMLHelmholtzElement< DIM, NNODE_1D >::get_Z2_flux().

◆ get_source_helmholtz()

template<unsigned DIM>
virtual void oomph::PMLHelmholtzEquations< DIM >::get_source_helmholtz ( const unsigned &  ipt,
const Vector< double > &  x,
std::complex< double > &  source 
) const
inlinevirtual

Get source term at (Eulerian) position x. This function is virtual to allow overloading in multi-physics problems where the strength of the source function might be determined by another system of equations.

419  {
420  // If no source function has been set, return zero
421  if (Source_fct_pt == 0)
422  {
423  source = std::complex<double>(0.0, 0.0);
424  }
425  else
426  {
427  // Get source strength
428  (*Source_fct_pt)(x, source);
429  }
430  }

References TestProblem::source(), oomph::PMLHelmholtzEquations< DIM >::Source_fct_pt, and plotDoE::x.

◆ interpolated_u_pml_helmholtz()

template<unsigned DIM>
std::complex<double> oomph::PMLHelmholtzEquations< DIM >::interpolated_u_pml_helmholtz ( const Vector< double > &  s) const
inline

Return FE representation of function value u_helmholtz(s) at local coordinate s

507  {
508  // Find number of nodes
509  const unsigned n_node = nnode();
510 
511  // Local shape function
512  Shape psi(n_node);
513 
514  // Find values of shape function
515  shape(s, psi);
516 
517  // Initialise value of u
518  std::complex<double> interpolated_u(0.0, 0.0);
519 
520  // Get the index at which the helmholtz unknown is stored
521  const unsigned u_nodal_index_real = u_index_helmholtz().real();
522  const unsigned u_nodal_index_imag = u_index_helmholtz().imag();
523 
524  // Loop over the local nodes and sum
525  for (unsigned l = 0; l < n_node; l++)
526  {
527  // Make a temporary complex number from the stored data
528  const std::complex<double> u_value(
529  this->nodal_value(l, u_nodal_index_real),
530  this->nodal_value(l, u_nodal_index_imag));
531  // Add to the interpolated value
532  interpolated_u += u_value * psi[l];
533  }
534  return interpolated_u;
535  }
oomph::FiniteElement::shape
virtual void shape(const Vector< double > &s, Shape &psi) const =0

References oomph::FiniteElement::nnode(), oomph::FiniteElement::nodal_value(), s, oomph::FiniteElement::shape(), and oomph::PMLHelmholtzEquations< DIM >::u_index_helmholtz().

Referenced by oomph::PMLHelmholtzEquations< DIM >::scalar_value_paraview().

◆ k_squared()

template<unsigned DIM>
double oomph::PMLHelmholtzEquations< DIM >::k_squared ( )
inline

Get the square of wavenumber.

105  {
106 #ifdef PARANOID
107  if (K_squared_pt == 0)
108  {
109  throw OomphLibError(
110  "Please set pointer to k_squared using access fct to pointer!",
111  OOMPH_CURRENT_FUNCTION,
112  OOMPH_EXCEPTION_LOCATION);
113  }
114 #endif
115  return *K_squared_pt;
116  }

References oomph::PMLHelmholtzEquations< DIM >::K_squared_pt, OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

Referenced by oomph::PMLHelmholtzEquations< DIM >::compute_pml_coefficients(), and oomph::HelmholtzMGPreconditioner< DIM >::setup_mg_structures().

◆ k_squared_pt()

template<unsigned DIM>
double*& oomph::PMLHelmholtzEquations< DIM >::k_squared_pt ( )
inline

Get pointer to k_squared.

98  {
99  return K_squared_pt;
100  }

References oomph::PMLHelmholtzEquations< DIM >::K_squared_pt.

Referenced by PMLHelmholtzMGProblem< ELEMENT >::actions_after_adapt(), PMLHelmholtzMGProblem< ELEMENT >::PMLHelmholtzMGProblem(), and PMLProblem< ELEMENT >::PMLProblem().

◆ ndof_types()

template<unsigned DIM>
unsigned oomph::PMLHelmholtzEquations< DIM >::ndof_types ( ) const
inlinevirtual

The number of "DOF types" that degrees of freedom in this element are sub-divided into: real and imaginary part

Reimplemented from oomph::GeneralisedElement.

640  {
641  return 2;
642  }

◆ nscalar_paraview()

template<unsigned DIM>
unsigned oomph::PMLHelmholtzEquations< DIM >::nscalar_paraview ( ) const
inlinevirtual

Number of scalars/fields output by this element. Reimplements broken virtual function in base class.

Reimplemented from oomph::FiniteElement.

134  {
135  return 2;
136  }

◆ output() [1/4]

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

C_style output with default number of plot points.

Reimplemented from oomph::FiniteElement.

Reimplemented in oomph::TPMLHelmholtzElement< DIM, NNODE_1D >, oomph::QPMLHelmholtzElement< DIM, NNODE_1D >, and oomph::QPMLHelmholtzElement< 2, NNODE_1D >.

324  {
325  const unsigned n_plot = 5;
326  output(file_pt, n_plot);
327  }
oomph::PMLHelmholtzEquations::output
void output(std::ostream &outfile)
Output with default number of plot points.
Definition: pml_helmholtz_elements.h:282

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

◆ output() [2/4]

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

C-style output FE representation of soln: x,y,u_re,u_im or x,y,z,u_re,u_im at n_plot^DIM plot points

C-style output function:

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

nplot points in each coordinate direction

Reimplemented from oomph::FiniteElement.

Reimplemented in oomph::TPMLHelmholtzElement< DIM, NNODE_1D >, oomph::QPMLHelmholtzElement< DIM, NNODE_1D >, and oomph::QPMLHelmholtzElement< 2, NNODE_1D >.

522  {
523  // Vector of local coordinates
524  Vector<double> s(DIM);
525 
526  // Tecplot header info
527  fprintf(file_pt, "%s", tecplot_zone_string(nplot).c_str());
528 
529  // Loop over plot points
530  unsigned num_plot_points = nplot_points(nplot);
531  for (unsigned iplot = 0; iplot < num_plot_points; iplot++)
532  {
533  // Get local coordinates of plot point
534  get_s_plot(iplot, nplot, s);
535  std::complex<double> u(interpolated_u_pml_helmholtz(s));
536 
537  for (unsigned i = 0; i < DIM; i++)
538  {
539  fprintf(file_pt, "%g ", interpolated_x(s, i));
540  }
541 
542  for (unsigned i = 0; i < DIM; i++)
543  {
544  fprintf(file_pt, "%g ", interpolated_x(s, i));
545  }
546  fprintf(file_pt, "%g ", u.real());
547  fprintf(file_pt, "%g \n", u.imag());
548  }
549 
550  // Write tecplot footer (e.g. FE connectivity lists)
551  write_tecplot_zone_footer(file_pt, nplot);
552  }
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, and s.

◆ output() [3/4]

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

Output with default number of plot points.

Reimplemented from oomph::FiniteElement.

Reimplemented in oomph::TPMLHelmholtzElement< DIM, NNODE_1D >, oomph::QPMLHelmholtzElement< DIM, NNODE_1D >, and oomph::QPMLHelmholtzElement< 2, NNODE_1D >.

283  {
284  const unsigned n_plot = 5;
285  output(outfile, n_plot);
286  }

Referenced by oomph::PMLHelmholtzEquations< DIM >::output(), oomph::QPMLHelmholtzElement< DIM, NNODE_1D >::output(), and oomph::TPMLHelmholtzElement< DIM, NNODE_1D >::output().

◆ output() [4/4]

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

Output FE representation of soln: x,y,u_re,u_im or x,y,z,u_re,u_im at n_plot^DIM plot points

Output function:

x,y,u_re,u_imag or x,y,z,u_re,u_imag

nplot points in each coordinate direction

Reimplemented from oomph::FiniteElement.

Reimplemented in oomph::TPMLHelmholtzElement< DIM, NNODE_1D >, oomph::QPMLHelmholtzElement< DIM, NNODE_1D >, and oomph::QPMLHelmholtzElement< 2, NNODE_1D >.

346  {
347  // Vector of local coordinates
348  Vector<double> s(DIM);
349 
350  // Tecplot header info
351  outfile << tecplot_zone_string(nplot);
352 
353  // Loop over plot points
354  unsigned num_plot_points = nplot_points(nplot);
355  for (unsigned iplot = 0; iplot < num_plot_points; iplot++)
356  {
357  // Get local coordinates of plot point
358  get_s_plot(iplot, nplot, s);
359  std::complex<double> u(interpolated_u_pml_helmholtz(s));
360  for (unsigned i = 0; i < DIM; i++)
361  {
362  outfile << interpolated_x(s, i) << " ";
363  }
364  outfile << u.real() << " " << u.imag() << std::endl;
365  }
366 
367  // Write tecplot footer (e.g. FE connectivity lists)
368  write_tecplot_zone_footer(outfile, nplot);
369  }

References DIM, i, and s.

◆ output_fct() [1/2]

template<unsigned DIM>
virtual void oomph::PMLHelmholtzEquations< DIM >::output_fct ( std::ostream &  outfile,
const unsigned &  n_plot,
const double &  time,
FiniteElement::UnsteadyExactSolutionFctPt  exact_soln_pt 
)
inlinevirtual

Output exact soln: (dummy time-dependent version to keep intel compiler happy)

Reimplemented from oomph::FiniteElement.

Reimplemented in oomph::TPMLHelmholtzElement< DIM, NNODE_1D >, oomph::QPMLHelmholtzElement< DIM, NNODE_1D >, and oomph::QPMLHelmholtzElement< 2, NNODE_1D >.

346  {
347  throw OomphLibError(
348  "There is no time-dependent output_fct() for PMLHelmholtz elements.",
349  OOMPH_CURRENT_FUNCTION,
350  OOMPH_EXCEPTION_LOCATION);
351  }

References OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

◆ output_fct() [2/2]

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

Output exact soln: x,y,u_re_exact,u_im_exact or x,y,z,u_re_exact,u_im_exact at n_plot^DIM plot points

Output exact solution

Solution is provided via function pointer. Plot at a given number of plot points.

x,y,u_exact or x,y,z,u_exact

Reimplemented from oomph::FiniteElement.

Reimplemented in oomph::TPMLHelmholtzElement< DIM, NNODE_1D >, oomph::QPMLHelmholtzElement< DIM, NNODE_1D >, and oomph::QPMLHelmholtzElement< 2, NNODE_1D >.

568  {
569  // Vector of local coordinates
570  Vector<double> s(DIM);
571 
572  // Vector for coordinates
573  Vector<double> x(DIM);
574 
575  // Tecplot header info
576  outfile << tecplot_zone_string(nplot);
577 
578  // Exact solution Vector
579  Vector<double> exact_soln(2);
580 
581  // Loop over plot points
582  unsigned num_plot_points = nplot_points(nplot);
583  for (unsigned iplot = 0; iplot < num_plot_points; iplot++)
584  {
585  // Get local coordinates of plot point
586  get_s_plot(iplot, nplot, s);
587 
588  // Get x position as Vector
589  interpolated_x(s, x);
590 
591  // Get exact solution at this point
592  (*exact_soln_pt)(x, exact_soln);
593 
594  // Output x,y,...,u_exact
595  for (unsigned i = 0; i < DIM; i++)
596  {
597  outfile << x[i] << " ";
598  }
599  outfile << exact_soln[0] << " " << exact_soln[1] << std::endl;
600  }
601 
602  // Write tecplot footer (e.g. FE connectivity lists)
603  write_tecplot_zone_footer(outfile, nplot);
604  }

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

Referenced by oomph::QPMLHelmholtzElement< DIM, NNODE_1D >::output_fct(), and oomph::TPMLHelmholtzElement< DIM, NNODE_1D >::output_fct().

◆ output_imag()

template<unsigned DIM>
void oomph::PMLHelmholtzEquations< 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

487  {
488  // Vector of local coordinates
489  Vector<double> s(DIM);
490 
491  // Tecplot header info
492  outfile << tecplot_zone_string(nplot);
493 
494  // Loop over plot points
495  unsigned num_plot_points = nplot_points(nplot);
496  for (unsigned iplot = 0; iplot < num_plot_points; iplot++)
497  {
498  // Get local coordinates of plot point
499  get_s_plot(iplot, nplot, s);
500  std::complex<double> u(interpolated_u_pml_helmholtz(s));
501  for (unsigned i = 0; i < DIM; i++)
502  {
503  outfile << interpolated_x(s, i) << " ";
504  }
505  outfile << u.imag() * cos(phi) - u.real() * sin(phi) << std::endl;
506  }
507 
508  // Write tecplot footer (e.g. FE connectivity lists)
509  write_tecplot_zone_footer(outfile, nplot);
510  }
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, and sin().

Referenced by oomph::QPMLHelmholtzElement< DIM, NNODE_1D >::output_imag().

◆ output_imag_fct()

template<unsigned DIM>
void oomph::PMLHelmholtzEquations< DIM >::output_imag_fct ( std::ostream &  outfile,
const double &  phi,
const unsigned &  nplot,
FiniteElement::SteadyExactSolutionFctPt  exact_soln_pt 
)

Output function for imaginary part of full time-dependent fct 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 fct

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

680  {
681  // Vector of local coordinates
682  Vector<double> s(DIM);
683 
684  // Vector for coordintes
685  Vector<double> x(DIM);
686 
687  // Tecplot header info
688  outfile << tecplot_zone_string(nplot);
689 
690  // Exact solution Vector
691  Vector<double> exact_soln(2);
692 
693  // Loop over plot points
694  unsigned num_plot_points = nplot_points(nplot);
695  for (unsigned iplot = 0; iplot < num_plot_points; iplot++)
696  {
697  // Get local coordinates of plot point
698  get_s_plot(iplot, nplot, s);
699 
700  // Get x position as Vector
701  interpolated_x(s, x);
702 
703  // Get exact solution at this point
704  (*exact_soln_pt)(x, exact_soln);
705 
706  // Output x,y,...,u_exact
707  for (unsigned i = 0; i < DIM; i++)
708  {
709  outfile << x[i] << " ";
710  }
711  outfile << exact_soln[1] * cos(phi) - exact_soln[0] * sin(phi)
712  << std::endl;
713  }
714 
715  // Write tecplot footer (e.g. FE connectivity lists)
716  write_tecplot_zone_footer(outfile, nplot);
717  }

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

Referenced by oomph::QPMLHelmholtzElement< DIM, NNODE_1D >::output_imag_fct().

◆ output_real()

template<unsigned DIM>
void oomph::PMLHelmholtzEquations< 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 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

Output at nplot points in each coordinate direction

387  {
388  // Vector of local coordinates
389  Vector<double> s(DIM);
390 
391  // Tecplot header info
392  outfile << tecplot_zone_string(nplot);
393 
394  // Loop over plot points
395  unsigned num_plot_points = nplot_points(nplot);
396  for (unsigned iplot = 0; iplot < num_plot_points; iplot++)
397  {
398  // Get local coordinates of plot point
399  get_s_plot(iplot, nplot, s);
400  std::complex<double> u(interpolated_u_pml_helmholtz(s));
401  for (unsigned i = 0; i < DIM; i++)
402  {
403  outfile << interpolated_x(s, i) << " ";
404  }
405  outfile << u.real() * cos(phi) + u.imag() * sin(phi) << std::endl;
406  }
407 
408  // Write tecplot footer (e.g. FE connectivity lists)
409  write_tecplot_zone_footer(outfile, nplot);
410  }

References cos(), DIM, i, s, and sin().

Referenced by oomph::QPMLHelmholtzElement< DIM, NNODE_1D >::output_real().

◆ output_real_fct()

template<unsigned DIM>
void oomph::PMLHelmholtzEquations< DIM >::output_real_fct ( std::ostream &  outfile,
const double &  phi,
const unsigned &  nplot,
FiniteElement::SteadyExactSolutionFctPt  exact_soln_pt 
)

Output function for real part of full time-dependent fct 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 real part of full time-dependent fct

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

Output at nplot points in each coordinate direction

624  {
625  // Vector of local coordinates
626  Vector<double> s(DIM);
627 
628  // Vector for coordinates
629  Vector<double> x(DIM);
630 
631  // Tecplot header info
632  outfile << tecplot_zone_string(nplot);
633 
634  // Exact solution Vector
635  Vector<double> exact_soln(2);
636 
637  // Loop over plot points
638  unsigned num_plot_points = nplot_points(nplot);
639  for (unsigned iplot = 0; iplot < num_plot_points; iplot++)
640  {
641  // Get local coordinates of plot point
642  get_s_plot(iplot, nplot, s);
643 
644  // Get x position as Vector
645  interpolated_x(s, x);
646 
647  // Get exact solution at this point
648  (*exact_soln_pt)(x, exact_soln);
649 
650  // Output x,y,...,u_exact
651  for (unsigned i = 0; i < DIM; i++)
652  {
653  outfile << x[i] << " ";
654  }
655  outfile << exact_soln[0] * cos(phi) + exact_soln[1] * sin(phi)
656  << std::endl;
657  }
658 
659  // Write tecplot footer (e.g. FE connectivity lists)
660  write_tecplot_zone_footer(outfile, nplot);
661  }

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

Referenced by oomph::QPMLHelmholtzElement< DIM, NNODE_1D >::output_real_fct().

◆ output_total_real()

template<unsigned DIM>
void oomph::PMLHelmholtzEquations< 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

431  {
432  // Vector of local coordinates
433  Vector<double> s(DIM);
434 
435  // Vector for coordintes
436  Vector<double> x(DIM);
437 
438  // Real and imag part of incoming wave
439  Vector<double> incoming_soln(2);
440 
441  // Tecplot header info
442  outfile << tecplot_zone_string(nplot);
443 
444  // Loop over plot points
445  unsigned num_plot_points = nplot_points(nplot);
446  for (unsigned iplot = 0; iplot < num_plot_points; iplot++)
447  {
448  // Get local coordinates of plot point
449  get_s_plot(iplot, nplot, s);
450  std::complex<double> u(interpolated_u_pml_helmholtz(s));
451 
452  // Get x position as Vector
453  interpolated_x(s, x);
454 
455  // Get exact solution at this point
456  (*incoming_wave_fct_pt)(x, incoming_soln);
457 
458  for (unsigned i = 0; i < DIM; i++)
459  {
460  outfile << interpolated_x(s, i) << " ";
461  }
462 
463  outfile << (u.real() + incoming_soln[0]) * cos(phi) +
464  (u.imag() + incoming_soln[1]) * sin(phi)
465  << std::endl;
466  }
467 
468  // Write tecplot footer (e.g. FE connectivity lists)
469  write_tecplot_zone_footer(outfile, nplot);
470  }

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

◆ pml_mapping_pt() [1/2]

template<unsigned DIM>
PMLMapping*& oomph::PMLHelmholtzEquations< DIM >::pml_mapping_pt ( )
inline

Return a pointer to the PML Mapping object.

623  {
624  return Pml_mapping_pt;
625  }

References oomph::PMLHelmholtzEquations< DIM >::Pml_mapping_pt.

Referenced by PMLHelmholtzMGProblem< ELEMENT >::actions_after_adapt(), and PMLHelmholtzMGProblem< ELEMENT >::PMLHelmholtzMGProblem().

◆ pml_mapping_pt() [2/2]

template<unsigned DIM>
PMLMapping* const& oomph::PMLHelmholtzEquations< DIM >::pml_mapping_pt ( ) const
inline

Return a pointer to the PML Mapping object (const version)

629  {
630  return Pml_mapping_pt;
631  }

References oomph::PMLHelmholtzEquations< DIM >::Pml_mapping_pt.

◆ scalar_name_paraview()

template<unsigned DIM>
std::string oomph::PMLHelmholtzEquations< DIM >::scalar_name_paraview ( const unsigned &  i) const
inlinevirtual

Name of the i-th scalar field. Default implementation returns V1 for the first one, V2 for the second etc. Can (should!) be overloaded with more meaningful names in specific elements.

Reimplemented from oomph::FiniteElement.

251  {
252  switch (i)
253  {
254  case 0:
255  return "Real part";
256  break;
257 
258  case 1:
259  return "Imaginary part";
260  break;
261 
262  // Never get here
263  default:
264 #ifdef PARANOID
265  std::stringstream error_stream;
266  error_stream << "PML Helmholtz elements only store 2 fields (real "
267  "and imaginary) "
268  << "so i must be 0 or 1 rather "
269  << "than " << i << std::endl;
270  throw OomphLibError(error_stream.str(),
271  OOMPH_CURRENT_FUNCTION,
272  OOMPH_EXCEPTION_LOCATION);
273 #endif
274 
275  // Dummy return for the default statement
276  return " ";
277  break;
278  }
279  }

References i, OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

◆ scalar_value_fct_paraview()

template<unsigned DIM>
void oomph::PMLHelmholtzEquations< DIM >::scalar_value_fct_paraview ( std::ofstream &  file_out,
const unsigned &  i,
const unsigned &  nplot,
FiniteElement::SteadyExactSolutionFctPt  exact_soln_pt 
) const
inlinevirtual

Write values of the i-th scalar field at the plot points. Needs to be implemented for each new specific element type.

Reimplemented from oomph::FiniteElement.

193  {
194  // Vector of local coordinates
195  Vector<double> s(DIM);
196 
197  // Vector for coordinates
198  Vector<double> x(DIM);
199 
200  // Exact solution Vector
201  Vector<double> exact_soln(2);
202 
203  // Loop over plot points
204  unsigned num_plot_points = nplot_points_paraview(nplot);
205  for (unsigned iplot = 0; iplot < num_plot_points; iplot++)
206  {
207  // Get local coordinates of plot point
208  get_s_plot(iplot, nplot, s);
209 
210  // Get x position as Vector
211  interpolated_x(s, x);
212 
213  // Get exact solution at this point
214  (*exact_soln_pt)(x, exact_soln);
215 
216  // Paraview need to output the fields separately so it loops through all
217  // the elements twice
218  switch (i)
219  {
220  // Real part first
221  case 0:
222  file_out << exact_soln[0] << std::endl;
223  break;
224 
225  // Imaginary part second
226  case 1:
227  file_out << exact_soln[1] << std::endl;
228  break;
229 
230  // Never get here
231  default:
232 #ifdef PARANOID
233  std::stringstream error_stream;
234  error_stream << "PML Helmholtz elements only store 2 fields (real "
235  "and imaginary) "
236  << "so i must be 0 or 1 rather "
237  << "than " << i << std::endl;
238  throw OomphLibError(error_stream.str(),
239  OOMPH_CURRENT_FUNCTION,
240  OOMPH_EXCEPTION_LOCATION);
241 #endif
242  break;
243  }
244  }
245  }
oomph::FiniteElement::nplot_points_paraview
virtual unsigned nplot_points_paraview(const unsigned &nplot) const
Definition: elements.h:2862

References DIM, ProblemParameters::exact_soln(), oomph::FiniteElement::get_s_plot(), i, oomph::FiniteElement::interpolated_x(), oomph::FiniteElement::nplot_points_paraview(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, s, and plotDoE::x.

◆ scalar_value_paraview()

template<unsigned DIM>
void oomph::PMLHelmholtzEquations< DIM >::scalar_value_paraview ( std::ofstream &  file_out,
const unsigned &  i,
const unsigned &  nplot 
) const
inlinevirtual

Write values of the i-th scalar field at the plot points. Needs to be implemented for each new specific element type.

Reimplemented from oomph::FiniteElement.

143  {
144  // Vector of local coordinates
145  Vector<double> s(DIM);
146 
147  // Loop over plot points
148  unsigned num_plot_points = nplot_points_paraview(nplot);
149  for (unsigned iplot = 0; iplot < num_plot_points; iplot++)
150  {
151  // Get local coordinates of plot point
152  get_s_plot(iplot, nplot, s);
153  std::complex<double> u(interpolated_u_pml_helmholtz(s));
154 
155  // Paraview need to ouput the fields separately so it loops through all
156  // the elements twice
157  switch (i)
158  {
159  // Real part first
160  case 0:
161  file_out << u.real() << std::endl;
162  break;
163 
164  // Imaginary part second
165  case 1:
166  file_out << u.imag() << std::endl;
167  break;
168 
169  // Never get here
170  default:
171 #ifdef PARANOID
172  std::stringstream error_stream;
173  error_stream << "PML Helmholtz elements only store 2 fields (real "
174  "and imaginary) "
175  << "so i must be 0 or 1 rather "
176  << "than " << i << std::endl;
177  throw OomphLibError(error_stream.str(),
178  OOMPH_CURRENT_FUNCTION,
179  OOMPH_EXCEPTION_LOCATION);
180 #endif
181  break;
182  }
183  }
184  }

References DIM, oomph::FiniteElement::get_s_plot(), i, oomph::PMLHelmholtzEquations< DIM >::interpolated_u_pml_helmholtz(), oomph::FiniteElement::nplot_points_paraview(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, and s.

◆ self_test()

template<unsigned DIM>
unsigned oomph::PMLHelmholtzEquations< DIM >::self_test
virtual

Self-test: Return 0 for OK.

Reimplemented from oomph::FiniteElement.

315  {
316  bool passed = true;
317 
318  // Check lower-level stuff
319  if (FiniteElement::self_test() != 0)
320  {
321  passed = false;
322  }
323 
324  // Return verdict
325  if (passed)
326  {
327  return 0;
328  }
329  else
330  {
331  return 1;
332  }
333  }
oomph::FiniteElement::self_test
virtual unsigned self_test()
Definition: elements.cc:4440

References oomph::FiniteElement::self_test().

◆ source_fct_pt() [1/2]

template<unsigned DIM>
PMLHelmholtzSourceFctPt& oomph::PMLHelmholtzEquations< DIM >::source_fct_pt ( )
inline

Access function: Pointer to source function.

401  {
402  return Source_fct_pt;
403  }

References oomph::PMLHelmholtzEquations< DIM >::Source_fct_pt.

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

◆ source_fct_pt() [2/2]

template<unsigned DIM>
PMLHelmholtzSourceFctPt oomph::PMLHelmholtzEquations< DIM >::source_fct_pt ( ) const
inline

Access function: Pointer to source function. Const version.

407  {
408  return Source_fct_pt;
409  }

References oomph::PMLHelmholtzEquations< DIM >::Source_fct_pt.

◆ u_index_helmholtz()

template<unsigned DIM>
virtual std::complex<unsigned> oomph::PMLHelmholtzEquations< DIM >::u_index_helmholtz ( ) const
inlinevirtual

Broken assignment operator.

Return the index at which the unknown value is stored.

92  {
93  return std::complex<unsigned>(0, 1);
94  }

Referenced by oomph::PMLHelmholtzEquations< DIM >::get_dof_numbers_for_unknowns(), oomph::PMLHelmholtzEquations< DIM >::get_flux(), oomph::RefineablePMLHelmholtzEquations< DIM >::get_interpolated_values(), oomph::PMLHelmholtzEquations< DIM >::interpolated_u_pml_helmholtz(), oomph::PMLHelmholtzFluxElement< ELEMENT >::PMLHelmholtzFluxElement(), oomph::PMLHelmholtzFluxFromNormalDisplacementBCElement< HELMHOLTZ_BULK_ELEMENT, ELASTICITY_BULK_ELEMENT >::PMLHelmholtzFluxFromNormalDisplacementBCElement(), and oomph::PMLHelmholtzPowerElement< ELEMENT >::PMLHelmholtzPowerElement().

◆ values_to_be_pinned_on_outer_pml_boundary()

template<unsigned DIM>
void oomph::PMLHelmholtzEquations< DIM >::values_to_be_pinned_on_outer_pml_boundary ( Vector< unsigned > &  values_to_pin)
inlinevirtual

Pure virtual function in which we specify the values to be pinned (and set to zero) on the outer edge of the pml layer. All of them! Vector is resized internally.

Implements oomph::PMLElementBase< DIM >.

437  {
438  values_to_pin.resize(2);
439 
440  values_to_pin[0] = 0;
441  values_to_pin[1] = 1;
442  }

Member Data Documentation

◆ Alpha_pt

template<unsigned DIM>
double* oomph::PMLHelmholtzEquations< DIM >::Alpha_pt
protected

Pointer to wavenumber complex shift.

Referenced by oomph::PMLHelmholtzEquations< DIM >::alpha(), oomph::PMLHelmholtzEquations< DIM >::alpha_pt(), and oomph::PMLHelmholtzEquations< DIM >::PMLHelmholtzEquations().

◆ Default_Physical_Constant_Value

template<unsigned DIM>
double oomph::PMLHelmholtzEquations< DIM >::Default_Physical_Constant_Value
staticprotected
Initial value:
=
0.0

Static default value for the physical constants (initialised to zero)

PML Helmholtz equations static data, so that by default we can point to a 0

Referenced by oomph::PMLHelmholtzEquations< DIM >::PMLHelmholtzEquations().

◆ Default_pml_mapping

template<unsigned DIM>
BermudezPMLMapping oomph::PMLHelmholtzEquations< DIM >::Default_pml_mapping
static

Static so that the class doesn't need to instantiate a new default everytime it uses it

Referenced by oomph::PMLHelmholtzEquations< DIM >::PMLHelmholtzEquations().

◆ K_squared_pt

template<unsigned DIM>
double* oomph::PMLHelmholtzEquations< DIM >::K_squared_pt
protected

Pointer to wave number (must be set!)

Referenced by oomph::PMLHelmholtzEquations< DIM >::k_squared(), and oomph::PMLHelmholtzEquations< DIM >::k_squared_pt().

◆ Pml_mapping_pt

template<unsigned DIM>
PMLMapping* oomph::PMLHelmholtzEquations< DIM >::Pml_mapping_pt
protected

Pointer to class which holds the pml mapping function, also known as gamma

Referenced by oomph::PMLHelmholtzEquations< DIM >::compute_pml_coefficients(), oomph::PMLHelmholtzEquations< DIM >::pml_mapping_pt(), and oomph::PMLHelmholtzEquations< DIM >::PMLHelmholtzEquations().

◆ Source_fct_pt

template<unsigned DIM>
PMLHelmholtzSourceFctPt oomph::PMLHelmholtzEquations< DIM >::Source_fct_pt
protected

Pointer to source function:

Referenced by oomph::RefineablePMLHelmholtzEquations< DIM >::further_build(), oomph::PMLHelmholtzEquations< DIM >::get_source_helmholtz(), and oomph::PMLHelmholtzEquations< DIM >::source_fct_pt().

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