#include <immersed_rigid_body_elements.h>

Inheritance diagram for oomph::ImmersedRigidBodyElement:

Public Types
typedef void(*	ExternalForceFctPt) (const double &time, Vector< double > &external_force)

typedef void(*	ExternalTorqueFctPt) (const double &time, double &external_torque)

Public Member Functions
	ImmersedRigidBodyElement (GeomObject const &geom_object_pt, TimeStepper const &time_stepper_pt, Data *const &centre_displacement_data_pt=0)

void	set_geometric_rotation ()
	Set the rotation of the object to be included. More...

void	unset_geometric_rotation ()

double &	initial_phi ()
	Access function for the initial angle. More...

double &	initial_centre_of_mass (const unsigned &i)
	Access function for the initial centre of mass. More...

const double &	initial_centre_of_mass (const unsigned &i) const
	Access function for the initial centre of mass (const version) More...

void	position (const Vector< double > &xi, Vector< double > &r) const
	Overload the position to apply the rotation and translation. More...

void	position (const unsigned &t, const Vector< double > &xi, Vector< double > &r) const
	Overload to include the time history of the motion of the object. More...

void	dposition_dt (const Vector< double > &zeta, const unsigned &j, Vector< double > &drdt)
	Work out the position derivative, including rigid body motion. More...

	~ImmersedRigidBodyElement ()
	Destuctor: Cleanup if required. More...

double &	mass_shape ()

double &	moment_of_inertia_shape ()
	Access to dimensionless polar "moment of inertia" shape parameter. More...

Data *&	centre_displacement_data_pt ()

double &	centre_x_displacement ()
	x-displacement of centre of mass More...

double &	centre_y_displacement ()
	y-displacement of centre of mass More...

double &	centre_rotation_angle ()
	rotation of centre of mass More...

Vector< double >	centre_of_gravity ()
	Get current centre of gravity. More...

void	pin_centre_of_mass_coordinate (const unsigned &i)
	Pin the i-th coordinate of the centre of mass. More...

void	unpin_centre_of_mass_coordinate (const unsigned &i)
	Unpin the i-th coordinate of the centre of mass. More...

void	pin_rotation_angle ()
	Pin the rotation angle. More...

void	unpin_rotation_angle ()
	Unpin the rotation angle. More...

void	output_centre_of_gravity (std::ostream &outfile)
	Output position velocity and acceleration of centre of gravity. More...

void	fill_in_contribution_to_residuals (Vector< double > &residuals)
	Get the contribution to the residuals. More...

void	fill_in_contribution_to_jacobian (Vector< double > &residuals, DenseMatrix< double > &jacobian)
	Get residuals including contribution to jacobian. More...

void	node_update_adjacent_fluid_elements ()

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)
	Do nothing to reset within finite-differencing of external data. More...

void	reset_after_external_fd ()

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)
	Do nothing to reset within finite-differencing of internal data. More...

void	reset_after_internal_fd ()

void	get_force_and_torque (const double &time, Vector< double > &force, double &torque)

ExternalForceFctPt &	external_force_fct_pt ()

ExternalTorqueFctPt &	external_torque_fct_pt ()

Mesh *const &	drag_mesh_pt ()

void	set_drag_mesh (Mesh *const &drag_mesh_pt)

void	flush_drag_mesh ()
	Function to clear the drag mesh and all associated external data. More...

unsigned	ngeom_data () const
	The position of the object depends on one data item. More...

Data *	geom_data_pt (const unsigned &j)

Vector< double > *&	g_pt ()
	Access function to the direction of gravity. More...

const Vector< double > &	g () const
	Access function for gravity. More...

double *&	re_pt ()
	Access function for the pointer to the fluid Reynolds number. More...

const double &	re () const
	Access function for the fluid Reynolds number. More...

double *&	st_pt ()
	Access function for the pointer to the fluid Strouhal number. More...

const double &	st () const
	Access function for the fluid Strouhal number. More...

double *&	re_invfr_pt ()

const double &	re_invfr ()
	Access to the fluid inverse Froude number. More...

double *&	density_ratio_pt ()
	Access function for the pointer to the density ratio. More...

const double &	density_ratio () const
	Access function for the the density ratio. More...

Public Member Functions inherited from oomph::GeneralisedElement
	GeneralisedElement ()
	Constructor: Initialise all pointers and all values to zero. More...

virtual	~GeneralisedElement ()
	Virtual destructor to clean up any memory allocated by the object. More...

	GeneralisedElement (const GeneralisedElement &)=delete
	Broken copy constructor. More...

void	operator= (const GeneralisedElement &)=delete
	Broken assignment operator. More...

Data *&	internal_data_pt (const unsigned &i)
	Return a pointer to i-th internal data object. More...

Data *const &	internal_data_pt (const unsigned &i) const
	Return a pointer to i-th internal data object (const version) More...

Data *&	external_data_pt (const unsigned &i)
	Return a pointer to i-th external data object. More...

Data *const &	external_data_pt (const unsigned &i) const
	Return a pointer to i-th external data object (const version) More...

unsigned long	eqn_number (const unsigned &ieqn_local) const

int	local_eqn_number (const unsigned long &ieqn_global) const

unsigned	add_external_data (Data *const &data_pt, const bool &fd=true)

bool	external_data_fd (const unsigned &i) const

void	exclude_external_data_fd (const unsigned &i)

void	include_external_data_fd (const unsigned &i)

void	flush_external_data ()
	Flush all external data. More...

void	flush_external_data (Data *const &data_pt)
	Flush the object addressed by data_pt from the external data array. More...

unsigned	ninternal_data () const
	Return the number of internal data objects. More...

unsigned	nexternal_data () const
	Return the number of external data objects. More...

unsigned	ndof () const
	Return the number of equations/dofs in the element. More...

void	dof_vector (const unsigned &t, Vector< double > &dof)
	Return the vector of dof values at time level t. More...

void	dof_pt_vector (Vector< double * > &dof_pt)
	Return the vector of pointers to dof values. More...

void	set_internal_data_time_stepper (const unsigned &i, TimeStepper *const &time_stepper_pt, const bool &preserve_existing_data)

void	assign_internal_eqn_numbers (unsigned long &global_number, Vector< double * > &Dof_pt)

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

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

void	add_internal_value_pt_to_map (std::map< unsigned, double * > &map_of_value_pt)

virtual void	assign_local_eqn_numbers (const bool &store_local_dof_pt)

virtual void	complete_setup_of_dependencies ()

virtual void	get_residuals (Vector< double > &residuals)

virtual void	get_jacobian (Vector< double > &residuals, DenseMatrix< double > &jacobian)

virtual void	get_mass_matrix (Vector< double > &residuals, DenseMatrix< double > &mass_matrix)

virtual void	get_jacobian_and_mass_matrix (Vector< double > &residuals, DenseMatrix< double > &jacobian, DenseMatrix< double > &mass_matrix)

virtual void	get_dresiduals_dparameter (double *const &parameter_pt, Vector< double > &dres_dparam)

virtual void	get_djacobian_dparameter (double *const &parameter_pt, Vector< double > &dres_dparam, DenseMatrix< double > &djac_dparam)

virtual void	get_djacobian_and_dmass_matrix_dparameter (double *const &parameter_pt, Vector< double > &dres_dparam, DenseMatrix< double > &djac_dparam, DenseMatrix< double > &dmass_matrix_dparam)

virtual void	get_hessian_vector_products (Vector< double > const &Y, DenseMatrix< double > const &C, DenseMatrix< double > &product)

virtual void	get_inner_products (Vector< std::pair< unsigned, unsigned >> const &history_index, Vector< double > &inner_product)

virtual void	get_inner_product_vectors (Vector< unsigned > const &history_index, Vector< Vector< double >> &inner_product_vector)

virtual unsigned	self_test ()

virtual void	compute_norm (Vector< double > &norm)

virtual void	compute_norm (double &norm)

virtual unsigned	ndof_types () const

virtual void	get_dof_numbers_for_unknowns (std::list< std::pair< unsigned long, unsigned >> &dof_lookup_list) const

Public Member Functions inherited from oomph::GeomObject
	GeomObject ()
	Default constructor. More...

	GeomObject (const unsigned &ndim)

	GeomObject (const unsigned &nlagrangian, const unsigned &ndim)

	GeomObject (const unsigned &nlagrangian, const unsigned &ndim, TimeStepper *time_stepper_pt)

	GeomObject (const GeomObject &dummy)=delete
	Broken copy constructor. More...

void	operator= (const GeomObject &)=delete
	Broken assignment operator. More...

virtual	~GeomObject ()
	(Empty) destructor More...

unsigned	nlagrangian () const
	Access function to # of Lagrangian coordinates. More...

unsigned	ndim () const
	Access function to # of Eulerian coordinates. More...

void	set_nlagrangian_and_ndim (const unsigned &n_lagrangian, const unsigned &n_dim)
	Set # of Lagrangian and Eulerian coordinates. More...

TimeStepper *&	time_stepper_pt ()

TimeStepper *	time_stepper_pt () const

virtual void	position (const double &t, const Vector< double > &zeta, Vector< double > &r) const

virtual void	dposition (const Vector< double > &zeta, DenseMatrix< double > &drdzeta) const

virtual void	d2position (const Vector< double > &zeta, RankThreeTensor< double > &ddrdzeta) const

virtual void	d2position (const Vector< double > &zeta, Vector< double > &r, DenseMatrix< double > &drdzeta, RankThreeTensor< double > &ddrdzeta) const

virtual void	locate_zeta (const Vector< double > &zeta, GeomObject *&sub_geom_object_pt, Vector< double > &s, const bool &use_coordinate_as_initial_guess=false)

virtual void	interpolated_zeta (const Vector< double > &s, Vector< double > &zeta) const

Protected Member Functions
	ImmersedRigidBodyElement (TimeStepper const &time_stepper_pt, Data const &centre_displacement_data_pt=0)

void	apply_rigid_body_motion (const unsigned &t, const Vector< double > &initial_x, Vector< double > &r) const

Protected Member Functions inherited from oomph::GeneralisedElement
unsigned	add_internal_data (Data *const &data_pt, const bool &fd=true)

bool	internal_data_fd (const unsigned &i) const

void	exclude_internal_data_fd (const unsigned &i)

void	include_internal_data_fd (const unsigned &i)

void	clear_global_eqn_numbers ()

void	add_global_eqn_numbers (std::deque< unsigned long > const &global_eqn_numbers, std::deque< double * > const &global_dof_pt)

virtual void	assign_internal_and_external_local_eqn_numbers (const bool &store_local_dof_pt)

virtual void	assign_all_generic_local_eqn_numbers (const bool &store_local_dof_pt)

virtual void	assign_additional_local_eqn_numbers ()

int	internal_local_eqn (const unsigned &i, const unsigned &j) const

int	external_local_eqn (const unsigned &i, const unsigned &j)

void	fill_in_jacobian_from_internal_by_fd (Vector< double > &residuals, DenseMatrix< double > &jacobian, const bool &fd_all_data=false)

void	fill_in_jacobian_from_internal_by_fd (DenseMatrix< double > &jacobian, const bool &fd_all_data=false)

void	fill_in_jacobian_from_external_by_fd (Vector< double > &residuals, DenseMatrix< double > &jacobian, const bool &fd_all_data=false)

void	fill_in_jacobian_from_external_by_fd (DenseMatrix< double > &jacobian, const bool &fd_all_data=false)

virtual void	update_before_internal_fd ()

virtual void	update_before_external_fd ()

virtual void	fill_in_contribution_to_mass_matrix (Vector< double > &residuals, DenseMatrix< double > &mass_matrix)

virtual void	fill_in_contribution_to_jacobian_and_mass_matrix (Vector< double > &residuals, DenseMatrix< double > &jacobian, DenseMatrix< double > &mass_matrix)

virtual void	fill_in_contribution_to_dresiduals_dparameter (double *const &parameter_pt, Vector< double > &dres_dparam)

virtual void	fill_in_contribution_to_djacobian_dparameter (double *const &parameter_pt, Vector< double > &dres_dparam, DenseMatrix< double > &djac_dparam)

virtual void	fill_in_contribution_to_djacobian_and_dmass_matrix_dparameter (double *const &parameter_pt, Vector< double > &dres_dparam, DenseMatrix< double > &djac_dparam, DenseMatrix< double > &dmass_matrix_dparam)

virtual void	fill_in_contribution_to_hessian_vector_products (Vector< double > const &Y, DenseMatrix< double > const &C, DenseMatrix< double > &product)

virtual void	fill_in_contribution_to_inner_products (Vector< std::pair< unsigned, unsigned >> const &history_index, Vector< double > &inner_product)

virtual void	fill_in_contribution_to_inner_product_vectors (Vector< unsigned > const &history_index, Vector< Vector< double >> &inner_product_vector)

Protected Attributes
Vector< double >	Initial_centre_of_mass
	X-coordinate of initial centre of gravity. More...

double	Initial_Phi
	Original rotation angle. More...

double	Mass

double	Moment_of_inertia
	Polar moment of inertia of body. More...

Data *	Centre_displacement_data_pt

Protected Attributes inherited from oomph::GeomObject
unsigned	NLagrangian
	Number of Lagrangian (intrinsic) coordinates. More...

unsigned	Ndim
	Number of Eulerian coordinates. More...

TimeStepper *	Geom_object_time_stepper_pt

Private Member Functions
int	centre_displacement_local_eqn (const unsigned &i)

void	initialise (TimeStepper *const &time_stepper_pt)
	Initialisation function. More...

void	get_residuals_rigid_body_generic (Vector< double > &residuals, DenseMatrix< double > &jacobian, const bool &flag)
	Get residuals and/or Jacobian. More...

void	delete_external_hijacked_data ()
	Delete the storage for the external data formed from hijacked data. More...

Private Attributes
std::list< unsigned >	List_of_external_hijacked_data

GeomObject *	Geom_object_pt
	Underlying geometric object. More...

ExternalForceFctPt	External_force_fct_pt

ExternalTorqueFctPt	External_torque_fct_pt

Mesh *	Drag_mesh_pt

Vector< double > *	G_pt
	The direction of gravity. More...

double *	Re_pt
	Reynolds number of external fluid. More...

double *	St_pt
	Strouhal number of external fluid. More...

double *	ReInvFr_pt
	Reynolds number divided by Froude number of external fluid. More...

double *	Density_ratio_pt
	Density ratio of the solid to the external fluid. More...

unsigned	Index_for_centre_displacement

bool	Displacement_data_is_internal
	Boolean flag to indicate whether data is internal. More...

bool	Include_geometric_rotation

Static Private Attributes
static double	Default_Physical_Constant_Value = 0.0
	Static default value for physical constants. More...

static double	Default_Physical_Ratio_Value = 1.0
	Static default value for physical ratios. More...

static Vector< double >	Default_Gravity_vector
	Static default value for gravity. More...

Additional Inherited Members
Static Public Attributes inherited from oomph::GeneralisedElement
static bool	Suppress_warning_about_repeated_internal_data

static bool	Suppress_warning_about_repeated_external_data = true

static double	Default_fd_jacobian_step = 1.0e-8

Static Protected Attributes inherited from oomph::GeneralisedElement
static DenseMatrix< double >	Dummy_matrix

static std::deque< double * >	Dof_pt_deque

Detailed Description

Class that solves the equations of motion for a general two-dimensional rigid body subject to a particular imposed force and torque distribution and immersed within an external fluid. The body's position is entirely specified by the location of its centre of mass, $\mbox{\boldmath$X$}$, and a single angle, $\phi$, that represents a possible rotation. The equations of motion are then simply Newton's second law for the conservation of linear momentum in two directions and angular momentum about the single possible axis of rotation.

The non-dimensionalisation is based on the viscous scales of the surrounding fluid, in which case, the governing equations are

\[ Re St^{2} M \frac{\mbox{d}^{2} \mbox{\boldmath$X$}}{\mbox{d} t^{2}} = \mbox{\boldmath$F$} + \oint \mbox{\boldmath$t$} \mbox{d} s \quad\mbox{and}\quad Re St^{2} I \frac{\mbox{d}^{2}\Phi}{\mbox{d} t^{2}} = \mbox{\boldmath$T$} + \oint \mbox{\boldmath$q$} \mbox{d} s, \]

where $\mbox{\boldmath$F$} = \mbox{\boldmath$F$}^{*}/\mu U$ is the external force per unit length; $\mbox{\boldmath$t$}$ is the net force per unit length applied on the rigid body by the surrounding fluid; $\mbox{\boldmath$T$} = \mbox{\boldmath$T$}^{*}/(\mu UL)$ is the external torque per unit length; and $\mbox{\boldmath$q$}$ is the net torque per unit length applied on the body by the fluid. $M$ is a scaled mass the density ratio multiplied by a shape parameter and $I$ is a scaled moment of inertia. Finally, $Re$ and $St$ are the Reynolds and Strouhal numbers of the surrounding fluid. Note that these equations may be used without the external fluid, in which case the non-dimensionalisation doesn't make a lot of sense, but may be re-interpreted accordingly.

A Data object whose three values represent the x and y displacements of the body's centre of mass and its rotation about the centre of mass may be passed in as external data or, if not, it will be constructed internally.

For general usage, an underlying geometric object must passed to the constructor and the position will be determined by applying rigid body motions to the underlying object based on the initial_centre_of_mass and initial_phi (angle), which default to zero. If these defaults are not suitable, the values must be set externally. In addition a mass and moment of inertia should also be set externally.

If added to a mesh in the Problem (in its incarnation as a GeneralisedElement) the displacement/rotation of the body is computed in response to (i) user-specifiable applied forces and a torque and (ii) the net drag (and associated torque) from a mesh of elements that can exert a drag onto the body (typically Navier-Stokes FaceElements that apply a viscous drag to an immersed body, represented by the body.)

Member Typedef Documentation

◆ ExternalForceFctPt

typedef void(* oomph::ImmersedRigidBodyElement::ExternalForceFctPt) (const double &time, Vector< double > &external_force)

Function pointer to function that specifies external force

◆ ExternalTorqueFctPt

typedef void(* oomph::ImmersedRigidBodyElement::ExternalTorqueFctPt) (const double &time, double &external_torque)

Function pointer to function that specifies external torque

Constructor & Destructor Documentation

◆ ImmersedRigidBodyElement() [1/2]

oomph::ImmersedRigidBodyElement::ImmersedRigidBodyElement	(	TimeStepper *const &	time_stepper_pt,
		Data *const &	centre_displacement_data_pt = `0`
	)

inlineprotected

Default constructor that intialises everything to zero. This is expected to be called only from derived clases such as the ImmersedRigidBodyTriangleMeshPolygon that can provided their own position() functions.

       : Initial_Phi(0.0),
         Mass(0.0),
         Moment_of_inertia(0.0),
         Centre_displacement_data_pt(centre_displacement_data_pt),
         Geom_object_pt(0),
         External_force_fct_pt(0),
         External_torque_fct_pt(0),
         Drag_mesh_pt(0),
         G_pt(&Default_Gravity_vector),
         Re_pt(&Default_Physical_Constant_Value),
         St_pt(&Default_Physical_Ratio_Value),
         ReInvFr_pt(&Default_Physical_Constant_Value),
         Density_ratio_pt(&Default_Physical_Ratio_Value),
         Include_geometric_rotation(true)
     {
       this->initialise(time_stepper_pt);
     }

References initialise().

◆ ImmersedRigidBodyElement() [2/2]

oomph::ImmersedRigidBodyElement::ImmersedRigidBodyElement	(	GeomObject *const &	geom_object_pt,
		TimeStepper *const &	time_stepper_pt,
		Data *const &	centre_displacement_data_pt = `0`
	)

inline

Constructor that takes an underlying geometric object: and timestepper.

       : Initial_Phi(0.0),
         Mass(0.0),
         Moment_of_inertia(0.0),
         Centre_displacement_data_pt(centre_displacement_data_pt),
         Geom_object_pt(geom_object_pt),
         External_force_fct_pt(0),
         External_torque_fct_pt(0),
         Drag_mesh_pt(0),
         G_pt(&Default_Gravity_vector),
         Re_pt(&Default_Physical_Constant_Value),
         St_pt(&Default_Physical_Ratio_Value),
         ReInvFr_pt(&Default_Physical_Constant_Value),
         Density_ratio_pt(&Default_Physical_Ratio_Value),
         Include_geometric_rotation(true)
     {
       this->initialise(time_stepper_pt);
     }

References initialise().

◆ ~ImmersedRigidBodyElement()

oomph::ImmersedRigidBodyElement::~ImmersedRigidBodyElement ( )

inline

Destuctor: Cleanup if required.

     {
       if (Displacement_data_is_internal)
       {
         delete Centre_displacement_data_pt;
         // Null out the pointer stored as internal data
         this->internal_data_pt(0) = 0;
       }
     }

References Centre_displacement_data_pt, Displacement_data_is_internal, and oomph::GeneralisedElement::internal_data_pt().

Member Function Documentation

◆ apply_rigid_body_motion()

void oomph::ImmersedRigidBodyElement::apply_rigid_body_motion	(	const unsigned &	t,
		const Vector< double > &	initial_x,
		Vector< double > &	r
	)		const

inlineprotected

Helper function to adjust the position in response to changes in position and angle of the solid about the centre of mass

     {
       // Scale relative to the centre of mass
       double X = initial_x[0] - Initial_centre_of_mass[0];
       double Y = initial_x[1] - Initial_centre_of_mass[1];
  
       // Find the original angle and radius
       double phi_orig = atan2(Y, X);
       double r_orig = sqrt(X * X + Y * Y);
  
       // Updated position vector
       r[0] = Initial_centre_of_mass[0] +
              this->Centre_displacement_data_pt->value(t, 0);
  
       r[1] = Initial_centre_of_mass[1] +
              this->Centre_displacement_data_pt->value(t, 1);
  
       // Add in the rotation terms if there are to be included
       if (Include_geometric_rotation)
       {
         r[0] += r_orig *
                 cos(phi_orig + this->Centre_displacement_data_pt->value(t, 2));
         r[1] += r_orig *
                 sin(phi_orig + this->Centre_displacement_data_pt->value(t, 2));
       }
       else
       {
         r[0] += r_orig * cos(phi_orig);
         r[1] += r_orig * sin(phi_orig);
       }
     }

References atan2(), Centre_displacement_data_pt, cos(), Include_geometric_rotation, Initial_centre_of_mass, UniformPSDSelfTest::r, sin(), sqrt(), oomph::Data::value(), X, and Y.

Referenced by position(), oomph::ImmersedRigidBodyTriangleMeshPolygon::position(), and oomph::ImmersedRigidBodyTriangleMeshPolygon::reset_reference_configuration().

◆ centre_displacement_data_pt()

Data*& oomph::ImmersedRigidBodyElement::centre_displacement_data_pt ( )

inline

Pointer to Data for centre of gravity displacement. Values: 0: x-displ; 1: y-displ; 2: rotation angle.

     {
       return Centre_displacement_data_pt;
     }

References Centre_displacement_data_pt.

◆ centre_displacement_local_eqn()

int oomph::ImmersedRigidBodyElement::centre_displacement_local_eqn ( const unsigned & i )

inlineprivate

Return the equation number associated with the i-th centre of gravity displacment 0: x-displ; 1: y-displ; 2: rotation angle.

     {
       if (Displacement_data_is_internal)
       {
         return this->internal_local_eqn(Index_for_centre_displacement, i);
       }
       else
       {
         return this->external_local_eqn(Index_for_centre_displacement, i);
       }
     }

References Displacement_data_is_internal, oomph::GeneralisedElement::external_local_eqn(), Index_for_centre_displacement, and oomph::GeneralisedElement::internal_local_eqn().

Referenced by get_residuals_rigid_body_generic().

◆ centre_of_gravity()

Vector<double> oomph::ImmersedRigidBodyElement::centre_of_gravity ( )

inline

Get current centre of gravity.

     {
       Vector<double> cog(2);
       for (unsigned i = 0; i < 2; i++)
       {
         cog[i] = Initial_centre_of_mass[i] +
                  this->Centre_displacement_data_pt->value(i);
       }
       return cog;
     }

References Centre_displacement_data_pt, i, Initial_centre_of_mass, and oomph::Data::value().

◆ centre_rotation_angle()

double& oomph::ImmersedRigidBodyElement::centre_rotation_angle ( )

inline

rotation of centre of mass

     {
       return *(Centre_displacement_data_pt->value_pt(2));
     }

References Centre_displacement_data_pt, and oomph::Data::value_pt().

◆ centre_x_displacement()

double& oomph::ImmersedRigidBodyElement::centre_x_displacement ( )

inline

x-displacement of centre of mass

     {
       return *(Centre_displacement_data_pt->value_pt(0));
     }

References Centre_displacement_data_pt, and oomph::Data::value_pt().

◆ centre_y_displacement()

double& oomph::ImmersedRigidBodyElement::centre_y_displacement ( )

inline

y-displacement of centre of mass

     {
       return *(Centre_displacement_data_pt->value_pt(1));
     }

References Centre_displacement_data_pt, and oomph::Data::value_pt().

◆ delete_external_hijacked_data()

void oomph::ImmersedRigidBodyElement::delete_external_hijacked_data ( )

inlineprivate

Delete the storage for the external data formed from hijacked data.

     {
       for (std::list<unsigned>::iterator it =
              List_of_external_hijacked_data.begin();
            it != List_of_external_hijacked_data.end();
            ++it)
       {
         // Delete the associated external data
         delete this->external_data_pt(*it);
         this->external_data_pt(*it) = 0;
       }
       // Now clear the list
       List_of_external_hijacked_data.clear();
     }

References oomph::GeneralisedElement::external_data_pt(), and List_of_external_hijacked_data.

Referenced by flush_drag_mesh(), and set_drag_mesh().

◆ density_ratio()

const double& oomph::ImmersedRigidBodyElement::density_ratio ( ) const

inline

Access function for the the density ratio.

     {
       return *Density_ratio_pt;
     }

References Density_ratio_pt.

Referenced by get_residuals_rigid_body_generic().

◆ density_ratio_pt()

double*& oomph::ImmersedRigidBodyElement::density_ratio_pt ( )

inline

Access function for the pointer to the density ratio.

     {
       return Density_ratio_pt;
     }

References Density_ratio_pt.

Referenced by UnstructuredImmersedEllipseProblem< ELEMENT >::UnstructuredImmersedEllipseProblem().

◆ dposition_dt()

void oomph::ImmersedRigidBodyElement::dposition_dt	(	const Vector< double > &	zeta,
		const unsigned &	j,
		Vector< double > &	drdt
	)

virtual

Work out the position derivative, including rigid body motion.

Work out the position derivative taking into account the movement relative to the original centre of mass

Reimplemented from oomph::GeomObject.

   {
     // Switch on time level
     switch (j)
     {
         // Current time, just return the position
       case 0:
         return position(zeta, drdt);
         break;
  
         // Time derivative
       case 1:
       {
         // Get the initial position of the underlying geometric object
         Vector<double> initial_x(2);
         Geom_object_pt->position(zeta, initial_x);
         // Scale relative to the centre of mass
         double X = initial_x[0] - Initial_centre_of_mass[0];
         double Y = initial_x[1] - Initial_centre_of_mass[1];
  
         // Now calculate the original angle and radius
         double phi_orig = atan2(Y, X);
         double r_orig = sqrt(X * X + Y * Y);
  
         // Get first time derivatives of all displacement data
         Vector<double> veloc(3);
         // Get the velocity of the data
         this->Centre_displacement_data_pt->time_stepper_pt()->time_derivative(
           1, this->Centre_displacement_data_pt, veloc);
  
         // Now use the chain rule to specify the boundary velocities
         drdt[0] = veloc[0];
         drdt[1] = veloc[1];
  
         if (Include_geometric_rotation)
         {
           drdt[0] +=
             -r_orig *
             sin(phi_orig + this->Centre_displacement_data_pt->value(2)) *
             veloc[2];
           drdt[1] +=
             r_orig *
             cos(phi_orig + this->Centre_displacement_data_pt->value(2)) *
             veloc[2];
         }
       }
         // Done
         return;
         break;
  
       default:
         std::ostringstream warning_stream;
         warning_stream
           << "Using default (static) assignment " << j
           << "-th time derivative in GeomObject::dposition_dt(...) is zero\n"
           << "Overload for your specific geometric object if this is not \n"
           << "appropriate. \n";
         OomphLibWarning(warning_stream.str(),
                         "GeomObject::dposition_dt()",
                         OOMPH_EXCEPTION_LOCATION);
  
         unsigned n = drdt.size();
         for (unsigned i = 0; i < n; i++)
         {
           drdt[i] = 0.0;
         }
         break;
     }
   }

References atan2(), Centre_displacement_data_pt, cos(), Geom_object_pt, i, Include_geometric_rotation, Initial_centre_of_mass, j, n, OOMPH_EXCEPTION_LOCATION, position(), oomph::GeomObject::position(), sin(), sqrt(), oomph::TimeStepper::time_derivative(), oomph::Data::time_stepper_pt(), oomph::Data::value(), X, Y, and Eigen::zeta().

◆ drag_mesh_pt()

Mesh* const& oomph::ImmersedRigidBodyElement::drag_mesh_pt ( )

inline

Access fct to mesh containing face elements that allow the computation of the drag on the body

     {
       return Drag_mesh_pt;
     }

References Drag_mesh_pt.

Referenced by set_drag_mesh().

◆ external_force_fct_pt()

ExternalForceFctPt& oomph::ImmersedRigidBodyElement::external_force_fct_pt ( )

inline

Access to function pointer to function that specifies external force

     {
       return External_force_fct_pt;
     }

References External_force_fct_pt.

◆ external_torque_fct_pt()

ExternalTorqueFctPt& oomph::ImmersedRigidBodyElement::external_torque_fct_pt ( )

inline

Access to function pointer to function that specifies external torque

     {
       return External_torque_fct_pt;
     }

References External_torque_fct_pt.

◆ fill_in_contribution_to_jacobian()

void oomph::ImmersedRigidBodyElement::fill_in_contribution_to_jacobian	(	Vector< double > &	residuals,
		DenseMatrix< double > &	jacobian
	)

inlinevirtual

Get residuals including contribution to jacobian.

Reimplemented from oomph::GeneralisedElement.

     {
       // Get generic function, but don't bother to get jacobian terms
       bool flag = false;
       get_residuals_rigid_body_generic(residuals, jacobian, flag);
       // Get the internal effects by FD, because a change in internal
       // data can change the fluid loading, so this is one of those
       // subtle interactions
       this->fill_in_jacobian_from_internal_by_fd(residuals, jacobian);
       // Get the effect of the fluid loading on the rigid body
       this->fill_in_jacobian_from_external_by_fd(residuals, jacobian);
     }

References oomph::GeneralisedElement::fill_in_jacobian_from_external_by_fd(), oomph::GeneralisedElement::fill_in_jacobian_from_internal_by_fd(), and get_residuals_rigid_body_generic().

◆ fill_in_contribution_to_residuals()

void oomph::ImmersedRigidBodyElement::fill_in_contribution_to_residuals ( Vector< double > & residuals )

inlinevirtual

Get the contribution to the residuals.

Reimplemented from oomph::GeneralisedElement.

     {
       // Get generic function without jacobian terms
       get_residuals_rigid_body_generic(
         residuals, GeneralisedElement::Dummy_matrix, false);
     }

References oomph::GeneralisedElement::Dummy_matrix, and get_residuals_rigid_body_generic().

◆ flush_drag_mesh()

void oomph::ImmersedRigidBodyElement::flush_drag_mesh ( )

inline

Function to clear the drag mesh and all associated external data.

     {
       // Delete the hijacked data created as the load
       this->delete_external_hijacked_data();
       // Flush the external data
       this->flush_external_data();
       // Set the Drag_mesh pointer to null
       Drag_mesh_pt = 0;
     }

References delete_external_hijacked_data(), Drag_mesh_pt, and oomph::GeneralisedElement::flush_external_data().

◆ g()

const Vector<double>& oomph::ImmersedRigidBodyElement::g ( ) const

inline

Access function for gravity.

     {
       return *G_pt;
     }

References G_pt.

Referenced by get_residuals_rigid_body_generic().

◆ g_pt()

Vector<double>*& oomph::ImmersedRigidBodyElement::g_pt ( )

inline

Access function to the direction of gravity.

     {
       return G_pt;
     }

References G_pt.

◆ geom_data_pt()

Data* oomph::ImmersedRigidBodyElement::geom_data_pt ( const unsigned & j )

inlinevirtual

Return pointer to the j-th (only) Data item that the object's shape depends on.

Reimplemented from oomph::GeomObject.

     {
       return this->Centre_displacement_data_pt;
     }

References Centre_displacement_data_pt.

Referenced by UnstructuredImmersedEllipseProblem< ELEMENT >::create_drag_elements().

◆ get_force_and_torque()

void oomph::ImmersedRigidBodyElement::get_force_and_torque	(	const double &	time,
		Vector< double > &	force,
		double &	torque
	)

Get force and torque from specified fct pointers and drag mesh

Obtain the external force and torque on the body from specified function pointers and also from a drag mesh, if there is one

   {
     // Get external force
     if (External_force_fct_pt == 0)
     {
       force[0] = 0.0;
       force[1] = 0.0;
     }
     else
     {
       External_force_fct_pt(time, force);
     }
  
     // Get external torque
     if (External_torque_fct_pt == 0)
     {
       torque = 0.0;
     }
     else
     {
       External_torque_fct_pt(time, torque);
     }
  
     // Add drag from any (fluid) mesh attached to surface of body
     Vector<double> element_drag_force(2);
     Vector<double> element_drag_torque(1);
     if (Drag_mesh_pt == 0)
     {
       return;
     }
     else
     {
       unsigned nel = Drag_mesh_pt->nelement();
  
       for (unsigned e = 0; e < nel; e++)
       {
         dynamic_cast<ElementWithDragFunction*>(Drag_mesh_pt->element_pt(e))
           ->get_drag_and_torque(element_drag_force, element_drag_torque);
         force[0] += element_drag_force[0];
         force[1] += element_drag_force[1];
         torque += element_drag_torque[0];
       }
     }
   }

References Drag_mesh_pt, e(), oomph::Mesh::element_pt(), External_force_fct_pt, External_torque_fct_pt, and oomph::Mesh::nelement().

Referenced by get_residuals_rigid_body_generic().

◆ get_residuals_rigid_body_generic()

void oomph::ImmersedRigidBodyElement::get_residuals_rigid_body_generic	(	Vector< double > &	residuals,
		DenseMatrix< double > &	jacobian,
		const bool &	flag
	)

private

Get residuals and/or Jacobian.

Calculate the contributions to the residuals and the jacobian.

   {
     // Get timestepper and time
     TimeStepper* timestepper_pt =
       this->Centre_displacement_data_pt->time_stepper_pt();
     double time = timestepper_pt->time();
  
     // Get second time derivatives of all displacement data
     Vector<double> accel(3);
     timestepper_pt->time_derivative(
       2, this->Centre_displacement_data_pt, accel);
  
     // Get force and torque
     Vector<double> external_force(2);
     double external_torque;
     get_force_and_torque(time, external_force, external_torque);
  
     // Get the timescale ratio product of Reynolds number
     // and Strouhal number squared
     const double Lambda_sq =
       this->re() * this->st() * this->st() * this->density_ratio();
  
     // Get the effective ReInvFr which must be multiplied by the
     // density ratio to compute the gravitational load on the rigid body
     const double scaled_re_inv_fr = this->re_invfr() * this->density_ratio();
     // Get the gravitational load
     Vector<double> G = g();
  
     // Newton's law
     int local_eqn = 0;
     local_eqn = this->centre_displacement_local_eqn(0);
     if (local_eqn >= 0)
     {
       residuals[local_eqn] = Lambda_sq * Mass * accel[0] - external_force[0] -
                              Mass * scaled_re_inv_fr * G[0];
  
       // Get Jacobian too?
       if (flag)
       {
         jacobian(local_eqn, local_eqn) =
           Lambda_sq * Mass * timestepper_pt->weight(2, 0);
       }
     }
  
     local_eqn = this->centre_displacement_local_eqn(1);
     if (local_eqn >= 0)
     {
       residuals[local_eqn] = Lambda_sq * Mass * accel[1] - external_force[1] -
                              Mass * scaled_re_inv_fr * G[1];
       // Get Jacobian too?
       if (flag)
       {
         jacobian(local_eqn, local_eqn) =
           Lambda_sq * Mass * timestepper_pt->weight(2, 0);
       }
     }
  
     local_eqn = this->centre_displacement_local_eqn(2);
     if (local_eqn >= 0)
     {
       residuals[local_eqn] =
         Lambda_sq * Moment_of_inertia * accel[2] - external_torque;
       // Get Jacobian too?
       if (flag)
       {
         jacobian(local_eqn, local_eqn) =
           Lambda_sq * Moment_of_inertia * timestepper_pt->weight(2, 0);
       }
     }
   }

References Centre_displacement_data_pt, centre_displacement_local_eqn(), density_ratio(), G, g(), get_force_and_torque(), Global_Physical_Variables::Lambda_sq, Mass, Moment_of_inertia, re(), re_invfr(), st(), oomph::TimeStepper::time(), oomph::TimeStepper::time_derivative(), oomph::Data::time_stepper_pt(), and oomph::TimeStepper::weight().

Referenced by fill_in_contribution_to_jacobian(), and fill_in_contribution_to_residuals().

◆ initial_centre_of_mass() [1/2]

double& oomph::ImmersedRigidBodyElement::initial_centre_of_mass ( const unsigned & i )

inline

Access function for the initial centre of mass.

     {
       return Initial_centre_of_mass[i];
     }

References i, and Initial_centre_of_mass.

Referenced by UnstructuredImmersedEllipseProblem< ELEMENT >::create_drag_elements(), and UnstructuredImmersedEllipseProblem< ELEMENT >::UnstructuredImmersedEllipseProblem().

◆ initial_centre_of_mass() [2/2]

const double& oomph::ImmersedRigidBodyElement::initial_centre_of_mass ( const unsigned & i ) const

inline

Access function for the initial centre of mass (const version)

     {
       return Initial_centre_of_mass[i];
     }

References i, and Initial_centre_of_mass.

◆ initial_phi()

double& oomph::ImmersedRigidBodyElement::initial_phi ( )

inline

Access function for the initial angle.

     {
       return Initial_Phi;
     }

References Initial_Phi.

◆ initialise()

void oomph::ImmersedRigidBodyElement::initialise ( TimeStepper *const & time_stepper_pt )

private

Initialisation function.

Initialise the internal data.

   {
     // This could be calculated by an integral around the boundary
     Initial_centre_of_mass.resize(2, 0.0);
  
     // Temporary hack
     if (time_stepper_pt == 0)
     {
       return;
     }
  
     // Provide Data for centre-of-mass displacement internally
     if (Centre_displacement_data_pt == 0)
     {
       Centre_displacement_data_pt = new Data(time_stepper_pt, 3);
  
       // I've created it so I have to tidy up too!
       Displacement_data_is_internal = true;
  
       // Centre displacement is internal Data for this element
       Index_for_centre_displacement =
         add_internal_data(Centre_displacement_data_pt);
     }
     // Data created externally, so somebody else will clean up
     else
     {
       Displacement_data_is_internal = false;
  
       // Centre displacement is external Data for this element
       Index_for_centre_displacement =
         add_external_data(Centre_displacement_data_pt);
     }
   }

References oomph::GeneralisedElement::add_external_data(), oomph::GeneralisedElement::add_internal_data(), Centre_displacement_data_pt, Displacement_data_is_internal, Index_for_centre_displacement, Initial_centre_of_mass, and oomph::GeomObject::time_stepper_pt().

Referenced by ImmersedRigidBodyElement().

◆ mass_shape()

double& oomph::ImmersedRigidBodyElement::mass_shape ( )

inline

Access to dimensionless "mass" shape parameter that must be set by hand for non polygonal shapes

     {
       return Mass;
     }

References Mass.

Referenced by UnstructuredImmersedEllipseProblem< ELEMENT >::UnstructuredImmersedEllipseProblem().

◆ moment_of_inertia_shape()

double& oomph::ImmersedRigidBodyElement::moment_of_inertia_shape ( )

inline

Access to dimensionless polar "moment of inertia" shape parameter.

     {
       return Moment_of_inertia;
     }

References Moment_of_inertia.

Referenced by UnstructuredImmersedEllipseProblem< ELEMENT >::UnstructuredImmersedEllipseProblem().

◆ ngeom_data()

unsigned oomph::ImmersedRigidBodyElement::ngeom_data ( ) const

inlinevirtual

The position of the object depends on one data item.

Reimplemented from oomph::GeomObject.

     {
       return 1;
     }

◆ node_update_adjacent_fluid_elements()

void oomph::ImmersedRigidBodyElement::node_update_adjacent_fluid_elements ( )

inline

Update the positions of the nodes in fluid elements adjacent to the rigid body, defined as being elements in the drag mesh.

     {
       // If there is no drag mesh then do nothing
       if (Drag_mesh_pt == 0)
       {
         return;
       }
       // Otherwise update the elements adjacent to the rigid body
       //(all the elements adjacent to those in the drag mesh)
       else
       {
         unsigned nel = Drag_mesh_pt->nelement();
         for (unsigned e = 0; e < nel; e++)
         {
           dynamic_cast<FaceElement*>(Drag_mesh_pt->element_pt(e))
             ->bulk_element_pt()
             ->node_update();
         }
       }
     }

References Drag_mesh_pt, e(), oomph::Mesh::element_pt(), oomph::Mesh::nelement(), and oomph::FiniteElement::node_update().

Referenced by reset_after_external_fd(), reset_after_internal_fd(), update_in_external_fd(), and update_in_internal_fd().

◆ output_centre_of_gravity()

void oomph::ImmersedRigidBodyElement::output_centre_of_gravity ( std::ostream & outfile )

Output position velocity and acceleration of centre of gravity.

Output the position of the centre of gravity including velocities and accelerations

   {
     // Get timestepper
     TimeStepper* time_stepper_pt =
       this->Centre_displacement_data_pt->time_stepper_pt();
  
     // Get first time derivatives of all displacement data
     Vector<double> veloc(3);
     time_stepper_pt->time_derivative(
       1, this->Centre_displacement_data_pt, veloc);
  
     // Get second time derivatives of all displacement data
     Vector<double> accel(3);
     time_stepper_pt->time_derivative(
       2, this->Centre_displacement_data_pt, accel);
  
     outfile << time_stepper_pt->time() << " "
             << Initial_centre_of_mass[0] +
                  this->Centre_displacement_data_pt->value(0)
             << " "
             << Initial_centre_of_mass[1] +
                  this->Centre_displacement_data_pt->value(1)
             << " " << Initial_Phi + this->Centre_displacement_data_pt->value(2)
             << " " << veloc[0] << " " << veloc[1] << " " << veloc[2] << " "
             << accel[0] << " " << accel[1] << " " << accel[2] << std::endl;
   }

References Centre_displacement_data_pt, Initial_centre_of_mass, Initial_Phi, oomph::TimeStepper::time(), oomph::TimeStepper::time_derivative(), oomph::GeomObject::time_stepper_pt(), oomph::Data::time_stepper_pt(), and oomph::Data::value().

◆ pin_centre_of_mass_coordinate()

void oomph::ImmersedRigidBodyElement::pin_centre_of_mass_coordinate ( const unsigned & i )

inline

Pin the i-th coordinate of the centre of mass.

     {
       Centre_displacement_data_pt->pin(i);
     }

References Centre_displacement_data_pt, i, and oomph::Data::pin().

Referenced by UnstructuredImmersedEllipseProblem< ELEMENT >::solve_for_consistent_nodal_positions(), and UnstructuredImmersedEllipseProblem< ELEMENT >::UnstructuredImmersedEllipseProblem().

◆ pin_rotation_angle()

void oomph::ImmersedRigidBodyElement::pin_rotation_angle ( )

inline

Pin the rotation angle.

     {
       Centre_displacement_data_pt->pin(2);
     }

References Centre_displacement_data_pt, and oomph::Data::pin().

◆ position() [1/2]

void oomph::ImmersedRigidBodyElement::position	(	const unsigned &	t,
		const Vector< double > &	xi,
		Vector< double > &	r
	)		const

inlinevirtual

Overload to include the time history of the motion of the object.

Reimplemented from oomph::GeomObject.

Reimplemented in oomph::ImmersedRigidBodyTriangleMeshPolygon.

     {
       Vector<double> initial_x(2);
       Geom_object_pt->position(xi, initial_x);
       this->apply_rigid_body_motion(t, initial_x, r);
     }

References apply_rigid_body_motion(), Geom_object_pt, oomph::GeomObject::position(), and UniformPSDSelfTest::r.

◆ position() [2/2]

void oomph::ImmersedRigidBodyElement::position	(	const Vector< double > &	xi,
		Vector< double > &	r
	)		const

inlinevirtual

Overload the position to apply the rotation and translation.

Implements oomph::GeomObject.

Reimplemented in oomph::ImmersedRigidBodyTriangleMeshPolygon.

     {
       Vector<double> initial_x(2);
       Geom_object_pt->position(xi, initial_x);
       this->apply_rigid_body_motion(0, initial_x, r);
     }

References apply_rigid_body_motion(), Geom_object_pt, oomph::GeomObject::position(), and UniformPSDSelfTest::r.

Referenced by dposition_dt().

◆ re()

const double& oomph::ImmersedRigidBodyElement::re ( ) const

inline

Access function for the fluid Reynolds number.

     {
       return *Re_pt;
     }

References Re_pt.

Referenced by get_residuals_rigid_body_generic().

◆ re_invfr()

const double& oomph::ImmersedRigidBodyElement::re_invfr ( )

inline

Access to the fluid inverse Froude number.

     {
       return *ReInvFr_pt;
     }

References ReInvFr_pt.

Referenced by get_residuals_rigid_body_generic().

◆ re_invfr_pt()

double*& oomph::ImmersedRigidBodyElement::re_invfr_pt ( )

inline

Access function for pointer to the fluid inverse Froude number (dimensionless gravitational loading)

     {
       return ReInvFr_pt;
     }

References ReInvFr_pt.

◆ re_pt()

double*& oomph::ImmersedRigidBodyElement::re_pt ( )

inline

Access function for the pointer to the fluid Reynolds number.

     {
       return Re_pt;
     }

References Re_pt.

Referenced by UnstructuredImmersedEllipseProblem< ELEMENT >::UnstructuredImmersedEllipseProblem().

◆ reset_after_external_fd()

void oomph::ImmersedRigidBodyElement::reset_after_external_fd ( )

inlinevirtual

After all external data finite-differencing, update nodal positions

Reimplemented from oomph::GeneralisedElement.

     {
       node_update_adjacent_fluid_elements();
     }

References node_update_adjacent_fluid_elements().

◆ reset_after_internal_fd()

void oomph::ImmersedRigidBodyElement::reset_after_internal_fd ( )

inlinevirtual

After all internal data finite-differencing, update nodal positions

Reimplemented from oomph::GeneralisedElement.

     {
       node_update_adjacent_fluid_elements();
     }

References node_update_adjacent_fluid_elements().

◆ reset_in_external_fd()

void oomph::ImmersedRigidBodyElement::reset_in_external_fd ( const unsigned & i )

inlinevirtual

Do nothing to reset within finite-differencing of external data.

Reimplemented from oomph::GeneralisedElement.

353 {}

◆ reset_in_internal_fd()

void oomph::ImmersedRigidBodyElement::reset_in_internal_fd ( const unsigned & i )

inlinevirtual

Do nothing to reset within finite-differencing of internal data.

Reimplemented from oomph::GeneralisedElement.

369 {}

◆ set_drag_mesh()

void oomph::ImmersedRigidBodyElement::set_drag_mesh ( Mesh *const & drag_mesh_pt )

Function to set the drag mesh and add the appropriate load and geometric data as external data to the Rigid Body

Set the external drag mesh, which should consist of NavierStokesSurfaceDragTorqueElements and then read out the appropriate load and geometric data from those elements and set as external data for this element.

   {
     // Delete the external hijacked data
     this->delete_external_hijacked_data();
     // Flush any existing external data
     this->flush_external_data();
     // Set the pointer
     Drag_mesh_pt = drag_mesh_pt;
  
     // Allocate storage for all geometric data in the mesh
     std::set<Data*> bulk_geometric_data_pt;
     // Allocate storage for all load data in the mesh
     std::set<std::pair<Data*, unsigned>> bulk_load_data_pt;
  
     // Loop over all elements in the drag mesh
     const unsigned n_element = drag_mesh_pt->nelement();
     for (unsigned e = 0; e < n_element; ++e)
     {
       // Cast the bulk element associated with each FaceElement to
       // an FSIFluidElement
       FSIFluidElement* bulk_elem_pt = dynamic_cast<FSIFluidElement*>(
         dynamic_cast<FaceElement*>(drag_mesh_pt->element_pt(e))
           ->bulk_element_pt());
       // Check that the cast worked
       if (bulk_elem_pt == 0)
       {
         throw OomphLibError("Drag mesh must consist of FSIFluidElements\n",
                             OOMPH_CURRENT_FUNCTION,
                             OOMPH_EXCEPTION_LOCATION);
       }
  
       // Add the geometric and load data from the bulk element to the
       // set allocated above
       bulk_elem_pt->identify_geometric_data(bulk_geometric_data_pt);
       bulk_elem_pt->identify_load_data(bulk_load_data_pt);
     }
  
     // Need to add all these data as external data to this (Rigid Body) object
     for (std::set<Data*>::iterator it = bulk_geometric_data_pt.begin();
          it != bulk_geometric_data_pt.end();
          ++it)
     {
       this->add_external_data(*it);
     }
  
     // Now do the same but make custom data for the load data
     for (std::set<std::pair<Data*, unsigned>>::iterator it =
            bulk_load_data_pt.begin();
          it != bulk_load_data_pt.end();
          ++it)
     {
       Data* temp_data_pt = new HijackedData(it->second, it->first);
       List_of_external_hijacked_data.push_back(
         this->add_external_data(temp_data_pt));
     }
   }

References oomph::GeneralisedElement::add_external_data(), delete_external_hijacked_data(), drag_mesh_pt(), Drag_mesh_pt, e(), oomph::Mesh::element_pt(), oomph::GeneralisedElement::flush_external_data(), oomph::FiniteElement::identify_geometric_data(), oomph::FSIFluidElement::identify_load_data(), List_of_external_hijacked_data, oomph::Mesh::nelement(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, and set().

Referenced by UnstructuredImmersedEllipseProblem< ELEMENT >::UnstructuredImmersedEllipseProblem().

◆ set_geometric_rotation()

void oomph::ImmersedRigidBodyElement::set_geometric_rotation ( )

inline

Set the rotation of the object to be included.

     {
       Include_geometric_rotation = true;
     }

References Include_geometric_rotation.

◆ st()

const double& oomph::ImmersedRigidBodyElement::st ( ) const

inline

Access function for the fluid Strouhal number.

     {
       return *St_pt;
     }

References St_pt.

Referenced by get_residuals_rigid_body_generic().

◆ st_pt()

double*& oomph::ImmersedRigidBodyElement::st_pt ( )

inline

Access function for the pointer to the fluid Strouhal number.

     {
       return St_pt;
     }

References St_pt.

Referenced by UnstructuredImmersedEllipseProblem< ELEMENT >::UnstructuredImmersedEllipseProblem().

◆ unpin_centre_of_mass_coordinate()

void oomph::ImmersedRigidBodyElement::unpin_centre_of_mass_coordinate ( const unsigned & i )

inline

Unpin the i-th coordinate of the centre of mass.

     {
       Centre_displacement_data_pt->unpin(i);
     }

References Centre_displacement_data_pt, i, and oomph::Data::unpin().

◆ unpin_rotation_angle()

void oomph::ImmersedRigidBodyElement::unpin_rotation_angle ( )

inline

Unpin the rotation angle.

     {
       Centre_displacement_data_pt->unpin(2);
     }

References Centre_displacement_data_pt, and oomph::Data::unpin().

◆ unset_geometric_rotation()

void oomph::ImmersedRigidBodyElement::unset_geometric_rotation ( )

inline

Set the rotation of the object to be ignored (only really useful if you have a circular shape)

     {
       Include_geometric_rotation = false;
     }

References Include_geometric_rotation.

◆ update_in_external_fd()

void oomph::ImmersedRigidBodyElement::update_in_external_fd ( const unsigned & i )

inlinevirtual

After an external data change, update the nodal positions.

Reimplemented from oomph::GeneralisedElement.

     {
       node_update_adjacent_fluid_elements();
     }

References node_update_adjacent_fluid_elements().

◆ update_in_internal_fd()

void oomph::ImmersedRigidBodyElement::update_in_internal_fd ( const unsigned & i )

inlinevirtual

After an internal data change, update the nodal positions.

Reimplemented from oomph::GeneralisedElement.

     {
       node_update_adjacent_fluid_elements();
     }

References node_update_adjacent_fluid_elements().

Member Data Documentation

◆ Centre_displacement_data_pt

Data* oomph::ImmersedRigidBodyElement::Centre_displacement_data_pt

protected

Data for centre of gravity displacement. Values: 0: x-displ; 1: y-displ; 2: rotation angle.

Referenced by apply_rigid_body_motion(), centre_displacement_data_pt(), centre_of_gravity(), centre_rotation_angle(), centre_x_displacement(), centre_y_displacement(), dposition_dt(), geom_data_pt(), get_residuals_rigid_body_generic(), initialise(), output_centre_of_gravity(), pin_centre_of_mass_coordinate(), pin_rotation_angle(), oomph::ImmersedRigidBodyTriangleMeshPolygon::reset_reference_configuration(), unpin_centre_of_mass_coordinate(), unpin_rotation_angle(), and ~ImmersedRigidBodyElement().

◆ Default_Gravity_vector

Vector< double > oomph::ImmersedRigidBodyElement::Default_Gravity_vector

staticprivate

Static default value for gravity.

Static default gravity direction vector.

◆ Default_Physical_Constant_Value

double oomph::ImmersedRigidBodyElement::Default_Physical_Constant_Value = 0.0

staticprivate

Static default value for physical constants.

Static default value for physical constants Zero gives instantaneous force and torque balances — no solid intertia

◆ Default_Physical_Ratio_Value

double oomph::ImmersedRigidBodyElement::Default_Physical_Ratio_Value = 1.0

staticprivate

Static default value for physical ratios.

Static default value for physical ratio.

◆ Density_ratio_pt

double* oomph::ImmersedRigidBodyElement::Density_ratio_pt

private

Density ratio of the solid to the external fluid.

Referenced by density_ratio(), and density_ratio_pt().

◆ Displacement_data_is_internal

bool oomph::ImmersedRigidBodyElement::Displacement_data_is_internal

private

Boolean flag to indicate whether data is internal.

Referenced by centre_displacement_local_eqn(), initialise(), and ~ImmersedRigidBodyElement().

◆ Drag_mesh_pt

Mesh* oomph::ImmersedRigidBodyElement::Drag_mesh_pt

private

Mesh containing face elements that allow the computation of the drag on the body

Referenced by drag_mesh_pt(), flush_drag_mesh(), get_force_and_torque(), node_update_adjacent_fluid_elements(), and set_drag_mesh().

◆ External_force_fct_pt

ExternalForceFctPt oomph::ImmersedRigidBodyElement::External_force_fct_pt

private

Function pointer to function that specifies external force

Referenced by external_force_fct_pt(), and get_force_and_torque().

◆ External_torque_fct_pt

ExternalTorqueFctPt oomph::ImmersedRigidBodyElement::External_torque_fct_pt

private

Function pointer to function that specifies external torque

Referenced by external_torque_fct_pt(), and get_force_and_torque().

◆ G_pt

Vector<double>* oomph::ImmersedRigidBodyElement::G_pt

private

The direction of gravity.

Referenced by g(), and g_pt().

◆ Geom_object_pt

GeomObject* oomph::ImmersedRigidBodyElement::Geom_object_pt

private

Underlying geometric object.

Referenced by dposition_dt(), and position().

◆ Include_geometric_rotation

bool oomph::ImmersedRigidBodyElement::Include_geometric_rotation

private

Boolean to indicate that the rotation variable does not affect the boundary shape

Referenced by apply_rigid_body_motion(), dposition_dt(), set_geometric_rotation(), and unset_geometric_rotation().

◆ Index_for_centre_displacement

unsigned oomph::ImmersedRigidBodyElement::Index_for_centre_displacement

private

Index for the data (internal or external) that contains the centre-of-gravity displacement

Referenced by centre_displacement_local_eqn(), and initialise().

◆ Initial_centre_of_mass

Vector<double> oomph::ImmersedRigidBodyElement::Initial_centre_of_mass

protected

X-coordinate of initial centre of gravity.

Referenced by apply_rigid_body_motion(), centre_of_gravity(), dposition_dt(), oomph::ImmersedRigidBodyTriangleMeshPolygon::ImmersedRigidBodyTriangleMeshPolygon(), initial_centre_of_mass(), initialise(), output_centre_of_gravity(), and oomph::ImmersedRigidBodyTriangleMeshPolygon::reset_reference_configuration().

◆ Initial_Phi

double oomph::ImmersedRigidBodyElement::Initial_Phi

protected

Original rotation angle.

Referenced by oomph::ImmersedRigidBodyTriangleMeshPolygon::ImmersedRigidBodyTriangleMeshPolygon(), initial_phi(), output_centre_of_gravity(), and oomph::ImmersedRigidBodyTriangleMeshPolygon::reset_reference_configuration().

◆ List_of_external_hijacked_data

std::list<unsigned> oomph::ImmersedRigidBodyElement::List_of_external_hijacked_data

private

Storage for the external data that is formed from hijacked data that must be deleted by this element

Referenced by delete_external_hijacked_data(), and set_drag_mesh().

◆ Mass

double oomph::ImmersedRigidBodyElement::Mass

protected

Referenced by get_residuals_rigid_body_generic(), oomph::ImmersedRigidBodyTriangleMeshPolygon::ImmersedRigidBodyTriangleMeshPolygon(), and mass_shape().

◆ Moment_of_inertia

double oomph::ImmersedRigidBodyElement::Moment_of_inertia

protected

Polar moment of inertia of body.

Referenced by get_residuals_rigid_body_generic(), oomph::ImmersedRigidBodyTriangleMeshPolygon::ImmersedRigidBodyTriangleMeshPolygon(), and moment_of_inertia_shape().

◆ Re_pt

double* oomph::ImmersedRigidBodyElement::Re_pt

private

Reynolds number of external fluid.

Referenced by re(), and re_pt().

◆ ReInvFr_pt

double* oomph::ImmersedRigidBodyElement::ReInvFr_pt

private

Reynolds number divided by Froude number of external fluid.

Referenced by re_invfr(), and re_invfr_pt().

◆ St_pt

double* oomph::ImmersedRigidBodyElement::St_pt

private

Strouhal number of external fluid.

Referenced by st(), and st_pt().

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

Public Types

Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Static Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ ExternalForceFctPt

◆ ExternalTorqueFctPt

Constructor & Destructor Documentation

◆ ImmersedRigidBodyElement() [1/2]

◆ ImmersedRigidBodyElement() [2/2]

◆ ~ImmersedRigidBodyElement()

Member Function Documentation

◆ apply_rigid_body_motion()

◆ centre_displacement_data_pt()

◆ centre_displacement_local_eqn()

◆ centre_of_gravity()

◆ centre_rotation_angle()

◆ centre_x_displacement()

◆ centre_y_displacement()

◆ delete_external_hijacked_data()

◆ density_ratio()

◆ density_ratio_pt()

◆ dposition_dt()

◆ drag_mesh_pt()

◆ external_force_fct_pt()

◆ external_torque_fct_pt()

◆ fill_in_contribution_to_jacobian()

◆ fill_in_contribution_to_residuals()

◆ flush_drag_mesh()

◆ g()

◆ g_pt()

◆ geom_data_pt()

◆ get_force_and_torque()

◆ get_residuals_rigid_body_generic()

◆ initial_centre_of_mass() [1/2]

◆ initial_centre_of_mass() [2/2]

◆ initial_phi()

◆ initialise()

◆ mass_shape()

◆ moment_of_inertia_shape()

◆ ngeom_data()

◆ node_update_adjacent_fluid_elements()

◆ output_centre_of_gravity()

◆ pin_centre_of_mass_coordinate()

◆ pin_rotation_angle()

◆ position() [1/2]

◆ position() [2/2]

◆ re()

◆ re_invfr()

◆ re_invfr_pt()

◆ re_pt()

◆ reset_after_external_fd()

◆ reset_after_internal_fd()

◆ reset_in_external_fd()

◆ reset_in_internal_fd()

◆ set_drag_mesh()

◆ set_geometric_rotation()

◆ st()

◆ st_pt()

◆ unpin_centre_of_mass_coordinate()

◆ unpin_rotation_angle()

◆ unset_geometric_rotation()

◆ update_in_external_fd()

◆ update_in_internal_fd()

Member Data Documentation

◆ Centre_displacement_data_pt

◆ Default_Gravity_vector

◆ Default_Physical_Constant_Value

◆ Default_Physical_Ratio_Value

◆ Density_ratio_pt

◆ Displacement_data_is_internal

◆ Drag_mesh_pt

◆ External_force_fct_pt

◆ External_torque_fct_pt

◆ G_pt