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

////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////// More...

#include <solid_traction_elements.h>

+ Inheritance diagram for oomph::RefineableFSISolidTractionElement< ELEMENT, DIM >:

Public Member Functions

 RefineableFSISolidTractionElement (FiniteElement *const &element_pt, const int &face_index)
 Constructor: Create element as FSIWallElement (and thus, by inheritance, a GeomObject) with DIM-1 Lagrangian and DIM Eulerian coordinates. By default, we assume that the normal vector computed by the underlying FaceElement points into the fluid. If this is not the case, overwrite this with the access function FSISolidTractionElement::set_normal_pointing_out_of_fluid() Constructor for GeomObject is called explicitly because of virtual inheritance! More...
 
 ~RefineableFSISolidTractionElement ()
 Destructor: empty. More...
 
virtual void fill_in_contribution_to_jacobian (Vector< double > &residuals, DenseMatrix< double > &jacobian)
 Final overload. Get contributions from refineable solid traction element and derivatives from external data. More...
 
- Public Member Functions inherited from oomph::RefineableSolidTractionElement< ELEMENT >
 RefineableSolidTractionElement (FiniteElement *const &element_pt, const int &face_index)
 Constructor, which takes a "bulk" element and the face index. More...
 
 ~RefineableSolidTractionElement ()
 Destructor should not delete anything. More...
 
unsigned ncont_interpolated_values () const
 Number of continuously interpolated values are the same as those in the bulk element. More...
 
void fill_in_contribution_to_residuals (Vector< double > &residuals)
 This function returns just the residuals. More...
 
- Public Member Functions inherited from oomph::SolidTractionElement< ELEMENT >
 SolidTractionElement (FiniteElement *const &element_pt, const int &face_index, const bool &called_from_refineable_constructor=false)
 Constructor, which takes a "bulk" element and the value of the index and its limit. More...
 
void output (std::ostream &outfile)
 Output function. More...
 
void output (FILE *file_pt)
 C_style output function. More...
 
void output (FILE *file_pt, const unsigned &n_plot)
 C-style output function. More...
 
void traction (const Vector< double > &s, Vector< double > &traction)
 Compute traction vector at specified local coordinate Should only be used for post-processing; ignores dependence on integration point! More...
 
- Public Member Functions inherited from oomph::SolidFaceElement
double zeta_nodal (const unsigned &n, const unsigned &k, const unsigned &i) const
 The "global" intrinsic coordinate of the element when viewed as part of a geometric object should be given by the FaceElement representation, by default This final over-ride is required because both SolidFiniteElements and FaceElements overload zeta_nodal. More...
 
double interpolated_xi (const Vector< double > &s, const unsigned &i) const
 Return i-th FE-interpolated Lagrangian coordinate xi[i] at local coordinate s. Overloaded from SolidFiniteElement. Note that the Lagrangian coordinates are those defined in the bulk! For instance, in a 1D FaceElement that is aligned with the Lagrangian coordinate line xi_0=const, only xi_1 will vary in the FaceElement. This may confuse you if you (wrongly!) believe that in a 1D SolidElement there should only a single Lagrangian coordinate, namely xi_0! More...
 
void interpolated_xi (const Vector< double > &s, Vector< double > &xi) const
 Compute FE interpolated Lagrangian coordinate vector xi[] at local coordinate s as Vector. Overloaded from SolidFiniteElement. Note that the Lagrangian coordinates are those defined in the bulk! For instance, in a 1D FaceElement that is aligned with the Lagrangian coordinate line xi_0=const, only xi_1 will vary in the FaceElement. This may confuse you if you (wrongly!) believe that in a 1D SolidElement there should only a single Lagrangian coordinate, namely xi_0! More...
 
- Public Member Functions inherited from oomph::FaceElement
 FaceElement ()
 Constructor: Initialise all appropriate member data. More...
 
virtual ~FaceElement ()
 Empty virtual destructor. More...
 
 FaceElement (const FaceElement &)=delete
 Broken copy constructor. More...
 
const unsigned & boundary_number_in_bulk_mesh () const
 Broken assignment operator. More...
 
void set_boundary_number_in_bulk_mesh (const unsigned &b)
 Set function for the boundary number in bulk mesh. More...
 
double J_eulerian (const Vector< double > &s) const
 Return the Jacobian of mapping from local to global coordinates at local position s. Overloaded from FiniteElement. More...
 
double J_eulerian_at_knot (const unsigned &ipt) const
 Return the Jacobian of the mapping from local to global coordinates at the ipt-th integration point Overloaded from FiniteElement. More...
 
void check_J_eulerian_at_knots (bool &passed) const
 Check that Jacobian of mapping between local and Eulerian coordinates at all integration points is positive. More...
 
double interpolated_x (const Vector< double > &s, const unsigned &i) const
 Return FE interpolated coordinate x[i] at local coordinate s. Overloaded to get information from bulk. More...
 
double interpolated_x (const unsigned &t, const Vector< double > &s, const unsigned &i) const
 Return FE interpolated coordinate x[i] at local coordinate s at previous timestep t (t=0: present; t>0: previous timestep). Overloaded to get information from bulk. More...
 
void interpolated_x (const Vector< double > &s, Vector< double > &x) const
 Return FE interpolated position x[] at local coordinate s as Vector Overloaded to get information from bulk. More...
 
void interpolated_x (const unsigned &t, const Vector< double > &s, Vector< double > &x) const
 Return FE interpolated position x[] at local coordinate s at previous timestep t as Vector (t=0: present; t>0: previous timestep). Overloaded to get information from bulk. More...
 
double interpolated_dxdt (const Vector< double > &s, const unsigned &i, const unsigned &t)
 Return t-th time-derivative of the i-th FE-interpolated Eulerian coordinate at local coordinate s. Overloaded to get information from bulk. More...
 
void interpolated_dxdt (const Vector< double > &s, const unsigned &t, Vector< double > &dxdt)
 Compte t-th time-derivative of the FE-interpolated Eulerian coordinate vector at local coordinate s. Overloaded to get information from bulk. More...
 
int & normal_sign ()
 Sign of outer unit normal (relative to cross-products of tangent vectors in the corresponding "bulk" element. More...
 
int normal_sign () const
 Return sign of outer unit normal (relative to cross-products of tangent vectors in the corresponding "bulk" element. (const version) More...
 
int & face_index ()
 Index of the face (a number that uniquely identifies the face in the element) More...
 
int face_index () const
 Index of the face (a number that uniquely identifies the face in the element) (const version) More...
 
const Vector< double > * tangent_direction_pt () const
 Public access function for the tangent direction pointer. More...
 
void set_tangent_direction (Vector< double > *tangent_direction_pt)
 Set the tangent direction vector. More...
 
void turn_on_warning_for_discontinuous_tangent ()
 Turn on warning for when there may be discontinuous tangent vectors from continuous_tangent_and_outer_unit_normal(...) More...
 
void turn_off_warning_for_discontinuous_tangent ()
 Turn off warning for when there may be discontinuous tangent vectors from continuous_tangent_and_outer_unit_normal(...) More...
 
void continuous_tangent_and_outer_unit_normal (const Vector< double > &s, Vector< Vector< double >> &tang_vec, Vector< double > &unit_normal) const
 Compute the tangent vector(s) and the outer unit normal vector at the specified local coordinate. In two spatial dimensions, a "tangent direction" is not required. In three spatial dimensions, a tangent direction is required (set via set_tangent_direction(...)), and we project the tanent direction on to the surface. The second tangent vector is taken to be the cross product of the projection and the unit normal. More...
 
void continuous_tangent_and_outer_unit_normal (const unsigned &ipt, Vector< Vector< double >> &tang_vec, Vector< double > &unit_normal) const
 Compute the tangent vector(s) and the outer unit normal vector at the ipt-th integration point. This is a wrapper around continuous_tangent_and_outer_unit_normal(...) with the integration points converted into local coordinates. More...
 
void outer_unit_normal (const Vector< double > &s, Vector< double > &unit_normal) const
 Compute outer unit normal at the specified local coordinate. More...
 
void outer_unit_normal (const unsigned &ipt, Vector< double > &unit_normal) const
 Compute outer unit normal at ipt-th integration point. More...
 
FiniteElement *& bulk_element_pt ()
 Pointer to higher-dimensional "bulk" element. More...
 
FiniteElementbulk_element_pt () const
 Pointer to higher-dimensional "bulk" element (const version) More...
 
CoordinateMappingFctPtface_to_bulk_coordinate_fct_pt ()
 Return the pointer to the function that maps the face coordinate to the bulk coordinate. More...
 
CoordinateMappingFctPt face_to_bulk_coordinate_fct_pt () const
 Return the pointer to the function that maps the face coordinate to the bulk coordinate (const version) More...
 
BulkCoordinateDerivativesFctPtbulk_coordinate_derivatives_fct_pt ()
 Return the pointer to the function that returns the derivatives of the bulk coordinates wrt the face coordinates. More...
 
BulkCoordinateDerivativesFctPt bulk_coordinate_derivatives_fct_pt () const
 Return the pointer to the function that returns the derivatives of the bulk coordinates wrt the face coordinates (const version) More...
 
Vector< double > local_coordinate_in_bulk (const Vector< double > &s) const
 Return vector of local coordinates in bulk element, given the local coordinates in this FaceElement. More...
 
void get_local_coordinate_in_bulk (const Vector< double > &s, Vector< double > &s_bulk) const
 Calculate the vector of local coordinate in the bulk element given the local coordinates in this FaceElement. More...
 
void get_ds_bulk_ds_face (const Vector< double > &s, DenseMatrix< double > &dsbulk_dsface, unsigned &interior_direction) const
 Calculate the derivatives of the local coordinates in the bulk element with respect to the local coordinates in this FaceElement. In addition return the index of a bulk local coordinate that varies away from the face. More...
 
unsigned & bulk_position_type (const unsigned &i)
 Return the position type in the "bulk" element that corresponds to position type i on the FaceElement. More...
 
const unsigned & bulk_position_type (const unsigned &i) const
 Return the position type in the "bulk" element that corresponds to the position type i on the FaceElement. Const version. More...
 
void bulk_node_number_resize (const unsigned &i)
 Resize the storage for the bulk node numbers. More...
 
unsigned & bulk_node_number (const unsigned &n)
 Return the bulk node number that corresponds to the n-th local node number. More...
 
const unsigned & bulk_node_number (const unsigned &n) const
 Return the bulk node number that corresponds to the n-th local node number (const version) More...
 
void bulk_position_type_resize (const unsigned &i)
 Resize the storage for bulk_position_type to i entries. More...
 
unsigned & nbulk_value (const unsigned &n)
 Return the number of values originally stored at local node n (before the FaceElement added additional values to it (if it did)) More...
 
unsigned nbulk_value (const unsigned &n) const
 Return the number of values originally stored at local node n (before the FaceElement added additional values to it (if it did)) (const version) More...
 
void nbulk_value_resize (const unsigned &i)
 Resize the storage for the number of values originally stored at the local nodes to i entries. More...
 
void resize_nodes (Vector< unsigned > &nadditional_data_values)
 Provide additional storage for a specified number of values at the nodes of the FaceElement. (This is needed, for instance, in free-surface elements, if the non-penetration condition is imposed by Lagrange multipliers whose values are only stored at the surface nodes but not in the interior of the bulk element). nadditional_data_values[n] specifies the number of additional values required at node n of the FaceElement. Note: Since this function is executed separately for each FaceElement, nodes that are common to multiple elements might be resized repeatedly. To avoid this, we only allow a single resize operation by comparing the number of values stored at each node to the number of values the node had when it was simply a member of the associated "bulk" element. There are cases where this will break! – e.g. if a node is common to two FaceElements which require additional storage for distinct quantities. Such cases need to be handled by "hand-crafted" face elements. More...
 
void output_zeta (std::ostream &outfile, const unsigned &nplot)
 Output boundary coordinate zeta. More...
 
- Public Member Functions inherited from oomph::FiniteElement
void set_dimension (const unsigned &dim)
 Set the dimension of the element and initially set the dimension of the nodes to be the same as the dimension of the element. More...
 
void set_nodal_dimension (const unsigned &nodal_dim)
 Set the dimension of the nodes in the element. This will typically only be required when constructing FaceElements or in beam and shell type elements where a lower dimensional surface is embedded in a higher dimensional space. More...
 
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)
 Set the number of nodes in the element to n, by resizing the storage for pointers to the Node objects. More...
 
int nodal_local_eqn (const unsigned &n, const unsigned &i) const
 Return the local equation number corresponding to the i-th value at the n-th local node. More...
 
double dJ_eulerian_at_knot (const unsigned &ipt, Shape &psi, DenseMatrix< double > &djacobian_dX) const
 Compute the geometric shape functions (psi) at integration point ipt. Return the determinant of the jacobian of the mapping (detJ). Additionally calculate the derivatives of "detJ" w.r.t. the nodal coordinates. More...
 
 FiniteElement ()
 Constructor. More...
 
virtual ~FiniteElement ()
 The destructor cleans up the static memory allocated for shape function storage. Internal and external data get wiped by the GeneralisedElement destructor; nodes get killed in mesh destructor. More...
 
 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
 Adjust local coordinates so that they're located inside the element. More...
 
void get_centre_of_gravity_and_max_radius_in_terms_of_zeta (Vector< double > &cog, double &max_radius) const
 Compute centre of gravity of all nodes and radius of node that is furthest from it. Used to assess approximately if a point is likely to be contained with an element in locate_zeta-like operations. More...
 
virtual void local_coordinate_of_node (const unsigned &j, Vector< double > &s) const
 Get local coordinates of node j in the element; vector sets its own size (broken virtual) More...
 
virtual void local_fraction_of_node (const unsigned &j, Vector< double > &s_fraction)
 Get the local fraction of the node j in the element A dumb, but correct default implementation is provided. More...
 
virtual double local_one_d_fraction_of_node (const unsigned &n1d, const unsigned &i)
 Get the local fraction of any node in the n-th position in a one dimensional expansion along the i-th local coordinate. More...
 
MacroElementmacro_elem_pt ()
 Access function to pointer to macro element. More...
 
void get_x (const Vector< double > &s, Vector< double > &x) const
 Global coordinates as function of local coordinates. Either via FE representation or via macro-element (if Macro_elem_pt!=0) More...
 
void get_x (const unsigned &t, const Vector< double > &s, Vector< double > &x)
 Global coordinates as function of local coordinates at previous time "level" t (t=0: present; t>0: previous). Either via FE representation of QElement or via macro-element (if Macro_elem_pt!=0). More...
 
virtual void get_x_from_macro_element (const Vector< double > &s, Vector< double > &x) const
 Global coordinates as function of local coordinates using macro element representation. (Broken virtual — this must be overloaded in specific geometric element classes) More...
 
virtual void get_x_from_macro_element (const unsigned &t, const Vector< double > &s, Vector< double > &x)
 Global coordinates as function of local coordinates at previous time "level" t (t=0: present; t>0: previous). using macro element representation (Broken virtual – overload in specific geometric element class if you want to use this functionality.) More...
 
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
 Calculate the geometric shape functions at local coordinate s. This function must be overloaded for each specific geometric element. More...
 
virtual void shape_at_knot (const unsigned &ipt, Shape &psi) const
 Return the geometric shape function at the ipt-th integration point. More...
 
virtual void dshape_local (const Vector< double > &s, Shape &psi, DShape &dpsids) const
 Function to compute the geometric shape functions and derivatives w.r.t. local coordinates at local coordinate s. This function must be overloaded for each specific geometric element. (Broken virtual function — specifies the interface) More...
 
virtual void dshape_local_at_knot (const unsigned &ipt, Shape &psi, DShape &dpsids) const
 Return the geometric shape function and its derivative w.r.t. the local coordinates at the ipt-th integration point. More...
 
virtual void d2shape_local (const Vector< double > &s, Shape &psi, DShape &dpsids, DShape &d2psids) const
 Function to compute the geometric shape functions and also first and second derivatives w.r.t. local coordinates at local coordinate s. This function must be overloaded for each specific geometric element (if required). (Broken virtual function — specifies the interface). Numbering: 1D: d2psids(i,0) = $ d^2 \psi_j / ds^2 $ 2D: d2psids(i,0) = $ \partial^2 \psi_j / \partial s_0^2 $ d2psids(i,1) = $ \partial^2 \psi_j / \partial s_1^2 $ d2psids(i,2) = $ \partial^2 \psi_j / \partial s_0 \partial s_1 $ 3D: d2psids(i,0) = $ \partial^2 \psi_j / \partial s_0^2 $ d2psids(i,1) = $ \partial^2 \psi_j / \partial s_1^2 $ d2psids(i,2) = $ \partial^2 \psi_j / \partial s_2^2 $ d2psids(i,3) = $ \partial^2 \psi_j / \partial s_0 \partial s_1 $ d2psids(i,4) = $ \partial^2 \psi_j / \partial s_0 \partial s_2 $ d2psids(i,5) = $ \partial^2 \psi_j / \partial s_1 \partial s_2 $. More...
 
virtual void d2shape_local_at_knot (const unsigned &ipt, Shape &psi, DShape &dpsids, DShape &d2psids) const
 Return the geometric shape function and its first and second derivatives w.r.t. the local coordinates at the ipt-th integration point. Numbering: 1D: d2psids(i,0) = $ d^2 \psi_j / ds^2 $ 2D: d2psids(i,0) = $ \partial^2 \psi_j / \partial s_0^2 $ d2psids(i,1) = $ \partial^2 \psi_j / \partial s_1^2 $ d2psids(i,2) = $ \partial^2 \psi_j / \partial s_0 \partial s_1 $ 3D: d2psids(i,0) = $ \partial^2 \psi_j / \partial s_0^2 $ d2psids(i,1) = $ \partial^2 \psi_j / \partial s_1^2 $ d2psids(i,2) = $ \partial^2 \psi_j / \partial s_2^2 $ d2psids(i,3) = $ \partial^2 \psi_j / \partial s_0 \partial s_1 $ d2psids(i,4) = $ \partial^2 \psi_j / \partial s_0 \partial s_2 $ d2psids(i,5) = $ \partial^2 \psi_j / \partial s_1 \partial s_2 $. More...
 
void check_J_eulerian_at_knots (bool &passed) const
 Check that Jacobian of mapping between local and Eulerian coordinates at all integration points is positive. More...
 
void check_jacobian (const double &jacobian) const
 Helper function used to check for singular or negative Jacobians in the transform from local to global or Lagrangian coordinates. More...
 
double dshape_eulerian (const Vector< double > &s, Shape &psi, DShape &dpsidx) const
 Compute the geometric shape functions and also first derivatives w.r.t. global coordinates at local coordinate s; Returns Jacobian of mapping from global to local coordinates. More...
 
virtual double dshape_eulerian_at_knot (const unsigned &ipt, Shape &psi, DShape &dpsidx) const
 Return the geometric shape functions and also first derivatives w.r.t. global coordinates at the ipt-th integration point. More...
 
virtual double dshape_eulerian_at_knot (const unsigned &ipt, Shape &psi, DShape &dpsi, DenseMatrix< double > &djacobian_dX, RankFourTensor< double > &d_dpsidx_dX) const
 Compute the geometric shape functions (psi) and first derivatives w.r.t. global coordinates (dpsidx) at the ipt-th integration point. Return the determinant of the jacobian of the mapping (detJ). Additionally calculate the derivatives of both "detJ" and "dpsidx" w.r.t. the nodal coordinates. More...
 
double d2shape_eulerian (const Vector< double > &s, Shape &psi, DShape &dpsidx, DShape &d2psidx) const
 Compute the geometric shape functions and also first and second derivatives w.r.t. global coordinates at local coordinate s; Returns Jacobian of mapping from global to local coordinates. Numbering: 1D: d2psidx(i,0) = $ d^2 \psi_j / d x^2 $ 2D: d2psidx(i,0) = $ \partial^2 \psi_j / \partial x_0^2 $ d2psidx(i,1) = $ \partial^2 \psi_j / \partial x_1^2 $ d2psidx(i,2) = $ \partial^2 \psi_j / \partial x_0 \partial x_1 $ 3D: d2psidx(i,0) = $ \partial^2 \psi_j / \partial x_0^2 $ d2psidx(i,1) = $ \partial^2 \psi_j / \partial x_1^2 $ d2psidx(i,2) = $ \partial^2 \psi_j / \partial x_2^2 $ d2psidx(i,3) = $ \partial^2 \psi_j / \partial x_0 \partial x_1 $ d2psidx(i,4) = $ \partial^2 \psi_j / \partial x_0 \partial x_2 $ d2psidx(i,5) = $ \partial^2 \psi_j / \partial x_1 \partial x_2 $. More...
 
virtual double d2shape_eulerian_at_knot (const unsigned &ipt, Shape &psi, DShape &dpsidx, DShape &d2psidx) const
 Return the geometric shape functions and also first and second derivatives w.r.t. global coordinates at ipt-th integration point. Numbering: 1D: d2psidx(i,0) = $ d^2 \psi_j / d s^2 $ 2D: d2psidx(i,0) = $ \partial^2 \psi_j / \partial x_0^2 $ d2psidx(i,1) = $ \partial^2 \psi_j / \partial x_1^2 $ d2psidx(i,2) = $ \partial^2 \psi_j / \partial x_0 \partial x_1 $ 3D: d2psidx(i,0) = $ \partial^2 \psi_j / \partial x_0^2 $ d2psidx(i,1) = $ \partial^2 \psi_j / \partial x_1^2 $ d2psidx(i,2) = $ \partial^2 \psi_j / \partial x_2^2 $ d2psidx(i,3) = $ \partial^2 \psi_j / \partial x_0 \partial x_1 $ d2psidx(i,4) = $ \partial^2 \psi_j / \partial x_0 \partial x_2 $ d2psidx(i,5) = $ \partial^2 \psi_j / \partial x_1 \partial x_2 $. More...
 
virtual void describe_nodal_local_dofs (std::ostream &out, const std::string &current_string) const
 Function to describe the local dofs of the element[s]. The ostream specifies the output stream to which the description is written; the string stores the currently assembled output that is ultimately written to the output stream by Data::describe_dofs(...); it is typically built up incrementally as we descend through the call hierarchy of this function when called from Problem::describe_dofs(...) More...
 
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
 Return the number of nodes along one edge of the element Default is to return zero — must be overloaded by geometric elements. More...
 
double raw_nodal_position (const unsigned &n, const unsigned &i) const
 Return the i-th coordinate at local node n. Do not use the hanging node representation. NOTE: Moved to cc file because of a possible compiler bug in gcc (yes, really!). The move to the cc file avoids inlining which appears to cause problems (only) when compiled with gcc and -O3; offensive "illegal read" is in optimised-out section of code and data that is allegedly illegal is readily readable (by other means) just before this function is called so I can't really see how we could possibly be responsible for this... More...
 
double raw_nodal_position (const unsigned &t, const unsigned &n, const unsigned &i) const
 Return the i-th coordinate at local node n, at time level t (t=0: present; t>0: previous time level). Do not use the hanging node representation. More...
 
double raw_dnodal_position_dt (const unsigned &n, const unsigned &i) const
 Return the i-th component of nodal velocity: dx/dt at local node n. Do not use the hanging node representation. More...
 
double raw_dnodal_position_dt (const unsigned &n, const unsigned &j, const unsigned &i) const
 Return the i-th component of j-th derivative of nodal position: d^jx/dt^j at node n. Do not use the hanging node representation. More...
 
double raw_nodal_position_gen (const unsigned &n, const unsigned &k, const unsigned &i) const
 Return the value of the k-th type of the i-th positional variable at the local node n. Do not use the hanging node representation. More...
 
double raw_nodal_position_gen (const unsigned &t, const unsigned &n, const unsigned &k, const unsigned &i) const
 Return the generalised nodal position (type k, i-th variable) at previous timesteps at local node n. Do not use the hanging node representation. More...
 
double raw_dnodal_position_gen_dt (const unsigned &n, const unsigned &k, const unsigned &i) const
 i-th component of time derivative (velocity) of the generalised position, dx(k,i)/dt at local node n. ‘Type’: k; Coordinate direction: i. Do not use the hanging node representation. More...
 
double raw_dnodal_position_gen_dt (const unsigned &j, const unsigned &n, const unsigned &k, const unsigned &i) const
 i-th component of j-th time derivative of the generalised position, dx(k,i)/dt at local node n. ‘Type’: k; Coordinate direction: i. Do not use the hanging node representation. More...
 
double nodal_position (const unsigned &n, const unsigned &i) const
 Return the i-th coordinate at local node n. If the node is hanging, the appropriate interpolation is handled by the position function in the Node class. More...
 
double nodal_position (const unsigned &t, const unsigned &n, const unsigned &i) const
 Return the i-th coordinate at local node n, at time level t (t=0: present; t>0: previous time level) Returns suitably interpolated version for hanging nodes. More...
 
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
 Return the i-th component of j-th derivative of nodal position: d^jx/dt^j at node n. More...
 
double nodal_position_gen (const unsigned &n, const unsigned &k, const unsigned &i) const
 Return the value of the k-th type of the i-th positional variable at the local node n. More...
 
double nodal_position_gen (const unsigned &t, const unsigned &n, const unsigned &k, const unsigned &i) const
 Return the generalised nodal position (type k, i-th variable) at previous timesteps at local node n. More...
 
double dnodal_position_gen_dt (const unsigned &n, const unsigned &k, const unsigned &i) const
 i-th component of time derivative (velocity) of the generalised position, dx(k,i)/dt at local node n. ‘Type’: k; Coordinate direction: i. More...
 
double dnodal_position_gen_dt (const unsigned &j, const unsigned &n, const unsigned &k, const unsigned &i) const
 i-th component of j-th time derivative of the generalised position, dx(k,i)/dt at local node n. ‘Type’: k; Coordinate direction: i. More...
 
virtual void disable_ALE ()
 This is an empty function that establishes a uniform interface for all (derived) elements that involve time-derivatives. Such elements are/should be implemented in ALE form to allow mesh motions. The additional expense associated with the computation of the mesh velocities is, of course, superfluous if the elements are used in problems in which the mesh is stationary. This function should therefore be overloaded in all derived elements that are formulated in ALE form to suppress the computation of the mesh velocities. The user disables the ALE functionality at his/her own risk! If the mesh does move after all, then the results will be wrong. Here we simply issue a warning message stating that the empty function has been called. More...
 
virtual void enable_ALE ()
 (Re-)enable ALE, i.e. take possible mesh motion into account when evaluating the time-derivative. This function is empty and simply establishes a common interface for all derived elements that are formulated in ALE form. More...
 
virtual unsigned required_nvalue (const unsigned &n) const
 Number of values that must be stored at local node n by the element. The default is 0, until over-ridden by a particular element. For example, a Poisson equation requires only one value to be stored at each node; 2D Navier–Stokes equations require two values (velocity components) to be stored at each Node (provided that the pressure interpolation is discontinuous). More...
 
unsigned nnodal_position_type () const
 Return the number of coordinate types that the element requires to interpolate the geometry between the nodes. For Lagrange elements it is 1. More...
 
bool has_hanging_nodes () const
 Return boolean to indicate if any of the element's nodes are geometrically hanging. More...
 
unsigned nodal_dimension () const
 Return the required Eulerian dimension of the nodes in this element. More...
 
virtual unsigned nvertex_node () const
 Return the number of vertex nodes in this element. Broken virtual function in "pure" finite elements. More...
 
virtual Nodevertex_node_pt (const unsigned &j) const
 Pointer to the j-th vertex node in the element. Broken virtual function in "pure" finite elements. More...
 
int get_node_number (Node *const &node_pt) const
 Return the number of the node *node_pt if this node is in the element, else return -1;. More...
 
virtual Nodeget_node_at_local_coordinate (const Vector< double > &s) const
 If there is a node at this local coordinate, return the pointer to the node. More...
 
double raw_nodal_value (const unsigned &n, const unsigned &i) const
 Return the i-th value stored at local node n but do NOT take hanging nodes into account. More...
 
double raw_nodal_value (const unsigned &t, const unsigned &n, const unsigned &i) const
 Return the i-th value stored at local node n, at time level t (t=0: present; t>0 previous timesteps), but do NOT take hanging nodes into account. More...
 
double nodal_value (const unsigned &n, const unsigned &i) const
 Return the i-th value stored at local node n. Produces suitably interpolated values for hanging nodes. More...
 
double nodal_value (const unsigned &t, const unsigned &n, const unsigned &i) const
 Return the i-th value stored at local node n, at time level t (t=0: present; t>0 previous timesteps). Produces suitably interpolated values for hanging nodes. More...
 
unsigned dim () const
 Return the spatial dimension of the element, i.e. the number of local coordinates required to parametrise its geometry. More...
 
virtual ElementGeometry::ElementGeometry element_geometry () const
 Return the geometry type of the element (either Q or T usually). More...
 
void position (const Vector< double > &zeta, Vector< double > &r) const
 Return the parametrised position of the FiniteElement in its incarnation as a GeomObject, r(zeta). The position is given by the Eulerian coordinate and the intrinsic coordinate (zeta) is the local coordinate of the element (s). More...
 
void position (const unsigned &t, const Vector< double > &zeta, Vector< double > &r) const
 Return the parametrised position of the FiniteElement in its GeomObject incarnation: r(zeta). The position is given by the Eulerian coordinate and the intrinsic coordinate (zeta) is the local coordinate of the element (s) This version of the function returns the position as a function of time t=0: current time; t>0: previous timestep. Works for t=0 but needs to be overloaded if genuine time-dependence is required. More...
 
void dposition_dt (const Vector< double > &zeta, const unsigned &t, Vector< double > &drdt)
 Return the t-th time derivative of the parametrised position of the FiniteElement in its GeomObject incarnation: $ \frac{d^{t} dr(zeta)}{d t^{t}} $. Call the t-th time derivative of the FE-interpolated Eulerian coordinate. More...
 
void interpolated_zeta (const Vector< double > &s, Vector< double > &zeta) const
 Calculate the interpolated value of zeta, the intrinsic coordinate of the element when viewed as a compound geometric object within a Mesh as a function of the local coordinate of the element, s. The default assumption is the zeta is interpolated using the shape functions of the element with the values given by zeta_nodal(). A MacroElement representation of the intrinsic coordinate parametrised by the local coordinate s is used if available. Choosing the MacroElement representation of zeta (Eulerian x by default) allows a correspondence to be established between elements on different Meshes covering the same curvilinear domain in cases where one element is much coarser than the other. More...
 
void locate_zeta (const Vector< double > &zeta, GeomObject *&geom_object_pt, Vector< double > &s, const bool &use_coordinate_as_initial_guess=false)
 For a given value of zeta, the "global" intrinsic coordinate of a mesh of FiniteElements represented as a compound geometric object, find the local coordinate in this element that corresponds to the requested value of zeta. If zeta cannot be located in this element, geom_object_pt is set to NULL. If zeta is located in this element, we return its "this" pointer. By default don't use any value passed in to the local coordinate s as the initial guess in the Newton method. More...
 
virtual void node_update ()
 Update the positions of all nodes in the element using each node update function. The default implementation may be overloaded so that more efficient versions can be written. More...
 
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
 Calculate the size of the element (length, area, volume,...) in Eulerian computational coordinates. Use suitably overloaded compute_physical_size() function to compute the actual size (taking into account factors such as 2pi or radii the integrand) – such function can only be implemented on an equation-by-equation basis. More...
 
virtual double compute_physical_size () const
 Broken virtual function to compute the actual size (taking into account factors such as 2pi or radii the integrand) – such function can only be implemented on an equation-by-equation basis. More...
 
virtual void point_output_data (const Vector< double > &s, Vector< double > &data)
 Virtual function to write the double precision numbers that appear in a single line of output into the data vector. Empty virtual, can be overloaded for specific elements; used e.g. by LineVisualiser. More...
 
void point_output (std::ostream &outfile, const Vector< double > &s)
 Output solution (as defined by point_output_data()) at local cordinates s. More...
 
virtual unsigned nplot_points_paraview (const unsigned &nplot) const
 Return the number of actual plot points for paraview plot with parameter nplot. Broken virtual; can be overloaded in specific elements. More...
 
virtual unsigned nsub_elements_paraview (const unsigned &nplot) const
 Return the number of local sub-elements for paraview plot with parameter nplot. Broken virtual; can be overloaded in specific elements. More...
 
void output_paraview (std::ofstream &file_out, const unsigned &nplot) const
 Paraview output – this outputs the coordinates at the plot points (for parameter nplot) to specified output file. More...
 
virtual void write_paraview_output_offset_information (std::ofstream &file_out, const unsigned &nplot, unsigned &counter) const
 Fill in the offset information for paraview plot. Broken virtual. Needs to be implemented for each new geometric element type; see http://www.vtk.org/VTK/img/file-formats.pdf. More...
 
virtual void write_paraview_type (std::ofstream &file_out, const unsigned &nplot) const
 Return the paraview element type. Broken virtual. Needs to be implemented for each new geometric element type; see http://www.vtk.org/VTK/img/file-formats.pdf. More...
 
virtual void write_paraview_offsets (std::ofstream &file_out, const unsigned &nplot, unsigned &offset_sum) const
 Return the offsets for the paraview sub-elements. Broken virtual. Needs to be implemented for each new geometric element type; see http://www.vtk.org/VTK/img/file-formats.pdf. More...
 
virtual unsigned nscalar_paraview () const
 Number of scalars/fields output by this element. Broken virtual. Needs to be implemented for each new specific element type. More...
 
virtual void scalar_value_paraview (std::ofstream &file_out, const unsigned &i, const unsigned &nplot) const
 Write values of the i-th scalar field at the plot points. Broken virtual. Needs to be implemented for each new specific element type. More...
 
virtual void scalar_value_fct_paraview (std::ofstream &file_out, const unsigned &i, const unsigned &nplot, FiniteElement::SteadyExactSolutionFctPt exact_soln_pt) const
 Write values of the i-th scalar field at the plot points. Broken virtual. Needs to be implemented for each new specific element type. More...
 
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
 Write values of the i-th scalar field at the plot points. Broken virtual. Needs to be implemented for each new specific element type. More...
 
virtual std::string scalar_name_paraview (const unsigned &i) const
 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. More...
 
virtual void output (const unsigned &t, std::ostream &outfile, const unsigned &n_plot) const
 Output the element data at time step t. This is const because it is newly added and so can be done easily. Really all the output(...) functions should be const! More...
 
virtual void output_fct (std::ostream &outfile, const unsigned &n_plot, FiniteElement::SteadyExactSolutionFctPt exact_soln_pt)
 Output an exact solution over the element. More...
 
virtual void output_fct (std::ostream &outfile, const unsigned &n_plot, const double &time, FiniteElement::UnsteadyExactSolutionFctPt exact_soln_pt)
 Output a time-dependent exact solution over the element. More...
 
virtual void output_fct (std::ostream &outfile, const unsigned &n_plot, const double &time, const SolutionFunctorBase &exact_soln) const
 Output a time-dependent exact solution over the element. More...
 
virtual void get_s_plot (const unsigned &i, const unsigned &nplot, Vector< double > &s, const bool &shifted_to_interior=false) const
 Get cector of local coordinates of plot point i (when plotting nplot points in each "coordinate direction"). Generally these plot points will be uniformly spaced across the element. The optional final boolean flag (default: false) allows them to be shifted inwards to avoid duplication of plot point points between elements – useful when they are used in locate_zeta, say. More...
 
virtual std::string tecplot_zone_string (const unsigned &nplot) const
 Return string for tecplot zone header (when plotting nplot points in each "coordinate direction") More...
 
virtual void write_tecplot_zone_footer (std::ostream &outfile, const unsigned &nplot) const
 Add tecplot zone "footer" to output stream (when plotting nplot points in each "coordinate direction"). Empty by default – can be used, e.g., to add FE connectivity lists to elements that need it. More...
 
virtual void write_tecplot_zone_footer (FILE *file_pt, const unsigned &nplot) const
 Add tecplot zone "footer" to C-style output. (when plotting nplot points in each "coordinate direction"). Empty by default – can be used, e.g., to add FE connectivity lists to elements that need it. More...
 
virtual unsigned nplot_points (const unsigned &nplot) const
 Return total number of plot points (when plotting nplot points in each "coordinate direction") More...
 
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)
 Given the exact solution $ {\bf f}({\bf x}) $ this function calculates the norm of the error and that of the exact solution. Version with vectors of norms and errors so that different variables' norms and errors can be returned individually. More...
 
virtual void compute_error (FiniteElement::UnsteadyExactSolutionFctPt exact_soln_pt, const double &time, Vector< double > &error, Vector< double > &norm)
 Given the exact solution $ {\bf f}({\bf x}) $ this function calculates the norm of the error and that of the exact solution. Version with vectors of norms and errors so that different variables' norms and errors can be returned individually. More...
 
virtual void compute_error (std::ostream &outfile, FiniteElement::SteadyExactSolutionFctPt exact_soln_pt, double &error, double &norm)
 Plot the error when compared against a given exact solution $ {\bf f}({\bf x}) $. Also calculates the norm of the error and that of the exact solution. More...
 
virtual void compute_error (std::ostream &outfile, FiniteElement::UnsteadyExactSolutionFctPt exact_soln_pt, const double &time, double &error, double &norm)
 Plot the error when compared against a given time-dependent exact solution $ {\bf f}(t,{\bf x}) $. Also calculates the norm of the error and that of the exact solution. More...
 
virtual void compute_error (std::ostream &outfile, FiniteElement::SteadyExactSolutionFctPt exact_soln_pt, Vector< double > &error, Vector< double > &norm)
 Plot the error when compared against a given exact solution $ {\bf f}({\bf x}) $. Also calculates the norm of the error and that of the exact solution. The version with vectors of norms and errors so that different variables' norms and errors can be returned individually. More...
 
virtual void compute_error (std::ostream &outfile, FiniteElement::UnsteadyExactSolutionFctPt exact_soln_pt, const double &time, Vector< double > &error, Vector< double > &norm)
 Plot the error when compared against a given time-dependent exact solution $ {\bf f}(t,{\bf x}) $. Also calculates the norm of the error and that of the exact solution. The version with vectors of norms and errors so that different variables' norms and errors can be returned individually. More...
 
virtual void compute_abs_error (std::ostream &outfile, FiniteElement::SteadyExactSolutionFctPt exact_soln_pt, double &error)
 Plot the error when compared against a given exact solution $ {\bf f}({\bf x}) $. Also calculates the maximum absolute error. More...
 
void integrate_fct (FiniteElement::SteadyExactSolutionFctPt integrand_fct_pt, Vector< double > &integral)
 Evaluate integral of a Vector-valued function $ {\bf f}({\bf x}) $ over the element. More...
 
void integrate_fct (FiniteElement::UnsteadyExactSolutionFctPt integrand_fct_pt, const double &time, Vector< double > &integral)
 Evaluate integral of a Vector-valued, time-dependent function $ {\bf f}(t,{\bf x}) $ over the element. More...
 
virtual void build_face_element (const int &face_index, FaceElement *face_element_pt)
 Function for building a lower dimensional FaceElement on the specified face of the FiniteElement. The arguments are the index of the face, an integer whose value depends on the particular element type, and a pointer to the FaceElement. More...
 
virtual unsigned self_test ()
 Self-test: Check inversion of element & do self-test for GeneralisedElement. Return 0 if OK. More...
 
virtual unsigned get_bulk_node_number (const int &face_index, const unsigned &i) const
 Get the number of the ith node on face face_index (in the bulk node vector). More...
 
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
 Get a pointer to the function mapping face coordinates to bulk coordinates. More...
 
virtual BulkCoordinateDerivativesFctPt bulk_coordinate_derivatives_fct_pt (const int &face_index) const
 Get a pointer to the derivative of the mapping from face to bulk coordinates. More...
 
- Public Member Functions inherited from oomph::GeneralisedElement
GeneralisedElement() GeneralisedElement (const GeneralisedElement &)=delete
 Constructor: Initialise all pointers and all values to zero. 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
 Return the global equation number corresponding to the ieqn_local-th local equation number. More...
 
int local_eqn_number (const unsigned long &ieqn_global) const
 Return the local equation number corresponding to the ieqn_global-th global equation number. Returns minus one (-1) if there is no local degree of freedom corresponding to the chosen global equation number. More...
 
unsigned add_external_data (Data *const &data_pt, const bool &fd=true)
 Add a (pointer to an) external data object to the element and return its index (i.e. the index required to obtain it from the access function external_data_pt(...). The optional boolean flag indicates whether the data should be included in the general finite-difference loop when calculating the jacobian. The default value is true, i.e. the data will be included in the finite-differencing. More...
 
bool external_data_fd (const unsigned &i) const
 Return the status of the boolean flag indicating whether the external data is included in the finite difference loop. More...
 
void exclude_external_data_fd (const unsigned &i)
 Set the boolean flag to exclude the external datum from the the finite difference loop when computing the jacobian matrix. More...
 
void include_external_data_fd (const unsigned &i)
 Set the boolean flag to include the external datum in the the finite difference loop when computing the jacobian matrix. More...
 
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)
 Set the timestepper associated with the i-th internal data object. More...
 
void assign_internal_eqn_numbers (unsigned long &global_number, Vector< double * > &Dof_pt)
 Assign the global equation numbers to the internal Data. The arguments are the current highest global equation number (which will be incremented) and a Vector of pointers to the global variables (to which any unpinned values in the internal Data are added). More...
 
void describe_dofs (std::ostream &out, const std::string &current_string) const
 Function to describe the dofs of the element. The ostream specifies the output stream to which the description is written; the string stores the currently assembled output that is ultimately written to the output stream by Data::describe_dofs(...); it is typically built up incrementally as we descend through the call hierarchy of this function when called from Problem::describe_dofs(...) More...
 
void add_internal_value_pt_to_map (std::map< unsigned, double * > &map_of_value_pt)
 Add pointers to the internal data values to map indexed by the global equation number. More...
 
void add_internal_data_values_to_vector (Vector< double > &vector_of_values)
 Add all internal data and time history values to the vector in the internal storage order. More...
 
void read_internal_data_values_from_vector (const Vector< double > &vector_of_values, unsigned &index)
 Read all internal data and time history values from the vector starting from index. On return the index will be set to the value at the end of the data that has been read in. More...
 
void add_internal_eqn_numbers_to_vector (Vector< long > &vector_of_eqn_numbers)
 Add all equation numbers associated with internal data to the vector in the internal storage order. More...
 
void read_internal_eqn_numbers_from_vector (const Vector< long > &vector_of_eqn_numbers, unsigned &index)
 Read all equation numbers associated with internal data from the vector starting from index. On return the index will be set to the value at the end of the data that has been read in. More...
 
virtual void assign_local_eqn_numbers (const bool &store_local_dof_pt)
 Setup the arrays of local equation numbers for the element. If the optional boolean argument is true, then pointers to the associated degrees of freedom are stored locally in the array Dof_pt. More...
 
virtual void complete_setup_of_dependencies ()
 Complete the setup of any additional dependencies that the element may have. Empty virtual function that may be overloaded for specific derived elements. Used, e.g., for elements with algebraic node update functions to determine the "geometric Data", i.e. the Data that affects the element's shape. This function is called (for all elements) at the very beginning of the equation numbering procedure to ensure that all dependencies are accounted for. More...
 
virtual void get_residuals (Vector< double > &residuals)
 Calculate the vector of residuals of the equations in the element. By default initialise the vector to zero and then call the fill_in_contribution_to_residuals() function. Note that this entire function can be overloaded if desired. More...
 
virtual void get_jacobian (Vector< double > &residuals, DenseMatrix< double > &jacobian)
 Calculate the elemental Jacobian matrix "d equation / d variable". More...
 
virtual void get_mass_matrix (Vector< double > &residuals, DenseMatrix< double > &mass_matrix)
 Calculate the residuals and the elemental "mass" matrix, the matrix that multiplies the time derivative terms in a problem. More...
 
virtual void get_jacobian_and_mass_matrix (Vector< double > &residuals, DenseMatrix< double > &jacobian, DenseMatrix< double > &mass_matrix)
 Calculate the residuals and jacobian and elemental "mass" matrix, the matrix that multiplies the time derivative terms. More...
 
virtual void get_dresiduals_dparameter (double *const &parameter_pt, Vector< double > &dres_dparam)
 Calculate the derivatives of the residuals with respect to a parameter. More...
 
virtual void get_djacobian_dparameter (double *const &parameter_pt, Vector< double > &dres_dparam, DenseMatrix< double > &djac_dparam)
 Calculate the derivatives of the elemental Jacobian matrix and residuals with respect to a parameter. More...
 
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)
 Calculate the derivatives of the elemental Jacobian matrix mass matrix and residuals with respect to a parameter. More...
 
virtual void get_hessian_vector_products (Vector< double > const &Y, DenseMatrix< double > const &C, DenseMatrix< double > &product)
 Calculate the product of the Hessian (derivative of Jacobian with respect to all variables) an eigenvector, Y, and other specified vectors, C (d(J_{ij})/d u_{k}) Y_{j} C_{k}. More...
 
virtual void get_inner_products (Vector< std::pair< unsigned, unsigned >> const &history_index, Vector< double > &inner_product)
 Return the vector of inner product of the given pairs of history values. More...
 
virtual void get_inner_product_vectors (Vector< unsigned > const &history_index, Vector< Vector< double >> &inner_product_vector)
 Compute the vectors that when taken as a dot product with other history values give the inner product over the element. More...
 
virtual void compute_norm (Vector< double > &norm)
 Compute norm of solution – broken virtual can be overloaded by element writer to implement whatever norm is desired for the specific element. More...
 
void set_halo (const unsigned &non_halo_proc_ID)
 Label the element as halo and specify processor that holds non-halo counterpart. More...
 
void set_nonhalo ()
 Label the element as not being a halo. More...
 
bool is_halo () const
 Is this element a halo? More...
 
int non_halo_proc_ID ()
 ID of processor ID that holds non-halo counterpart of halo element; negative if not a halo. More...
 
void set_must_be_kept_as_halo ()
 Insist that this element be kept as a halo element during a distribute? More...
 
void unset_must_be_kept_as_halo ()
 Do not insist that this element be kept as a halo element during distribution. More...
 
bool must_be_kept_as_halo () const
 Test whether the element must be kept as a halo element. More...
 
- Public Member Functions inherited from oomph::GeomObject
 GeomObject ()
 Default constructor. More...
 
 GeomObject (const unsigned &ndim)
 Constructor: Pass dimension of geometric object (# of Eulerian coords = # of Lagrangian coords; no time history available/needed) More...
 
 GeomObject (const unsigned &nlagrangian, const unsigned &ndim)
 Constructor: pass # of Eulerian and Lagrangian coordinates. No time history available/needed. More...
 
 GeomObject (const unsigned &nlagrangian, const unsigned &ndim, TimeStepper *time_stepper_pt)
 Constructor: pass # of Eulerian and Lagrangian coordinates and pointer to time-stepper which is used to handle the position at previous timesteps and allows the evaluation of veloc/acceleration etc. in cases where the GeomData varies with time. More...
 
 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 ()
 Access function for pointer to time stepper: Null if object is not time-dependent. More...
 
TimeSteppertime_stepper_pt () const
 Access function for pointer to time stepper: Null if object is not time-dependent. Const version. More...
 
virtual void position (const double &t, const Vector< double > &zeta, Vector< double > &r) const
 Parametrised position on object: r(zeta). Evaluated at the continuous time value, t. More...
 
virtual void dposition (const Vector< double > &zeta, DenseMatrix< double > &drdzeta) const
 Derivative of position Vector w.r.t. to coordinates: $ \frac{dR_i}{d \zeta_\alpha}$ = drdzeta(alpha,i). Evaluated at current time. More...
 
virtual void d2position (const Vector< double > &zeta, RankThreeTensor< double > &ddrdzeta) const
 2nd derivative of position Vector w.r.t. to coordinates: $ \frac{d^2R_i}{d \zeta_\alpha d \zeta_\beta}$ = ddrdzeta(alpha,beta,i). Evaluated at current time. More...
 
virtual void d2position (const Vector< double > &zeta, Vector< double > &r, DenseMatrix< double > &drdzeta, RankThreeTensor< double > &ddrdzeta) const
 Posn Vector and its 1st & 2nd derivatives w.r.t. to coordinates: $ \frac{dR_i}{d \zeta_\alpha}$ = drdzeta(alpha,i). $ \frac{d^2R_i}{d \zeta_\alpha d \zeta_\beta}$ = ddrdzeta(alpha,beta,i). Evaluated at current time. More...
 
- Public Member Functions inherited from oomph::SolidFiniteElement
void set_lagrangian_dimension (const unsigned &lagrangian_dimension)
 Set the lagrangian dimension of the element — the number of lagrangian coordinates stored at the nodes in the element. More...
 
virtual bool has_internal_solid_data ()
 Return whether there is internal solid data (e.g. discontinuous solid pressure). At present, this is used to report an error in setting initial conditions for ElasticProblems which can't handle such cases. The default is false. More...
 
 SolidFiniteElement ()
 Constructor: Set defaults. More...
 
virtual ~SolidFiniteElement ()
 Destructor to clean up any allocated memory. More...
 
 SolidFiniteElement (const SolidFiniteElement &)=delete
 Broken copy constructor. More...
 
virtual void get_x_and_xi (const Vector< double > &s, Vector< double > &x_fe, Vector< double > &x, Vector< double > &xi_fe, Vector< double > &xi) const
 Eulerian and Lagrangian coordinates as function of the local coordinates: The Eulerian position is returned in FE-interpolated form (x_fe) and then in the form obtained from the "current" MacroElement representation (if it exists – if not, x is the same as x_fe). This allows the Domain/MacroElement- based representation to be used to apply displacement boundary conditions exactly. Ditto for the Lagrangian coordinates returned in xi_fe and xi. (Broken virtual – overload in specific geometric element class if you want to use this functionality.) More...
 
virtual void set_macro_elem_pt (MacroElement *macro_elem_pt)
 Set pointer to MacroElement – overloads generic version and uses the MacroElement also as the default for the "undeformed" configuration. This assignment must be overwritten with set_undeformed_macro_elem_pt(...) if the deformation of the solid body is driven by a deformation of the "current" Domain/MacroElement representation of it's boundary. Can be overloaded in derived classes to perform additional tasks. More...
 
virtual void set_macro_elem_pt (MacroElement *macro_elem_pt, MacroElement *undeformed_macro_elem_pt)
 Set pointers to "current" and "undeformed" MacroElements. Can be overloaded in derived classes to perform additional tasks. More...
 
void set_undeformed_macro_elem_pt (MacroElement *undeformed_macro_elem_pt)
 Set pointer to "undeformed" macro element. Can be overloaded in derived classes to perform additional tasks. More...
 
MacroElementundeformed_macro_elem_pt ()
 Access function to pointer to "undeformed" macro element. More...
 
double dshape_lagrangian (const Vector< double > &s, Shape &psi, DShape &dpsidxi) const
 Calculate shape functions and derivatives w.r.t. Lagrangian coordinates at local coordinate s. Returns the Jacobian of the mapping from Lagrangian to local coordinates. More...
 
virtual double dshape_lagrangian_at_knot (const unsigned &ipt, Shape &psi, DShape &dpsidxi) const
 Return the geometric shape functions and also first derivatives w.r.t. Lagrangian coordinates at ipt-th integration point. More...
 
double d2shape_lagrangian (const Vector< double > &s, Shape &psi, DShape &dpsidxi, DShape &d2psidxi) const
 Compute the geometric shape functions and also first and second derivatives w.r.t. Lagrangian coordinates at local coordinate s; Returns Jacobian of mapping from Lagrangian to local coordinates. Numbering: 1D: d2pidxi(i,0) = $ d^2 \psi_j / d \xi^2 $ 2D: d2psidxi(i,0) = $ \partial^2 \psi_j / \partial \xi_0^2 $ d2psidxi(i,1) = $ \partial^2 \psi_j / \partial \xi_1^2 $ d2psidxi(i,2) = $ \partial^2 \psi_j / \partial \xi_0 \partial \xi_1 $ 3D: d2psidxi(i,0) = $ \partial^2 \psi_j / \partial \xi_0^2 $ d2psidxi(i,1) = $ \partial^2 \psi_j / \partial \xi_1^2 $ d2psidxi(i,2) = $ \partial^2 \psi_j / \partial \xi_2^2 $ d2psidxi(i,3) = $ \partial^2 \psi_j/\partial \xi_0 \partial \xi_1 $ d2psidxi(i,4) = $ \partial^2 \psi_j/\partial \xi_0 \partial \xi_2 $ d2psidxi(i,5) = $ \partial^2 \psi_j/\partial \xi_1 \partial \xi_2 $. More...
 
virtual double d2shape_lagrangian_at_knot (const unsigned &ipt, Shape &psi, DShape &dpsidxi, DShape &d2psidxi) const
 Return the geometric shape functions and also first and second derivatives w.r.t. Lagrangian coordinates at the ipt-th integration point. Returns Jacobian of mapping from Lagrangian to local coordinates. Numbering: 1D: d2pidxi(i,0) = $ d^2 \psi_j / d^2 \xi^2 $ 2D: d2psidxi(i,0) = $ \partial^2 \psi_j/\partial^2 \xi_0^2 $ d2psidxi(i,1) = $ \partial^2 \psi_j/\partial^2 \xi_1^2 $ d2psidxi(i,2) = $ \partial^2 \psi_j/\partial \xi_0 \partial \xi_1 $ 3D: d2psidxi(i,0) = $ \partial^2 \psi_j / \partial^2 \xi_0^2 $ d2psidxi(i,1) = $ \partial^2 \psi_j / \partial^2 \xi_1^2 $ d2psidxi(i,2) = $ \partial^2 \psi_j / \partial^2 \xi_2^2 $ d2psidxi(i,3) = $ \partial^2 \psi_j / \partial \xi_0 \partial \xi_1 $ d2psidxi(i,4) = $ \partial^2 \psi_j / \partial \xi_0 \partial \xi_2 $ d2psidxi(i,5) = $ \partial^2 \psi_j / \partial \xi_1 \partial \xi_2 $. More...
 
unsigned lagrangian_dimension () const
 Return the number of Lagrangian coordinates that the element requires at all nodes. This is by default the elemental dimension. If we ever need any other case, it can be implemented. More...
 
unsigned nnodal_lagrangian_type () const
 Return the number of types of (generalised) nodal Lagrangian coordinates required to interpolate the Lagrangian coordinates in the element. (E.g. 1 for Lagrange-type elements; 2 for Hermite beam elements; 4 for Hermite shell elements). Default value is 1. Needs to be overloaded for any other element. More...
 
Nodeconstruct_node (const unsigned &n)
 Construct the local node n and return a pointer to it. More...
 
Nodeconstruct_node (const unsigned &n, TimeStepper *const &time_stepper_pt)
 Construct the local node n and return a pointer to it. Additionally, create storage for ‘history’ values as required by timestepper. More...
 
Nodeconstruct_boundary_node (const unsigned &n)
 Construct the local node n and return a pointer to it. in the case when it is a boundary node; that is it MAY be located on a Mesh boundary. More...
 
Nodeconstruct_boundary_node (const unsigned &n, TimeStepper *const &time_stepper_pt)
 Construct the local node n and return a pointer to it, in the case when the node MAY be located on a boundary. Additionally, create storage for ‘history’ values as required by timestepper. More...
 
virtual void assign_all_generic_local_eqn_numbers (const bool &store_local_dof_pt)
 Overload assign_all_generic_local_equation numbers to include the data associated with solid dofs. It remains virtual so that it can be overloaded by RefineableSolidElements. If the boolean argument is true then the degrees of freedom are stored in Dof_pt. More...
 
double raw_lagrangian_position (const unsigned &n, const unsigned &i) const
 Return i-th Lagrangian coordinate at local node n without using the hanging representation. More...
 
double raw_lagrangian_position_gen (const unsigned &n, const unsigned &k, const unsigned &i) const
 Return Generalised Lagrangian coordinate at local node n. ‘Direction’ i, ‘Type’ k. Does not use the hanging node representation. More...
 
double lagrangian_position (const unsigned &n, const unsigned &i) const
 Return i-th Lagrangian coordinate at local node n. More...
 
double lagrangian_position_gen (const unsigned &n, const unsigned &k, const unsigned &i) const
 Return Generalised Lagrangian coordinate at local node n. ‘Direction’ i, ‘Type’ k. More...
 
virtual void interpolated_dxids (const Vector< double > &s, DenseMatrix< double > &dxids) const
 Compute derivatives of FE-interpolated Lagrangian coordinates xi with respect to local coordinates: dxids[i][j]=dxi_i/ds_j. More...
 
virtual void J_lagrangian (const Vector< double > &s) const
 Return the Jacobian of mapping from local to Lagrangian coordinates at local position s. NOT YET IMPLEMENTED. More...
 
virtual double J_lagrangian_at_knot (const unsigned &ipt) const
 Return the Jacobian of the mapping from local to Lagrangian coordinates at the ipt-th integration point. NOT YET IMPLEMENTED. More...
 
SolidInitialCondition *& solid_ic_pt ()
 Pointer to object that describes the initial condition. More...
 
void enable_solve_for_consistent_newmark_accel ()
 Set to alter the problem being solved when assigning the initial conditions for time-dependent problems: solve for the history value that corresponds to the acceleration in the Newmark scheme by demanding that the PDE is satisifed at the initial time. In this case the Jacobian is replaced by the mass matrix. More...
 
void disable_solve_for_consistent_newmark_accel ()
 Set to reset the problem being solved to be the standard problem. More...
 
MultiplierFctPtmultiplier_fct_pt ()
 Access function: Pointer to multiplicator function for assignment of consistent assignement of initial conditions for Newmark scheme. More...
 
MultiplierFctPt multiplier_fct_pt () const
 Access function: Pointer to multiplicator function for assignment of consistent assignement of initial conditions for Newmark scheme (const version) More...
 
virtual void get_residuals_for_solid_ic (Vector< double > &residuals)
 Compute the residuals for the setup of an initial condition. The global equations are: More...
 
void fill_in_residuals_for_solid_ic (Vector< double > &residuals)
 Fill in the residuals for the setup of an initial condition. The global equations are: More...
 
void fill_in_jacobian_for_solid_ic (Vector< double > &residuals, DenseMatrix< double > &jacobian)
 Fill in the residuals and Jacobian for the setup of an initial condition. The global equations are: More...
 
void fill_in_jacobian_for_newmark_accel (DenseMatrix< double > &jacobian)
 Fill in the contributions of the Jacobian matrix for the consistent assignment of the initial "accelerations" in Newmark scheme. In this case the Jacobian is the mass matrix. More...
 
void compute_norm (double &el_norm)
 Calculate the L2 norm of the displacement u=R-r to overload the compute_norm function in the GeneralisedElement base class. More...
 
int position_local_eqn (const unsigned &n, const unsigned &k, const unsigned &j) const
 Access function that returns the local equation number that corresponds to the j-th coordinate of the k-th position-type at the n-th local node. More...
 
- Public Member Functions inherited from oomph::NonRefineableElementWithHangingNodes
void build (Mesh *&mesh_pt, Vector< Node * > &new_node_pt, bool &was_already_built, std::ofstream &new_nodes_file)
 Broken build function – shouldn't really be needed. More...
 
void get_interpolated_values (const Vector< double > &s, Vector< double > &values)
 Broken function – this shouldn't really be needed. More...
 
virtual void get_interpolated_values (const unsigned &t, const Vector< double > &s, Vector< double > &values)
 Broken function – this shouldn't really be needed. More...
 
void check_integrity (double &max_error)
 Broken function – this shouldn't really be needed. More...
 
void rebuild_from_sons (Mesh *&mesh_pt)
 Broken function – this shouldn't really be needed. More...
 
- Public Member Functions inherited from oomph::RefineableElement
 RefineableElement ()
 Constructor, calls the FiniteElement constructor and initialises the member data. More...
 
virtual ~RefineableElement ()
 Destructor, delete the allocated storage for the hanging equations. More...
 
 RefineableElement (const RefineableElement &)=delete
 Broken copy constructor. More...
 
void operator= (const RefineableElement &)=delete
 Broken assignment operator. More...
 
Treetree_pt ()
 Access function: Pointer to quadtree representation of this element. More...
 
void set_tree_pt (Tree *my_tree_pt)
 Set pointer to quadtree representation of this element. More...
 
virtual unsigned required_nsons () const
 Set the number of sons that can be constructed by the element The default is none. More...
 
bool refinement_is_enabled ()
 Flag to indicate suppression of any refinement. More...
 
void disable_refinement ()
 Suppress of any refinement for this element. More...
 
void enable_refinement ()
 Emnable refinement for this element. More...
 
template<class ELEMENT >
void split (Vector< ELEMENT * > &son_pt) const
 Split the element into the number of sons to be constructed and return a vector of pointers to the sons. Elements are allocated, but they are not given any properties. The refinement level of the sons is one higher than that of the father elemern. More...
 
int local_hang_eqn (Node *const &node_pt, const unsigned &i)
 Access function that returns the local equation number for the hanging node variables (values stored at master nodes). The local equation number corresponds to the i-th unknown stored at the node addressed by node_pt. More...
 
void set_refinement_level (const int &refine_level)
 Set the refinement level. More...
 
unsigned refinement_level () const
 Return the Refinement level. More...
 
void select_for_refinement ()
 Select the element for refinement. More...
 
void deselect_for_refinement ()
 Deselect the element for refinement. More...
 
void select_sons_for_unrefinement ()
 Unrefinement will be performed by merging the four sons of this element. More...
 
void deselect_sons_for_unrefinement ()
 No unrefinement will be performed by merging the four sons of this element. More...
 
bool to_be_refined ()
 Has the element been selected for refinement? More...
 
bool sons_to_be_unrefined ()
 Has the element been selected for unrefinement? More...
 
virtual void unbuild ()
 Unbuild the element, i.e. mark the nodes that were created during its creation for possible deletion. More...
 
virtual void deactivate_element ()
 Final operations that must be performed when the element is no longer active in the mesh, but still resident in the QuadTree. More...
 
virtual bool nodes_built ()
 Return true if all the nodes have been built, false if not. More...
 
long number () const
 Element number (for debugging/plotting) More...
 
void set_number (const long &mynumber)
 Set element number (for debugging/plotting) More...
 
virtual Nodeinterpolating_node_pt (const unsigned &n, const int &value_id)
 In mixed elements, different sets of nodes are used to interpolate different unknowns. This function returns the n-th node that interpolates the value_id-th unknown. Default implementation is that all variables use the positional nodes, i.e. isoparametric elements. Note that any overloaded versions of this function MUST provide a set of nodes for the position, which always has the value_id -1. More...
 
virtual double local_one_d_fraction_of_interpolating_node (const unsigned &n1d, const unsigned &i, const int &value_id)
 Return the local one dimensional fraction of the n1d-th node in the direction of the local coordinate s[i] that is used to interpolate the value_id-th continuously interpolated unknown. Default assumes isoparametric interpolation for all unknowns. More...
 
virtual Nodeget_interpolating_node_at_local_coordinate (const Vector< double > &s, const int &value_id)
 Return a pointer to the node that interpolates the value-id-th unknown at local coordinate s. If there is not a node at that position, then return 0. More...
 
virtual unsigned ninterpolating_node (const int &value_id)
 Return the number of nodes that are used to interpolate the value_id-th unknown. Default is to assume isoparametric elements. More...
 
virtual unsigned ninterpolating_node_1d (const int &value_id)
 Return the number of nodes in a one_d direction that are used to interpolate the value_id-th unknown. Default is to assume an isoparametric mapping. More...
 
virtual void interpolating_basis (const Vector< double > &s, Shape &psi, const int &value_id) const
 Return the basis functions that are used to interpolate the value_id-th unknown. By default assume isoparameteric interpolation. More...
 
void identify_field_data_for_interactions (std::set< std::pair< Data *, unsigned >> &paired_field_data)
 The purpose of this function is to identify all possible Data that can affect the fields interpolated by the FiniteElement. This must be overloaded to include data from any hanging nodes correctly. More...
 
void assign_nodal_local_eqn_numbers (const bool &store_local_dof_pt)
 Overload the function that assigns local equation numbers for the Data stored at the nodes so that hanging data is taken into account. More...
 
virtual RefineableElementroot_element_pt ()
 Pointer to the root element in refinement hierarchy (must be implemented in specific elements that do refinement via tree-like refinement structure. Here we provide a default implementation that is appropriate for cases where tree-like refinement doesn't exist or if the element doesn't have root in that tree (i.e. if it's a root itself): We return "this". More...
 
virtual RefineableElementfather_element_pt () const
 Return a pointer to the father element. More...
 
void get_father_at_refinement_level (unsigned &refinement_level, RefineableElement *&father_at_reflevel_pt)
 Return a pointer to the "father" element at the specified refinement level. More...
 
virtual void initial_setup (Tree *const &adopted_father_pt=0, const unsigned &initial_p_order=0)
 Initial setup of the element: e.g. set the appropriate internal p-order. If an adopted father is specified, information from this is used instead of using the father found from the tree. More...
 
virtual void pre_build (Mesh *&mesh_pt, Vector< Node * > &new_node_pt)
 Pre-build the element. More...
 
virtual void setup_hanging_nodes (Vector< std::ofstream * > &output_stream)
 Mark up any hanging nodes that arise as a result of non-uniform refinement. Any hanging nodes will be documented in files addressed by the streams in the vector output_stream, if the streams are open. More...
 
virtual void further_setup_hanging_nodes ()
 Perform additional hanging node procedures for variables that are not interpolated by all nodes (e.g. lower order interpolations for the pressure in Taylor Hood). More...
 
void get_dresidual_dnodal_coordinates (RankThreeTensor< double > &dresidual_dnodal_coordinates)
 Compute derivatives of elemental residual vector with respect to nodal coordinates. Default implementation by FD can be overwritten for specific elements. dresidual_dnodal_coordinates(l,i,j) = d res(l) / dX_{ij} This version is overloaded from the version in FiniteElement and takes hanging nodes into account – j in the above loop loops over all the nodes that actively control the shape of the element (i.e. they are non-hanging or master nodes of hanging nodes in this element). More...
 
unsigned nshape_controlling_nodes ()
 Number of shape-controlling nodes = the number of non-hanging nodes plus the number of master nodes associated with hanging nodes. More...
 
std::map< Node *, unsigned > shape_controlling_node_lookup ()
 Return lookup scheme for unique number associated with any of the nodes that actively control the shape of the element (i.e. they are either non-hanging nodes of this element or master nodes of hanging nodes. More...
 
- Public Member Functions inherited from oomph::RefineableSolidElement
 RefineableSolidElement ()
 Constructor. More...
 
virtual ~RefineableSolidElement ()
 Virtual Destructor, delete any allocated storage. More...
 
void assign_solid_local_eqn_numbers (const bool &store_local_dof_pt)
 Overload the local equation numbers for Data stored as part of solid nodes to include hanging node data. More...
 
unsigned ngeom_data () const
 The number of geometric data affecting a RefineableSolidFiniteElement is the positional Data of all non-hanging nodes plus the geometric Data of all distinct master nodes. Recomputed on the fly. More...
 
Datageom_data_pt (const unsigned &j)
 Return pointer to the j-th Data item that the object's shape depends on: Positional data of non-hanging nodes and positional data of master nodes. Recomputed on the fly. More...
 
void identify_geometric_data (std::set< Data * > &geometric_data_pt)
 Specify Data that affects the geometry of the element by adding the position Data to the set that's passed in. (This functionality is required in FSI problems; set is used to avoid double counting). Refineable version includes hanging nodes. More...
 
void fill_in_jacobian_from_solid_position_by_fd (Vector< double > &residuals, DenseMatrix< double > &jacobian)
 Compute element residual Vector and element Jacobian matrix corresponding to the solid positions. Overloaded version to take the hanging nodes into account. More...
 
bool is_undeformed_macro_element_used_for_new_lagrangian_coords () const
 Return the flag deciding if the Lagrangian coordinates of newly-created interior SolidNodes are to be determined by the father element's undeformed MacroElement representation (if it has one). Default: False as it means that, following a refinement an element is no longer in equilbrium (as the Lagrangian coordinate is determined differently from the Eulerian one). However, basing the Lagrangian coordinates on the undeformed MacroElement can be more stable numerically and for steady problems it's not a big deal either way as the difference between the two formulations only matters at finite resolution so we have no right to say that one is "more correct" than the other... More...
 
void enable_use_of_undeformed_macro_element_for_new_lagrangian_coords ()
 Set the flag deciding if the Lagrangian coordinates of newly-created interior SolidNodes are to be determined by the father element's undeformed MacroElement representation (if it has one). More...
 
void disable_use_of_undeformed_macro_element_for_new_lagrangian_coords ()
 Unset the flag deciding if the Lagrangian coordinates of newly-created interior SolidNodes are to be determined by the father element's undeformed MacroElement representation (if it has one). More...
 
DenseMatrix< int > & local_position_hang_eqn (Node *const &node_pt)
 Access the local equation number of of hanging node variables associated with nodal positions. The function returns a dense matrix that contains all the local equation numbers corresponding to the positional degrees of freedom. More...
 
virtual void further_build ()
 Further build: Pass the father's Use_undeformed_macro_element_for_new_lagrangian_coords flag down, then call the underlying RefineableElement's version. More...
 
- Public Member Functions inherited from oomph::FSISolidTractionElement< ELEMENT, DIM >
 FSISolidTractionElement (FiniteElement *const &element_pt, const int &face_index, const bool &called_from_refineable_constructor=false)
 Constructor: Create element as FSIWallElement (and thus, by inheritance, a GeomObject) with DIM-1 Lagrangian and DIM Eulerian coordinates. By default, we assume that the normal vector computed by the underlying FaceElement points into the fluid. If this is not the case, overwrite this with the access function FSISolidTractionElement::set_normal_pointing_out_of_fluid() Constructor for GeomObject is called explicitly because of virtual inheritance! More...
 
 ~FSISolidTractionElement ()
 Destructor: empty. More...
 
void set_normal_pointing_into_fluid ()
 Set the normal computed by underlying FaceElement to point into the fluid. More...
 
void set_normal_pointing_out_of_fluid ()
 Set the normal computed by underlying FaceElement to point out of the fluid. More...
 
void dposition_dlagrangian_at_local_coordinate (const Vector< double > &s, DenseMatrix< double > &drdxi) const
 Derivative of position vector w.r.t. the SolidFiniteElement's Lagrangian coordinates; evaluated at current time. More...
 
virtual void get_traction (const unsigned &intpt, const Vector< double > &xi, const Vector< double > &x, const Vector< double > &n, Vector< double > &traction)
 Get the load vector: Pass number of the integration point, Lagr. coordinate, Eulerian coordinate (neither of the last two are used in the FSI implementation of this function!) and normal vector and return the load vector, taking the sign of the normal into account. More...
 
void output (std::ostream &outfile, const unsigned &n_plot)
 Output function: Note we can only output the traction at Gauss points so n_plot is actually ignored. More...
 
unsigned ndof_types () const
 The number of "DOF types" that degrees of freedom in this element are sub-divided into: Just the solid degrees of freedom themselves. More...
 
void get_dof_numbers_for_unknowns (std::list< std::pair< unsigned long, unsigned >> &dof_lookup_list) const
 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 types" that this unknown is associated with. (Function can obviously only be called if the equation numbering scheme has been set up.) More...
 
- Public Member Functions inherited from oomph::FSIWallElement
void describe_local_dofs (std::ostream &out, const std::string &current_string) const
 Function to describe the local dofs of the element. The ostream specifies the output stream to which the description is written; the string stores the currently assembled output that is ultimately written to the output stream by Data::describe_dofs(...); it is typically built up incrementally as we descend through the call hierarchy of this function when called from Problem::describe_dofs(...) More...
 
 FSIWallElement ()
 Constructor. Note that element is not fully-functional until its setup_fsi_wall_element() function has been called! More...
 
 FSIWallElement (const FSIWallElement &)=delete
 Broken copy constructor. More...
 
void operator= (const FSIWallElement &)=delete
 Broken assignment operator. More...
 
virtual ~FSIWallElement ()
 Empty virtual destructor for safety. More...
 
void setup_fsi_wall_element (const unsigned &nlagr_solid, const unsigned &ndim_fluid)
 Setup: Assign storage – pass the Eulerian dimension of the "adjacent" fluid elements and the number of local coordinates required to parametrise the wall element. E.g. for a FSIKirchhoffLoveBeam, bounding a 2D fluid domain ndim_fluid=2 and nlagr_solid=1. More...
 
const double & q () const
 Return the ratio of the stress scales used to non-dimensionalise the fluid and solid equations. E.g. $ Q = \mu U/(LE) $ if the fluid mechanics stresses (pressures) are scaled on the viscous scale $ \mu U / L$ and the solid mechanics stresses on the solid's Young's modulus $ E $. More...
 
double *& q_pt ()
 Return a pointer the ratio of stress scales used to non-dimensionalise the fluid and solid equations. More...
 
void enable_fluid_loading_on_both_sides ()
 Allow element to be loaded by fluid on both sides. (Resizes containers for lookup schemes and initialises data associated with elements at the "back" of the FSIWallElement to NULL. More...
 
bool only_front_is_loaded_by_fluid () const
 Is the element exposed to (and hence loaded by) fluid only on its "front"? True by default. This flag is set to false if the FSIWallElement is immersed in fluid in which case each integration point is loaded by two adjacent fluid elements, one at the "front" and one at the "back". This is a read-only function – the ability have loading from both sides must be enabled by a call to FSIWallElement::enable_fluid_loading_on_both_sides();. More...
 
void exclude_external_load_data ()
 Do not include any external data that affects the load in the computation of element's Jacobian matrix. This functionality is provided to allow the "user" to deem the coupling to the fluid equations to be irrelevant and to facilitate the solution of a auxiliary solids-only problems, e.g. during the assignment of initial conditions for a time-dependent FSI problem. More...
 
void include_external_load_data ()
 Include all external fluid data that affects the load in the computation of the element's Jacobian matrix. More...
 
void disable_shear_stress_in_jacobian ()
 Call this function to ignore shear stress component of load when calculating the Jacobian, i.e. to ignore fluid velocity Data in the FSIFluidElement and "far away" geometric Data that affects nodal positions in the FSIFluidElement, also to bypass node updates in the FSIFluidElement. This functionality is provided to allow the user to deem the coupling to the shear stress component of the fluid equations to be irrelevant. More...
 
void enable_shear_stress_in_jacobian ()
 Call thi function to re-enable calculation of the shear stress componnent of load when calculating the Jacobian (the default) More...
 
void node_update_adjacent_fluid_elements ()
 Update the nodal positions in all fluid elements that affect the traction on this FSIWallElement. More...
 
- Public Member Functions inherited from oomph::ElementWithExternalElement
 ElementWithExternalElement ()
 Constructor. Initialise member data and pointers to data associated with the external elements to zero. More...
 
virtual ~ElementWithExternalElement ()
 The destructor, clean up any allocated memory. More...
 
 ElementWithExternalElement (const ElementWithExternalElement &)=delete
 Broken copy constructor. More...
 
void operator= (const ElementWithExternalElement &)=delete
 Broken assignment operator. More...
 
bool storage_has_been_allocated () const
 Helper function to check if storage has actually been allocated. More...
 
FiniteElement *& external_element_pt (const unsigned &interaction_index, const unsigned &ipt)
 Access function to source element for specified interaction index at specified integration point. More...
 
FiniteElement *const & external_element_pt (const unsigned &interaction_index, const unsigned &ipt) const
 Access function to source element, const version. More...
 
Vector< double > & external_element_local_coord (const unsigned &interaction_index, const unsigned &ipt)
 Access function to get source element's local coords for specified interaction index at specified integration point. More...
 
Vector< double > const & external_element_local_coord (const unsigned &interaction_index, const unsigned &ipt) const
 Access function to get source element's coords, const version. More...
 
void output_external_elements (std::ostream &outfile, const unsigned &interaction_index)
 Output by plotting vector from integration point to corresponding point in external element for specified interaction index. More...
 
void initialise_external_element_storage ()
 Initialise storage for pointers to external elements and their local coordinates. This must be called before any of the access functions are used. More...
 
void flush_all_external_element_storage ()
 Flush the storage for external elements. More...
 
void set_ninteraction (const unsigned &n_interaction)
 Set the number of interactions in the element This function is usually called in the specific element's constructor. More...
 
unsigned ninteraction () const
 Return the number of interactions in the element. More...
 
unsigned nexternal_interaction_field_data () const
 Return the number of Data items that affect the external interactions in this element. This includes e.g. fluid velocities and pressures in adjacent fluid elements in an FSI problem. More...
 
Vector< Data * > external_interaction_field_data_pt () const
 Return vector of pointers to the field Data objects that affect the interactions on the element. More...
 
unsigned nexternal_interaction_geometric_data () const
 Return the number of geometric Data items that affect the external interactions in this element: i.e. any geometric Data in the problem that affects the nodal positions in the external elements. More...
 
bool add_external_geometric_data ()
 Are we including external geometric data in the element's Jacobian. More...
 
bool add_external_interaction_data ()
 Are we including external data in the element's Jacobian. More...
 
Vector< Data * > external_interaction_geometric_data_pt () const
 Return vector of pointers to the geometric Data objects that affect the interactions on the element. More...
 
void ignore_external_geometric_data ()
 Do not include any external geometric data when computing the element's Jacobian. This function should be called if the external element does not move and/or if the "source term" does not depend on spatial derivatives of the field computed by the other element. More...
 
void ignore_external_interaction_data ()
 Do not include any external interaction data when computing the element's Jacobian. More...
 
void include_external_geometric_data ()
 Do include external geometric data when computing the element's Jacobian. This function should be called to re-enable inclusion of external geometric data. More...
 
void include_external_interaction_data ()
 Do include external geometric data when computing the element's Jacobian This function should be called to re-enable inclusion of external interaction data. More...
 
bool external_geometric_data_is_included () const
 Is the external geometric data taken into account when forming the Jacobian? More...
 

Additional Inherited Members

- Public Types inherited from oomph::FiniteElement
typedef void(* SteadyExactSolutionFctPt) (const Vector< double > &, Vector< double > &)
 Function pointer for function that computes vector-valued steady "exact solution" $ {\bf f}({\bf x}) $ as $ \mbox{\tt fct}({\bf x}, {\bf f}) $. More...
 
typedef void(* UnsteadyExactSolutionFctPt) (const double &, const Vector< double > &, Vector< double > &)
 Function pointer for function that computes Vector-valued time-dependent function $ {\bf f}(t,{\bf x}) $ as $ \mbox{\tt fct}(t, {\bf x}, {\bf f}) $. More...
 
- Public Types inherited from oomph::SolidFiniteElement
typedef double(* MultiplierFctPt) (const Vector< double > &xi)
 Pointer to function that computes the "multiplier" for the inertia terms in the consistent determination of the initial conditions for Newmark timestepping. More...
 
- Static Public Member Functions inherited from oomph::RefineableElement
static double & max_integrity_tolerance ()
 Max. allowed discrepancy in element integrity check. More...
 
- Public Attributes inherited from oomph::SolidTractionElement< ELEMENT >
void(*&)(const Vector< double > &xi, const Vector< double > &x, const Vector< double > &n, Vector< double > &tractiontraction_fct_pt ()
 Reference to the traction function pointer. More...
 
- Public Attributes inherited from oomph::FSISolidTractionElement< ELEMENT, DIM >
virtual void(*&)(const Vector< double > &xi, const Vector< double > &x, const Vector< double > &n, Vector< double > &tractiontraction_fct_pt ()
 Broken overloaded reference to the traction function pointer. It doesn't make sense to specify an external traction. More...
 
- Static Public Attributes inherited from oomph::FiniteElement
static double Tolerance_for_singular_jacobian = 1.0e-16
 Tolerance below which the jacobian is considered singular. More...
 
static bool Accept_negative_jacobian = false
 Boolean that if set to true allows a negative jacobian in the transform between global and local coordinates (negative surface area = left-handed coordinate system). More...
 
static bool Suppress_output_while_checking_for_inverted_elements
 Static boolean to suppress output while checking for inverted elements. More...
 
- Static Public Attributes inherited from oomph::GeneralisedElement
static bool Suppress_warning_about_repeated_internal_data
 Static boolean to suppress warnings about repeated internal data. Defaults to false. More...
 
static bool Suppress_warning_about_repeated_external_data = true
 Static boolean to suppress warnings about repeated external data. Defaults to true. More...
 
static double Default_fd_jacobian_step = 1.0e-8
 Double used for the default finite difference step in elemental jacobian calculations. More...
 
- Static Public Attributes inherited from oomph::FSIWallElement
static bool Dont_warn_about_missing_adjacent_fluid_elements = false
 Static flag that allows the suppression of warning messages. More...
 
- Protected Member Functions inherited from oomph::RefineableSolidTractionElement< ELEMENT >
void refineable_fill_in_contribution_to_residuals_solid_traction (Vector< double > &residuals)
 This function returns the residuals for the traction function. More...
 
- Protected Member Functions inherited from oomph::SolidTractionElement< ELEMENT >
void fill_in_contribution_to_residuals_solid_traction (Vector< double > &residuals)
 Helper function that actually calculates the residuals. More...
 
- Protected Member Functions inherited from oomph::FaceElement
void add_additional_values (const Vector< unsigned > &nadditional_values, const unsigned &id)
 Helper function adding additional values for the unknowns associated with the FaceElement. This function also sets the map containing the position of the first entry of this face element's additional values.The inputs are the number of additional values and the face element's ID. Note the same number of additonal values are allocated at ALL nodes. More...
 
- Protected Member Functions inherited from oomph::FiniteElement
template<unsigned DIM>
double invert_jacobian (const DenseMatrix< double > &jacobian, DenseMatrix< double > &inverse_jacobian) const
 Take the matrix passed as jacobian and return its inverse in inverse_jacobian. This function is templated by the dimension of the element because matrix inversion cannot be written efficiently in a generic manner. More...
 
virtual double invert_jacobian_mapping (const DenseMatrix< double > &jacobian, DenseMatrix< double > &inverse_jacobian) const
 A template-free interface that takes the matrix passed as jacobian and return its inverse in inverse_jacobian. By default the function will use the dimension of the element to call the correct invert_jacobian(..) function. This should be overloaded for efficiency (removal of a switch statement) in specific elements. More...
 
virtual double local_to_eulerian_mapping (const DShape &dpsids, DenseMatrix< double > &jacobian, DenseMatrix< double > &inverse_jacobian) const
 Calculate the mapping from local to Eulerian coordinates, given the derivatives of the shape functions w.r.t. local coordinates. Returns the determinant of the jacobian, the jacobian and inverse jacobian. More...
 
double local_to_eulerian_mapping (const DShape &dpsids, DenseMatrix< double > &inverse_jacobian) const
 Calculate the mapping from local to Eulerian coordinates, given the derivatives of the shape functions w.r.t. local coordinates, Return only the determinant of the jacobian and the inverse of the mapping (ds/dx). More...
 
virtual void dJ_eulerian_dnodal_coordinates (const DenseMatrix< double > &jacobian, const DShape &dpsids, DenseMatrix< double > &djacobian_dX) const
 A template-free interface that calculates the derivative of the jacobian of a mapping with respect to the nodal coordinates X_ij. To do this it requires the jacobian matrix and the derivatives of the shape functions w.r.t. the local coordinates. By default the function will use the dimension of the element to call the correct dJ_eulerian_dnodal_coordinates_templated_helper(..) function. This should be overloaded for efficiency (removal of a switch statement) in specific elements. More...
 
template<unsigned DIM>
void dJ_eulerian_dnodal_coordinates_templated_helper (const DenseMatrix< double > &jacobian, const DShape &dpsids, DenseMatrix< double > &djacobian_dX) const
 Calculate the derivative of the jacobian of a mapping with respect to the nodal coordinates X_ij using the jacobian matrix and the derivatives of the shape functions w.r.t. the local coordinates. This function is templated by the dimension of the element. More...
 
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
 A template-free interface that calculates the derivative w.r.t. the nodal coordinates $ X_{pq} $ of the derivative of the shape functions $ \psi_j $ w.r.t. the global eulerian coordinates $ x_i $. I.e. this function calculates. More...
 
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
 Calculate the derivative w.r.t. the nodal coordinates $ X_{pq} $ of the derivative of the shape functions w.r.t. the global eulerian coordinates $ x_i $, using the determinant of the jacobian mapping, its derivative w.r.t. the nodal coordinates $ X_{pq} $, the inverse jacobian and the derivatives of the shape functions w.r.t. the local coordinates. The result is returned as a tensor of rank four. Numbering: d_dpsidx_dX(p,q,j,i) = $ \frac{\partial}{\partial X_{pq}} \left( \frac{\partial \psi_j}{\partial x_i} \right) $ This function is templated by the dimension of the element. More...
 
virtual void transform_derivatives (const DenseMatrix< double > &inverse_jacobian, DShape &dbasis) const
 Convert derivative w.r.t.local coordinates to derivatives w.r.t the coordinates used to assemble the inverse_jacobian passed in the mapping. On entry, dbasis must contain the basis function derivatives w.r.t. the local coordinates; it will contain the derivatives w.r.t. the new coordinates on exit. This is virtual so that it may be overloaded if desired for efficiency reasons. More...
 
void transform_derivatives_diagonal (const DenseMatrix< double > &inverse_jacobian, DShape &dbasis) const
 Convert derivative w.r.t local coordinates to derivatives w.r.t the coordinates used to assemble the inverse jacobian passed in the mapping, assuming that the coordinates are aligned in the direction of the local coordinates. On entry dbasis must contain the derivatives of the basis functions w.r.t. the local coordinates; it will contain the derivatives w.r.t. the new coordinates. are converted into the new using the mapping inverse_jacobian. More...
 
virtual void transform_second_derivatives (const DenseMatrix< double > &jacobian, const DenseMatrix< double > &inverse_jacobian, const DenseMatrix< double > &jacobian2, DShape &dbasis, DShape &d2basis) const
 Convert derivatives and second derivatives w.r.t. local coordiantes to derivatives and second derivatives w.r.t. the coordinates used to assemble the jacobian, inverse jacobian and jacobian2 passed to the function. By default this function will call transform_second_derivatives_template<>(...) using the dimension of the element as the template parameter. It is virtual so that it can be overloaded by a specific element to save using a switch statement. Optionally, the element writer may wish to use the transform_second_derivatives_diagonal<>(...) function On entry dbasis and d2basis must contain the derivatives w.r.t. the local coordinates; on exit they will be the derivatives w.r.t. the transformed coordinates. More...
 
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
 Convert derivatives and second derivatives w.r.t. local coordinates to derivatives and second derivatives w.r.t. the coordinates used to asssmble the jacobian, inverse jacobian and jacobian2 passed in the mapping. This is templated by dimension because the method of calculation varies significantly with the dimension. On entry dbasis and d2basis must contain the derivatives w.r.t. the local coordinates; on exit they will be the derivatives w.r.t. the transformed coordinates. More...
 
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
 Convert derivatives and second derivatives w.r.t. local coordinates to derivatives and second derivatives w.r.t. the coordinates used to asssmble the jacobian, inverse jacobian and jacobian2 passed in the mapping. This version of the function assumes that the local coordinates are aligned with the global coordinates, i.e. the jacobians are diagonal On entry dbasis and d2basis must contain the derivatives w.r.t. the local coordinates; on exit they will be the derivatives w.r.t. the transformed coordinates. More...
 
void fill_in_jacobian_from_nodal_by_fd (DenseMatrix< double > &jacobian)
 Calculate the contributions to the jacobian from the nodal degrees of freedom using finite differences. This version computes the residuals vector before calculating the jacobian terms. More...
 
virtual void update_before_nodal_fd ()
 Function that is called before the finite differencing of any nodal data. This may be overloaded to update any dependent data before finite differencing takes place. More...
 
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
 Three-d specialisation of function to calculate inverse of jacobian mapping. More...
 
template<>
void dJ_eulerian_dnodal_coordinates_templated_helper (const DenseMatrix< double > &jacobian, const DShape &dpsids, DenseMatrix< double > &djacobian_dX) const
 Zero-d specialisation of function to calculate the derivative of the jacobian of a mapping with respect to the nodal coordinates X_ij. More...
 
template<>
void dJ_eulerian_dnodal_coordinates_templated_helper (const DenseMatrix< double > &jacobian, const DShape &dpsids, DenseMatrix< double > &djacobian_dX) const
 One-d specialisation of function to calculate the derivative of the jacobian of a mapping with respect to the nodal coordinates X_ij. More...
 
template<>
void dJ_eulerian_dnodal_coordinates_templated_helper (const DenseMatrix< double > &jacobian, const DShape &dpsids, DenseMatrix< double > &djacobian_dX) const
 Two-d specialisation of function to calculate the derivative of the jacobian of a mapping with respect to the nodal coordinates X_ij. More...
 
template<>
void dJ_eulerian_dnodal_coordinates_templated_helper (const DenseMatrix< double > &jacobian, const DShape &dpsids, DenseMatrix< double > &djacobian_dX) const
 Three-d specialisation of function to calculate the derivative of the jacobian of a mapping with respect to the nodal coordinates X_ij. More...
 
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
 Zero-d specialisation of function to calculate the derivative w.r.t. the nodal coordinates $ X_{pq} $ of the derivative of the shape functions w.r.t. the global eulerian coordinates $ x_i $. More...
 
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
 One-d specialisation of function to calculate the derivative w.r.t. the nodal coordinates $ X_{pq} $ of the derivative of the shape functions w.r.t. the global eulerian coordinates $ x_i $. More...
 
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
 Two-d specialisation of function to calculate the derivative w.r.t. the nodal coordinates $ X_{pq} $ of the derivative of the shape functions w.r.t. the global eulerian coordinates $ x_i $. More...
 
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
 Three-d specialisation of function to calculate the derivative w.r.t. the nodal coordinates $ X_{pq} $ of the derivative of the shape functions w.r.t. the global eulerian coordinates $ x_i $. More...
 
template<>
void transform_second_derivatives_template (const DenseMatrix< double > &jacobian, const DenseMatrix< double > &inverse_jacobian, const DenseMatrix< double > &jacobian2, DShape &dbasis, DShape &d2basis) const
 Convert derivatives and second derivatives w.r.t local coordinates to derivatives w.r.t. the coordinates used to assemble the jacobian, inverse_jacobian and jacobian 2 passed. This must be specialised for each dimension, otherwise it gets very ugly Specialisation to one dimension. More...
 
template<>
void transform_second_derivatives_template (const DenseMatrix< double > &jacobian, const DenseMatrix< double > &inverse_jacobian, const DenseMatrix< double > &jacobian2, DShape &dbasis, DShape &d2basis) const
 Convert derivatives and second derivatives w.r.t local coordinates to derivatives w.r.t. the coordinates used to assemble the jacobian, inverse_jacobian and jacobian 2 passed. This must be specialised for each dimension, otherwise it gets very ugly. Specialisation to two spatial dimensions. More...
 
template<>
void transform_second_derivatives_diagonal (const DenseMatrix< double > &jacobian, const DenseMatrix< double > &inverse_jacobian, const DenseMatrix< double > &jacobian2, DShape &dbasis, DShape &d2basis) const
 Convert derivatives and second derivatives w.r.t local coordinates to derivatives w.r.t. the coordinates used to assemble the jacobian, inverse_jacobian and jacobian 2 passed. This must be specialised for each dimension, otherwise it gets very ugly Specialisation to one dimension. More...
 
template<>
void transform_second_derivatives_diagonal (const DenseMatrix< double > &jacobian, const DenseMatrix< double > &inverse_jacobian, const DenseMatrix< double > &jacobian2, DShape &dbasis, DShape &d2basis) const
 Convert second derivatives w.r.t. local coordinates to second derivatives w.r.t. the coordinates passed in the tensor coordinate. Specialised to two spatial dimension. More...
 
- Protected Member Functions inherited from oomph::GeneralisedElement
unsigned add_internal_data (Data *const &data_pt, const bool &fd=true)
 Add a (pointer to an) internal data object to the element and return the index required to obtain it from the access function internal_data_pt(). The boolean indicates whether the datum should be included in the general finite-difference loop when calculating the jacobian. The default value is true, i.e. the data will be included in the finite differencing. More...
 
bool internal_data_fd (const unsigned &i) const
 Return the status of the boolean flag indicating whether the internal data is included in the finite difference loop. More...
 
void exclude_internal_data_fd (const unsigned &i)
 Set the boolean flag to exclude the internal datum from the finite difference loop when computing the jacobian matrix. More...
 
void include_internal_data_fd (const unsigned &i)
 Set the boolean flag to include the internal datum in the finite difference loop when computing the jacobian matrix. More...
 
void clear_global_eqn_numbers ()
 Clear the storage for the global equation numbers and pointers to dofs (if stored) More...
 
void add_global_eqn_numbers (std::deque< unsigned long > const &global_eqn_numbers, std::deque< double * > const &global_dof_pt)
 Add the contents of the queue global_eqn_numbers to the local storage for the local-to-global translation scheme. It is essential that the entries in the queue are added IN ORDER i.e. from the front. More...
 
virtual void assign_additional_local_eqn_numbers ()
 Setup any additional look-up schemes for local equation numbers. Examples of use include using local storage to refer to explicit degrees of freedom. The additional memory cost of such storage may or may not be offset by fast local access. More...
 
int internal_local_eqn (const unsigned &i, const unsigned &j) const
 Return the local equation number corresponding to the j-th value stored at the i-th internal data. More...
 
int external_local_eqn (const unsigned &i, const unsigned &j)
 Return the local equation number corresponding to the j-th value stored at the i-th external data. More...
 
void fill_in_jacobian_from_internal_by_fd (Vector< double > &residuals, DenseMatrix< double > &jacobian, const bool &fd_all_data=false)
 Calculate the contributions to the jacobian from the internal degrees of freedom using finite differences. This version of the function assumes that the residuals vector has already been calculated. If the boolean argument is true, the finite differencing will be performed for all internal data, irrespective of the information in Data_fd. The default value (false) uses the information in Data_fd to selectively difference only certain data. More...
 
void fill_in_jacobian_from_internal_by_fd (DenseMatrix< double > &jacobian, const bool &fd_all_data=false)
 Calculate the contributions to the jacobian from the internal degrees of freedom using finite differences. This version computes the residuals vector before calculating the jacobian terms. If the boolean argument is true, the finite differencing will be performed for all internal data, irrespective of the information in Data_fd. The default value (false) uses the information in Data_fd to selectively difference only certain data. More...
 
void fill_in_jacobian_from_external_by_fd (Vector< double > &residuals, DenseMatrix< double > &jacobian, const bool &fd_all_data=false)
 Calculate the contributions to the jacobian from the external degrees of freedom using finite differences. This version of the function assumes that the residuals vector has already been calculated. If the boolean argument is true, the finite differencing will be performed for all external data, irrespective of the information in Data_fd. The default value (false) uses the information in Data_fd to selectively difference only certain data. More...
 
void fill_in_jacobian_from_external_by_fd (DenseMatrix< double > &jacobian, const bool &fd_all_data=false)
 Calculate the contributions to the jacobian from the external degrees of freedom using finite differences. This version computes the residuals vector before calculating the jacobian terms. If the boolean argument is true, the finite differencing will be performed for all internal data, irrespective of the information in Data_fd. The default value (false) uses the information in Data_fd to selectively difference only certain data. More...
 
virtual void update_before_internal_fd ()
 Function that is called before the finite differencing of any internal data. This may be overloaded to update any dependent data before finite differencing takes place. More...
 
virtual void update_before_external_fd ()
 Function that is called before the finite differencing of any external data. This may be overloaded to update any dependent data before finite differencing takes place. More...
 
virtual void fill_in_contribution_to_mass_matrix (Vector< double > &residuals, DenseMatrix< double > &mass_matrix)
 Add the elemental contribution to the mass matrix matrix. and the residuals vector. Note that this function should NOT initialise the residuals vector or the mass matrix. It must be called after the residuals vector and jacobian matrix have been initialised to zero. The default is deliberately broken. More...
 
virtual void fill_in_contribution_to_jacobian_and_mass_matrix (Vector< double > &residuals, DenseMatrix< double > &jacobian, DenseMatrix< double > &mass_matrix)
 Add the elemental contribution to the jacobian matrix, mass matrix and the residuals vector. Note that this function should NOT initialise any entries. It must be called after the residuals vector and matrices have been initialised to zero. More...
 
virtual void fill_in_contribution_to_dresiduals_dparameter (double *const &parameter_pt, Vector< double > &dres_dparam)
 Add the elemental contribution to the derivatives of the residuals with respect to a parameter. This function should NOT initialise any entries and must be called after the entries have been initialised to zero The default implementation is to use finite differences to calculate the derivatives. More...
 
virtual void fill_in_contribution_to_djacobian_dparameter (double *const &parameter_pt, Vector< double > &dres_dparam, DenseMatrix< double > &djac_dparam)
 Add the elemental contribution to the derivatives of the elemental Jacobian matrix and residuals with respect to a parameter. This function should NOT initialise any entries and must be called after the entries have been initialised to zero The default implementation is to use finite differences to calculate the derivatives. More...
 
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)
 Add the elemental contribution to the derivative of the jacobian matrix, mass matrix and the residuals vector with respect to the passed parameter. Note that this function should NOT initialise any entries. It must be called after the residuals vector and matrices have been initialised to zero. More...
 
virtual void fill_in_contribution_to_hessian_vector_products (Vector< double > const &Y, DenseMatrix< double > const &C, DenseMatrix< double > &product)
 Fill in contribution to the product of the Hessian (derivative of Jacobian with respect to all variables) an eigenvector, Y, and other specified vectors, C (d(J_{ij})/d u_{k}) Y_{j} C_{k}. More...
 
virtual void fill_in_contribution_to_inner_products (Vector< std::pair< unsigned, unsigned >> const &history_index, Vector< double > &inner_product)
 Fill in the contribution to the inner products between given pairs of history values. More...
 
virtual void fill_in_contribution_to_inner_product_vectors (Vector< unsigned > const &history_index, Vector< Vector< double >> &inner_product_vector)
 Fill in the contributions to the vectors that when taken as dot product with other history values give the inner product over the element. More...
 
- Protected Member Functions inherited from oomph::SolidFiniteElement
void fill_in_generic_jacobian_for_solid_ic (Vector< double > &residuals, DenseMatrix< double > &jacobian, const unsigned &flag)
 Helper function to fill in the residuals and (if flag==1) the Jacobian for the setup of an initial condition. The global equations are: More...
 
void set_nnodal_lagrangian_type (const unsigned &nlagrangian_type)
 Set the number of types required to interpolate the Lagrangian coordinates. More...
 
virtual double local_to_lagrangian_mapping (const DShape &dpsids, DenseMatrix< double > &jacobian, DenseMatrix< double > &inverse_jacobian) const
 Calculate the mapping from local to lagrangian coordinates, given the derivatives of the shape functions w.r.t. local coorindates. Return the determinant of the jacobian, the jacobian and inverse jacobian. More...
 
double local_to_lagrangian_mapping (const DShape &dpsids, DenseMatrix< double > &inverse_jacobian) const
 Calculate the mapping from local to lagrangian coordinates, given the derivatives of the shape functions w.r.t. local coordinates, Return only the determinant of the jacobian and the inverse of the mapping (ds/dx) More...
 
void describe_solid_local_dofs (std::ostream &out, const std::string &current_string) const
 Classifies dofs locally for solid specific aspects. More...
 
void fill_in_jacobian_from_solid_position_by_fd (DenseMatrix< double > &jacobian)
 Use finite differences to calculate the Jacobian entries corresponding to the solid positions. More...
 
virtual void update_before_solid_position_fd ()
 Function that is called before the finite differencing of any solid position data. This may be overloaded to update any dependent data before finite differencing takes place. More...
 
- Protected Member Functions inherited from oomph::RefineableElement
void assemble_local_to_eulerian_jacobian (const DShape &dpsids, DenseMatrix< double > &jacobian) const
 Assemble the jacobian matrix for the mapping from local to Eulerian coordinates, given the derivatives of the shape function w.r.t the local coordinates. Overload the standard version to use the hanging information for the Eulerian coordinates. More...
 
void assemble_local_to_eulerian_jacobian2 (const DShape &d2psids, DenseMatrix< double > &jacobian2) const
 Assemble the the "jacobian" matrix of second derivatives of the mapping from local to Eulerian coordinates, given the second derivatives of the shape functions w.r.t. local coordinates. Overload the standard version to use the hanging information for the Eulerian coordinates. More...
 
void assemble_eulerian_base_vectors (const DShape &dpsids, DenseMatrix< double > &interpolated_G) const
 Assemble the covariant Eulerian base vectors, assuming that the derivatives of the shape functions with respect to the local coordinates have already been constructed. Overload the standard version to account for hanging nodes. More...
 
double local_to_eulerian_mapping_diagonal (const DShape &dpsids, DenseMatrix< double > &jacobian, DenseMatrix< double > &inverse_jacobian) const
 Calculate the mapping from local to Eulerian coordinates given the derivatives of the shape functions w.r.t the local coordinates. assuming that the coordinates are aligned in the direction of the local coordinates, i.e. there are no cross terms and the jacobian is diagonal. This funciton returns the determinant of the jacobian, the jacobian and the inverse jacobian. Overload the standard version to take hanging info into account. More...
 
void assign_hanging_local_eqn_numbers (const bool &store_local_dof_pt)
 Assign the local equation numbers for hanging node variables. More...
 
virtual void fill_in_jacobian_from_nodal_by_fd (Vector< double > &residuals, DenseMatrix< double > &jacobian)
 Calculate the contributions to the jacobian from the nodal degrees of freedom using finite differences. This version is overloaded to take hanging node information into account. More...
 
- Protected Member Functions inherited from oomph::RefineableSolidElement
void assemble_local_to_lagrangian_jacobian (const DShape &dpsids, DenseMatrix< double > &jacobian) const
 Assemble the jacobian matrix for the mapping from local to lagrangian coordinates, given the derivatives of the shape function Overload the standard version to use the hanging information for the lagrangian coordinates. More...
 
void assemble_local_to_lagrangian_jacobian2 (const DShape &d2psids, DenseMatrix< double > &jacobian2) const
 Assemble the the "jacobian" matrix of second derivatives, given the second derivatives of the shape functions w.r.t. local coordinates Overload the standard version to use the hanging information for the lagrangian coordinates. More...
 
double local_to_lagrangian_mapping_diagonal (const DShape &dpsids, DenseMatrix< double > &jacobian, DenseMatrix< double > &inverse_jacobian) const
 Calculate the mapping from local to Lagrangian coordinates given the derivatives of the shape functions w.r.t the local coorindates. assuming that the coordinates are aligned in the direction of the local coordinates, i.e. there are no cross terms and the jacobian is diagonal. This function returns the determinant of the jacobian, the jacobian and the inverse jacobian. More...
 
- Protected Member Functions inherited from oomph::FSIWallElement
void update_in_internal_fd (const unsigned &i)
 After an internal data change, update the nodal positions. More...
 
void reset_in_internal_fd (const unsigned &i)
 Function called within the finite difference loop for internal data after the values in the i-th external data object are reset. The default behaviour is to call the update function. More...
 
void reset_after_internal_fd ()
 Function that is call after the finite differencing of the internal data. This may be overloaded to reset any dependent variables that may have changed during the finite differencing. More...
 
void update_in_external_fd (const unsigned &i)
 After an external data change, update the nodal positions. More...
 
void reset_in_external_fd (const unsigned &i)
 Function called within the finite difference loop for external data after the values in the i-th external data object are reset. The default behaviour is to call the update function. More...
 
void reset_after_external_fd ()
 Function that is call after the finite differencing of the external data. This may be overloaded to reset any dependent variables that may have changed during the finite differencing. More...
 
void update_in_nodal_fd (const unsigned &i)
 After a nodal data change, update the nodal positions. More...
 
void reset_in_nodal_fd (const unsigned &i)
 Function called within the finite difference loop for nodal data after the i-th nodal values is reset. The default behaviour is to call the update function. More...
 
void reset_after_nodal_fd ()
 Function that is call after the finite differencing of the nodal data. This may be overloaded to reset any dependent variables that may have changed during the finite differencing. More...
 
void update_in_external_interaction_field_fd (const unsigned &i)
 After an external field data change, update the nodal positions. More...
 
void reset_in_external_interaction_field_fd (const unsigned &i)
 Function called within the finite difference loop for external interaction data after the values in the i-th external interaction data object associated with external fields are reset. The default behaviour is to call the update function. More...
 
void reset_after_external_interaction_field_fd ()
 Function that is call after the finite differencing of the external interaction data associated with external fields This may be overloaded to reset any dependent variables that may have changed during the finite differencing. More...
 
void update_in_external_interaction_geometric_fd (const unsigned &i)
 After an external geometric data change, update the nodal positions. More...
 
void reset_in_external_interaction_geometric_fd (const unsigned &i)
 Function called within the finite difference loop for external interaction data after the values in the i-th external interaction data object associated with external geometry are reset. The default behaviour is to call the update function. More...
 
void reset_after_external_interaction_geometric_fd ()
 Function that is call after the finite differencing of the external interaction data associated with external geometry. This may be overloaded to reset any dependent variables that may have changed during the finite differencing. More...
 
void update_in_solid_position_fd (const unsigned &i)
 After an internal data change, update the nodal positions. More...
 
void reset_in_solid_position_fd (const unsigned &i)
 Function called within the finite difference loop for solid position data after the values in the i-th node are reset. The default behaviour is to call the update function. More...
 
void reset_after_solid_position_fd ()
 Function that is call after the finite differencing of the solid position data. This may be overloaded to reset any dependent variables that may have changed during the finite differencing. More...
 
void fluid_load_vector (const unsigned &intpt, const Vector< double > &N, Vector< double > &load)
 Get FE Jacobian by systematic finite differencing w.r.t. nodal positition Data, internal and external Data and any load Data that is not included in the previous categories. This is a re-implementation of the generic FD routines with they key difference being that any updates of values are followed by a node update in the adjacent fluid elements since their position (and hence the shear stresses they exert onto the solid) may be indirectly affected by these. For greater efficiency this may be overloaded in derived classes, e.g. if it is known that for a specific FSIWallElement, the internal Data does not affect the nodal positions in adjacent fluid elements. More...
 
- Protected Member Functions inherited from oomph::ElementWithExternalElement
void assign_internal_and_external_local_eqn_numbers (const bool &store_local_dof_pt)
 Overload the assign internal and external local equation number scheme so that the interaction data is taken into account. More...
 
void assign_external_interaction_data_local_eqn_numbers (const bool &store_local_dof_pt)
 Assign the local equation numbers for those Data values involved in the external interactions that affect the residuals of the element. More...
 
void fill_in_jacobian_from_external_interaction_by_fd (Vector< double > &residuals, DenseMatrix< double > &jacobian)
 Calculate the contributions to the jacobian from all external interaction degrees of freedom (geometric and field data) in the external element using finite differences. This version of the function assumes that the residuals vector has already been calculated. More...
 
void fill_in_jacobian_from_external_interaction_by_fd (DenseMatrix< double > &jacobian)
 Calculate the contributions to the jacobian from all enternal interaction degrees of freedom (geometric and field data) in the external element using finite differences. This version computes the residuals vector before calculating the jacobian terms. More...
 
void fill_in_jacobian_from_external_interaction_field_by_fd (Vector< double > &residuals, DenseMatrix< double > &jacobian)
 Calculate the contributions to the jacobian from the external interaction degrees of freedom associated with fields interpolated by the external element using finite differences. This version of the function assumes that the residuals vector has already been calculated. More...
 
void fill_in_jacobian_from_external_interaction_field_by_fd (DenseMatrix< double > &jacobian)
 Calculate the contributions to the jacobian from the enternal interaction degrees of freedom associated with fields interpolated by the external element using finite differences. This version computes the residuals vector before calculating the jacobian terms. More...
 
void fill_in_jacobian_from_external_interaction_geometric_by_fd (Vector< double > &residuals, DenseMatrix< double > &jacobian)
 Calculate the contributions to the jacobian from the external interaction degrees of freedom associated with the geometry of the external elements using finite differences. This version of the function assumes that the residuals vector has already been calculated. More...
 
void fill_in_jacobian_from_external_interaction_geometric_by_fd (DenseMatrix< double > &jacobian)
 Calculate the contributions to the jacobian from the external interaction degrees of freedom associated with the geometry of the external elements using finite differences. This version computes the residuals vector before calculating the jacobian terms. More...
 
virtual void update_before_external_interaction_field_fd ()
 Function that is called before the finite differencing of any external interaction data associated with external fields. This may be overloaded to update any dependent data before finite differencing takes place. More...
 
virtual void update_before_external_interaction_geometric_fd ()
 Function that is called before the finite differencing of any external interaction data associated with external geometry. This may be overloaded to update any dependent data before finite differencing takes place. More...
 
- Static Protected Member Functions inherited from oomph::RefineableElement
static void check_value_id (const int &n_continuously_interpolated_values, const int &value_id)
 Static helper function that is used to check that the value_id is in range. More...
 
- Protected Attributes inherited from oomph::SolidTractionElement< ELEMENT >
void(* Traction_fct_pt )(const Vector< double > &xi, const Vector< double > &x, const Vector< double > &n, Vector< double > &result)
 Pointer to an imposed traction function. Arguments: Lagrangian coordinate; Eulerian coordinate; outer unit normal; applied traction. (Not all of the input arguments will be required for all specific load functions but the list should cover all cases) More...
 
- Protected Attributes inherited from oomph::FaceElement
unsigned Boundary_number_in_bulk_mesh
 The boundary number in the bulk mesh to which this element is attached. More...
 
bool Boundary_number_in_bulk_mesh_has_been_set
 Has the Boundary_number_in_bulk_mesh been set? Only included if compiled with PARANOID switched on. More...
 
FiniteElementBulk_element_pt
 Pointer to the associated higher-dimensional "bulk" element. More...
 
Vector< unsigned > Bulk_node_number
 List of indices of the local node numbers in the "bulk" element that correspond to the local node numbers in the FaceElement. More...
 
Vector< unsigned > Nbulk_value
 A vector that will hold the number of data values at the nodes that are associated with the "bulk" element. i.e. not including any additional degrees of freedom that might be required for extra equations that are being solved by the FaceElement. More...
 
Vector< double > * Tangent_direction_pt
 A general direction pointer for the tangent vectors. This is used in the function continuous_tangent_and_outer_unit_normal() for creating continuous tangent vectors in spatial dimensions. The general direction is projected on to the surface. This technique is not required in two spatial dimensions. More...
 
- Protected Attributes inherited from oomph::FiniteElement
MacroElementMacro_elem_pt
 Pointer to the element's macro element (NULL by default) More...
 
- Protected Attributes inherited from oomph::GeneralisedElement
int Non_halo_proc_ID
 Non-halo processor ID for Data; -1 if it's not a halo. More...
 
bool Must_be_kept_as_halo
 Does this element need to be kept as a halo element during a distribute? More...
 
- Protected Attributes inherited from oomph::GeomObject
unsigned NLagrangian
 Number of Lagrangian (intrinsic) coordinates. More...
 
unsigned Ndim
 Number of Eulerian coordinates. More...
 
TimeStepperGeom_object_time_stepper_pt
 Timestepper (used to handle access to geometry at previous timesteps) More...
 
- Protected Attributes inherited from oomph::SolidFiniteElement
MacroElementUndeformed_macro_elem_pt
 Pointer to the element's "undeformed" macro element (NULL by default) More...
 
SolidInitialConditionSolid_ic_pt
 Pointer to object that specifies the initial condition. More...
 
bool Solve_for_consistent_newmark_accel_flag
 Flag to indicate which system of equations to solve when assigning initial conditions for time-dependent problems. If true, solve for the history value that corresponds to the acceleration in the Newmark scheme by demanding that the PDE is satisifed at the initial time. In this case the Jacobian is replaced by the mass matrix. More...
 
- Protected Attributes inherited from oomph::RefineableElement
TreeTree_pt
 A pointer to a general tree object. More...
 
unsigned Refine_level
 Refinement level. More...
 
bool To_be_refined
 Flag for refinement. More...
 
bool Refinement_is_enabled
 Flag to indicate suppression of any refinement. More...
 
bool Sons_to_be_unrefined
 Flag for unrefinement. More...
 
long Number
 Global element number – for plotting/validation purposes. More...
 
- Protected Attributes inherited from oomph::RefineableSolidElement
bool Use_undeformed_macro_element_for_new_lagrangian_coords
 Flag deciding if the Lagrangian coordinates of newly-created interior SolidNodes are to be determined by the father element's undeformed MacroElement representation (if it has one). Default: False as it means that, following a refinement an element is no longer in equilbrium (as the Lagrangian coordinate is determined differently from the Eulerian one). However, basing the Lagrangian coordinates on the undeformed MacroElement can be more stable numerically and for steady problems it's not a big deal either way as the difference between the two formulations only matters at finite resolution so we have no right to say that one is "more correct" than the other... More...
 
- Protected Attributes inherited from oomph::ElementWithExternalElement
bool Add_external_interaction_data
 Boolean flag to indicate whether to include the external data. More...
 
bool Add_external_geometric_data
 Boolean flag to indicate whether to include the external geometric data. More...
 
Data ** External_interaction_field_data_pt
 / Storage for pointers to external field Data that affect the interactions in the elemenet More...
 
Data ** External_interaction_geometric_data_pt
 / Storage for pointers to external geometric Data that affect the interactions in the elemenet More...
 
- Static Protected Attributes inherited from oomph::FiniteElement
static const unsigned Default_Initial_Nvalue = 0
 Default return value for required_nvalue(n) which gives the number of "data" values required by the element at node n; for example, solving a Poisson equation would required only one "data" value at each node. The defaults is set to zero, because a general element is problem-less. More...
 
static const double Node_location_tolerance = 1.0e-14
 Default value for the tolerance to be used when locating nodes via local coordinates. More...
 
static const unsigned N2deriv [] = {0, 1, 3, 6}
 Static array that holds the number of second derivatives as a function of the dimension of the element. More...
 
- Static Protected Attributes inherited from oomph::GeneralisedElement
static DenseMatrix< double > Dummy_matrix
 Empty dense matrix used as a dummy argument to combined residual and jacobian functions in the case when only the residuals are being assembled. More...
 
static std::deque< double * > Dof_pt_deque
 Static storage for deque used to add_global_equation_numbers when pointers to the dofs in each element are not required. More...
 
- Static Protected Attributes inherited from oomph::RefineableElement
static double Max_integrity_tolerance = 1.0e-8
 Max. allowed discrepancy in element integrity check. More...
 

Detailed Description

template<class ELEMENT, unsigned DIM>
class oomph::RefineableFSISolidTractionElement< ELEMENT, DIM >

////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////

RefineableSolidTractionElement "upgraded" to a FSIWallElement (and thus, by inheritance, a GeomObject), so it can be used in FSI. The element is templated by the bulk solid element and the spatial (Eulerian) dimension of the bulk element.

Definition at line 1042 of file solid_traction_elements.h.

Constructor & Destructor Documentation

◆ RefineableFSISolidTractionElement()

template<class ELEMENT , unsigned DIM>
oomph::RefineableFSISolidTractionElement< ELEMENT, DIM >::RefineableFSISolidTractionElement ( FiniteElement *const &  element_pt,
const int &  face_index 
)
inline

Constructor: Create element as FSIWallElement (and thus, by inheritance, a GeomObject) with DIM-1 Lagrangian and DIM Eulerian coordinates. By default, we assume that the normal vector computed by the underlying FaceElement points into the fluid. If this is not the case, overwrite this with the access function FSISolidTractionElement::set_normal_pointing_out_of_fluid() Constructor for GeomObject is called explicitly because of virtual inheritance!

Definition at line 1057 of file solid_traction_elements.h.

◆ ~RefineableFSISolidTractionElement()

template<class ELEMENT , unsigned DIM>
oomph::RefineableFSISolidTractionElement< ELEMENT, DIM >::~RefineableFSISolidTractionElement ( )
inline

Destructor: empty.

Definition at line 1066 of file solid_traction_elements.h.

Member Function Documentation

◆ fill_in_contribution_to_jacobian()

template<class ELEMENT , unsigned DIM>
virtual void oomph::RefineableFSISolidTractionElement< ELEMENT, DIM >::fill_in_contribution_to_jacobian ( Vector< double > &  residuals,
DenseMatrix< double > &  jacobian 
)
inlinevirtual

Final overload. Get contributions from refineable solid traction element and derivatives from external data.

Reimplemented from oomph::FSIWallElement.

Definition at line 1071 of file solid_traction_elements.h.

References oomph::RefineableSolidTractionElement< ELEMENT >::fill_in_contribution_to_jacobian(), and oomph::ElementWithExternalElement::fill_in_jacobian_from_external_interaction_by_fd().


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