Inheritance diagram for HeatedCircularPenetratorElement:

Public Member Functions
	HeatedCircularPenetratorElement (SolidNode control_node_pt, const unsigned &index_of_contact_pressure, const unsigned &index_of_horizontal_displacement, const unsigned &index_of_vertical_displacement, double r_pt)

void	surface_coordinate (const Vector< double > &x, Vector< double > &zeta) const

Vector< double >	rigid_body_displacement () const
	Get rigid body displacement of reference point in penetrator. More...

void	set_original_centre (const Vector< double > &orig_centre)

Vector< std::pair< Data *, unsigned > >	equilibrium_data ()

double	angle () const
	Angle of rotation around contact point. More...

void	set_angle (const double &angle)
	Set angle of rotation around contact point. More...

Mesh *	contact_element_mesh_pt () const

void	set_contact_element_mesh_pt (Mesh *contact_element_mesh_pt)

void	set_equilibrium_target_forces ()
	Set target horizontal and vertical force to be in equilibrium. More...

double	target_weight ()
	Target weight (returns zero if not imposed) More...

double	target_horizontal_force ()
	Target horizontal force (returns zero if not imposed) More...

double	target_yc ()
	Target vertical position of control point (returns zero if not imposed) More...

double	target_rotation_angle ()
	Target rotation angle about contact point (returns zero if not imposed) More...

bool	yc_is_imposed ()
	Is vertical positon of control node imposed? If false then weight imposed. More...

void	impose_weight (double *target_weight_pt)

void	impose_yc (double *target_yc_pt)

bool	rotation_angle_is_imposed ()

void	impose_horizontal_force (double *target_horizontal_force_pt)

void	impose_rotation_angle (double *target_rotation_angle_pt)

void	fill_in_contribution_to_residuals (Vector< double > &residuals)
	Fill in contribution to residuals. More...

Vector< double >	centre () const
	Get centre of penetrator. More...

double	centre (const unsigned &i) const
	Get centre of penetrator. More...

void	penetration (const Vector< double > &x, const Vector< double > &n, double &d, bool &intersection) const
	Get penetration for given point x. More...

double	temperature (const Vector< double > &x) const

void	output (std::ostream &outfile, const unsigned &nplot) const
	Output coordinates of penetrator at nplot plot points. More...

void	position_from_zeta (const Vector< double > &zeta, Vector< double > &r) const
	Get position to surface, r, in terms of surface coordinate zeta. More...

Vector< double >	resulting_force () const
	Resulting force from all associated ContactElements. More...

double	radius () const
	Radius of penetrator. 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::HeatedPenetrator
	HeatedPenetrator ()
	Constructor. More...

virtual	~HeatedPenetrator ()
	Destructor. More...

Public Member Functions inherited from oomph::Penetrator
	Penetrator ()
	Constructor. More...

virtual	~Penetrator ()
	Destructor. More...

Private Attributes
double *	Radius_pt
	Pointer to radius of penetrator. More...

Vector< double >	Orig_centre

SolidNode *	Control_node_pt
	Control node. More...

unsigned	Index_of_contact_pressure

unsigned	Index_of_vertical_displacement
	Where is the vertical displacement (linear_elasticity) stored? More...

unsigned	Index_of_horizontal_displacement
	Where is the horizontal displacement (linear_elasticity) stored? More...

unsigned	External_data_index_of_traded_contact_pressure

double *	Target_weight_pt

double *	Target_horizontal_force_pt

double *	Target_yc_pt

double *	Target_rotation_angle_pt

Mesh *	Contact_element_mesh_pt
	Mesh of contact elements that contribute to weight/horizontal force. 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

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	reset_after_internal_fd ()

virtual void	update_in_internal_fd (const unsigned &i)

virtual void	reset_in_internal_fd (const unsigned &i)

virtual void	update_before_external_fd ()

virtual void	reset_after_external_fd ()

virtual void	update_in_external_fd (const unsigned &i)

virtual void	reset_in_external_fd (const unsigned &i)

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

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)

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

static std::deque< double * >	Dof_pt_deque

Detailed Description

//////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////
Penetrator that keeps circle in contact with a control node on target surface (made of solid contact face elements) – centre of the circular penetrator is located at

{\bf r}_c = {\bf R}_p + R {\bf e}_alpha

where {\bf R}_p is the position of the control point, R the radius of the circular penetrator, and {\bf e}_alpha is a unit vector inclined at an angle \alpha against the vertical. Penetration can be driven in two ways. (1) We impose the vertical position of the control point (by pseudo-hijacking the Lagrange-multiplier (representing the contact pressure) stored at the controlled node. This means that rather than determining the contact pressure from the no-penetration constraint, (which we know to be satisfied by construction) we determine it from the condition that {\bf R}_p \cdot {\bf e}_y = Y_c which is prescribed. We also impose the angle \alpha (stored as an internal Data value in the element) by solving it via the equation \alpha-\alpha_{prescribed} = 0. (2) We impose the weight (i.e. the vertical reaction force from the contact elements) by using the equation

\int p_c {\bf n} \cdot {\bf e}_y ds - W = 0

as the equation for the pseudo-hijacked contact pressure and similarly, use the horizontal force balance

\int p_c {\bf n} \cdot {\bf e}_x ds - H = 0

to determine the rotation angle. Here, W and H are prescribed and the integral is computed from the contact elements that potentially impact on the penetrator.

Constructor & Destructor Documentation

◆ HeatedCircularPenetratorElement()

HeatedCircularPenetratorElement::HeatedCircularPenetratorElement	(	SolidNode *	control_node_pt,
		const unsigned &	index_of_contact_pressure,
		const unsigned &	index_of_horizontal_displacement,
		const unsigned &	index_of_vertical_displacement,
		double *	r_pt
	)

inline

Constructor: Pass pointer to control node whose index_of_contact_pressure-th value represents the Lagrange multiplier (the discrete contact pressure) that has been traded for the vertical displacement/weight constraint. Also need the indices of the nodal values that store the horizontal/vertical displacement (linear elasticity).

    {
     // Create internal data, representing the angle of rotation about
     // contact point. Determined either directly via insisting
     // that the difference between this value and the target is zero
     // or by insisting that the horizontal force is zero.
     add_internal_data(new Data(1));
     internal_data_pt(0)->set_value(0,0.0);
  
     oomph_info << "In here..\n";
     exit(0);
  
     // Store pointer to radius
     Radius_pt=r_pt;
     
     // Store original centre
     Orig_centre=centre();
  
     // Control node 
     Control_node_pt=control_node_pt;
  
     // Where is the tradedd contact pressure stored?
     Index_of_contact_pressure=index_of_contact_pressure;
  
     // Where is the horizontal displacement (linear_elasticity) stored?
     Index_of_horizontal_displacement=index_of_horizontal_displacement;
  
     // Where is the vertical displacement (linear_elasticity) stored?
     Index_of_vertical_displacement=index_of_vertical_displacement;
  
     //Pointer to target weight (null if vertical displacement of control
     //node is imposed)
     Target_weight_pt=0;
  
     // Pointer to target horizontal force (null if rotation angle angle 
     // about control node is imposed)
     Target_horizontal_force_pt=0;
  
     // Pointer to  target vertical displacement of control node (null if 
     // weight is imposed)
     Target_yc_pt=0;
  
     // Pointer to target rotation angle about control node (null 
     // if horizontal force is imposed)
     Target_rotation_angle_pt=0;
  
     // Pointer to mesh of contact elements that contribute to force
     Contact_element_mesh_pt=0;
    }

References oomph::GeneralisedElement::add_internal_data(), centre(), Contact_element_mesh_pt, Control_node_pt, Index_of_contact_pressure, Index_of_horizontal_displacement, Index_of_vertical_displacement, oomph::GeneralisedElement::internal_data_pt(), oomph::oomph_info, Orig_centre, Radius_pt, oomph::Data::set_value(), Target_horizontal_force_pt, Target_rotation_angle_pt, Target_weight_pt, and Target_yc_pt.

Member Function Documentation

◆ angle()

double HeatedCircularPenetratorElement::angle ( ) const

inline

Angle of rotation around contact point.

    {
     return internal_data_pt(0)->value(0);
    }

References oomph::GeneralisedElement::internal_data_pt(), and oomph::Data::value().

Referenced by centre(), ContactProblem< ELEMENT >::complete_problem_setup(), and set_angle().

◆ centre() [1/2]

Vector<double> HeatedCircularPenetratorElement::centre ( ) const

inline

Get centre of penetrator.

    {
     Vector<double> rc(2);
     rc[0]=centre(0); 
     rc[1]=centre(1); 
     return rc;
    }

References plotDoE::rc.

Referenced by ContactProblem< ELEMENT >::doc_solution(), HeatedCircularPenetratorElement(), output(), penetration(), position_from_zeta(), rigid_body_displacement(), surface_coordinate(), and temperature().

◆ centre() [2/2]

double HeatedCircularPenetratorElement::centre ( const unsigned & i ) const

inline

Get centre of penetrator.

    {
     switch (i)
      {
      case 0:
       return Control_node_pt->x(0)+
        Control_node_pt->value(Index_of_horizontal_displacement)+
        (*Radius_pt)*sin(angle());
       break;
       
      case 1:
       return Control_node_pt->x(1)+
        Control_node_pt->value(Index_of_vertical_displacement)+
        (*Radius_pt)*cos(angle());
       break;
       
      default:
       std::stringstream junk;
       junk << "Wrong index: " << i 
            << "\nCan only handle 0 or 1 (it's 2D!)\n";
       throw OomphLibError(
        junk.str(),
        OOMPH_CURRENT_FUNCTION,
        OOMPH_EXCEPTION_LOCATION);
      }
    }

References angle(), Control_node_pt, cos(), i, Index_of_horizontal_displacement, Index_of_vertical_displacement, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, sin(), oomph::Node::value(), and oomph::Node::x().

◆ contact_element_mesh_pt()

Mesh* HeatedCircularPenetratorElement::contact_element_mesh_pt ( ) const

inline

Access to pointer to mesh of contact elements that contribute to force on penetrator

    {
     return Contact_element_mesh_pt;
    }

References Contact_element_mesh_pt.

Referenced by set_contact_element_mesh_pt().

◆ equilibrium_data()

Vector<std::pair<Data*,unsigned> > HeatedCircularPenetratorElement::equilibrium_data ( )

inlinevirtual

Vector of pairs identifying values (via a pair of pointer to Data object and index within it) that correspond to the Data values that are determined by the horizontal/vertical/... equilibrium equations.

Reimplemented from oomph::Penetrator.

    {
     // We're in 2D
     Vector<std::pair<Data*,unsigned> > thingy(2);
  
     
     // Horizontal equilibrium determines the rotation angle
     // which is stored as the zero-th internal data
     if (Target_horizontal_force_pt==0)
      {
       thingy[0]=std::make_pair(static_cast<Data*>(0),0);
      }
     else
      {
       thingy[0]=std::make_pair(internal_data_pt(0),0);
      }
  
  
     // Vertical equilibrium determines the discrete contact pressure
     // (Lagrange multiplier) at control node
     if (Target_weight_pt==0)
      {
       thingy[1]=std::make_pair(static_cast<Data*>(0),0);
      }
     else
      {
       thingy[1]=std::make_pair(
        external_data_pt(External_data_index_of_traded_contact_pressure),
        Index_of_contact_pressure);
      }
  
     return thingy;
    }

References External_data_index_of_traded_contact_pressure, oomph::GeneralisedElement::external_data_pt(), Index_of_contact_pressure, oomph::GeneralisedElement::internal_data_pt(), Target_horizontal_force_pt, and Target_weight_pt.

◆ fill_in_contribution_to_residuals()

void HeatedCircularPenetratorElement::fill_in_contribution_to_residuals ( Vector< double > & residuals )

inlinevirtual

Fill in contribution to residuals.

Reimplemented from oomph::GeneralisedElement.

   {
    // Get resulting force from all associated PseudoContactElements
    // onto the elastic body
    Vector<double> force(resulting_force());
  
    // Equation for Lagrange multiplier (contact pressure) at controlled
    // node
    int local_eqn=external_local_eqn(
     External_data_index_of_traded_contact_pressure,Index_of_contact_pressure); 
    if (local_eqn>=0)
     {
      // Resulting force from all associated PseudoContactElements
      // onto the elastic body is equal and opposite to force on penetrator
      if (Target_weight_pt!=0)
       {
        residuals[local_eqn]+=(*Target_weight_pt);
       }
      // Impose vertical position of control node
      else
       {
 #ifdef PARANOID
        if (Target_yc_pt!=0)
         {
 #endif
          residuals[local_eqn]+=Control_node_pt->x(1)+
           Control_node_pt->value(Index_of_vertical_displacement)-(*Target_yc_pt);
 #ifdef PARANOID
         }
        else
         {
          std::stringstream junk;
          junk << "Target_yc_pt=0\n"
               << "Set with impose_yc(...)\n";
          throw OomphLibError(
           junk.str(),
           OOMPH_CURRENT_FUNCTION,
           OOMPH_EXCEPTION_LOCATION);
         }
 #endif
       }
     }
  
  
  
    // Equation for rotation angle
    local_eqn=internal_local_eqn(0,0); 
    if (local_eqn>=0)
     {
      // Resulting force from all associated PseudoContactElements
      // onto the elastic body is equal and opposite to force on penetrator
      if (Target_horizontal_force_pt!=0)
       {
        residuals[local_eqn]+=(*Target_horizontal_force_pt);
       }
      // Set rotation angle 
      else
       {
 #ifdef PARANOID
        if (Target_rotation_angle_pt!=0)
         {
 #endif
          residuals[local_eqn]+=internal_data_pt(0)->value(0)-
           (*Target_rotation_angle_pt);
 #ifdef PARANOID
         }
        else
         {
          std::stringstream junk;
          junk << "Target_rotation_angle_pt=0\n"
               << "Set with impose_rotation_angle(...)\n";
          throw OomphLibError(
           junk.str(),
           OOMPH_CURRENT_FUNCTION,
           OOMPH_EXCEPTION_LOCATION);
         }
 #endif
       }
     }
   }

References Control_node_pt, External_data_index_of_traded_contact_pressure, oomph::GeneralisedElement::external_local_eqn(), Index_of_contact_pressure, Index_of_vertical_displacement, oomph::GeneralisedElement::internal_data_pt(), oomph::GeneralisedElement::internal_local_eqn(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, resulting_force(), Target_horizontal_force_pt, Target_rotation_angle_pt, Target_weight_pt, Target_yc_pt, oomph::Data::value(), oomph::Node::value(), and oomph::Node::x().

◆ impose_horizontal_force()

void HeatedCircularPenetratorElement::impose_horizontal_force ( double * target_horizontal_force_pt )

inline

Impose horizontal force (rather than rotation about contact node). Target force specified via pointer.

    {
     Target_horizontal_force_pt=target_horizontal_force_pt;
     Target_rotation_angle_pt=0;
    }

References Target_horizontal_force_pt, and Target_rotation_angle_pt.

◆ impose_rotation_angle()

void HeatedCircularPenetratorElement::impose_rotation_angle ( double * target_rotation_angle_pt )

inline

Impose rotation about contact node (rather than horizontal force) Target angle specified via pointer.

    {
     Target_horizontal_force_pt=0;
     Target_rotation_angle_pt=target_rotation_angle_pt;
    }

References Target_horizontal_force_pt, and Target_rotation_angle_pt.

◆ impose_weight()

void HeatedCircularPenetratorElement::impose_weight ( double * target_weight_pt )

inline

Impose weight (rather than imposed displacement). Target weight specified via pointer.

    {
     Target_weight_pt=target_weight_pt;
     Target_yc_pt=0;
    }

References Target_weight_pt, and Target_yc_pt.

◆ impose_yc()

void HeatedCircularPenetratorElement::impose_yc ( double * target_yc_pt )

inline

Impose vertical position of control node (rather than weight). Target vertical position of control node specified via pointer.

    {
     Target_weight_pt=0;
     Target_yc_pt=target_yc_pt;
    }

References Target_weight_pt, and Target_yc_pt.

◆ output()

void HeatedCircularPenetratorElement::output	(	std::ostream &	outfile,
		const unsigned &	nplot
	)		const

inlinevirtual

Output coordinates of penetrator at nplot plot points.

Implements oomph::Penetrator.

    {
     for (unsigned j=0;j<nplot;j++)
      {
       double phi=2.0*MathematicalConstants::Pi*double(j)/double(nplot-1);
       outfile << centre(0)+(*Radius_pt)*cos(phi) << " " 
               << centre(1)+(*Radius_pt)*sin(phi)
               << std::endl;
      }
    }

References centre(), cos(), j, BiharmonicTestFunctions2::Pi, and sin().

◆ penetration()

void HeatedCircularPenetratorElement::penetration	(	const Vector< double > &	x,
		const Vector< double > &	n,
		double &	d,
		bool &	intersection
	)		const

inlinevirtual

Get penetration for given point x.

Implements oomph::Penetrator.

   {
    // Vector from potential contact point to centre of penetrator
    Vector<double> l(2);
    l[0]=centre(0)-x[0];
    l[1]=centre(1)-x[1];
    
    // Distance from potential contact point to centre of penetrator
    double ll=sqrt(l[0]*l[0]+l[1]*l[1]);
  
    // Projection of vector from potential contact point to centre of penetrator
    // onto outer unit normal on potential contact point
    double project=n[0]*l[0]+n[1]*l[1];
    double project_squared=project*project;
  
    // Final term in square root
    double b_squared=ll*ll-(*Radius_pt)*(*Radius_pt);
  
    // Is square root negative? In this case we have no intersection
    // and we return penetration as -DBL_MAX
    if (project_squared<b_squared)
     {
      d= -DBL_MAX;
      intersection = false;
     }
    else
     {
      double sqr=sqrt(project_squared-b_squared);
      d= -std::min(project-sqr,project+sqr);
      intersection = true;
     }
   }

References centre(), min, n, sqrt(), and plotDoE::x.

◆ position_from_zeta()

void HeatedCircularPenetratorElement::position_from_zeta	(	const Vector< double > &	zeta,
		Vector< double > &	r
	)		const

inline

Get position to surface, r, in terms of surface coordinate zeta.

   {
    double phi=zeta[0];
    r[0]=centre(0)+(*Radius_pt)*cos(phi);
    r[1]=centre(1)+(*Radius_pt)*sin(phi);
   }

References centre(), cos(), UniformPSDSelfTest::r, sin(), and Eigen::zeta().

◆ radius()

double HeatedCircularPenetratorElement::radius ( ) const

inline

Radius of penetrator.

2715 {return *Radius_pt;}

References Radius_pt.

◆ resulting_force()

Vector<double> HeatedCircularPenetratorElement::resulting_force ( ) const

inline

Resulting force from all associated ContactElements.

   {
    Vector<double> contact_force(2,0.0);
    Vector<double> el_contact_force(2);
    unsigned nel=Contact_element_mesh_pt->nelement();
    for (unsigned e=0;e<nel;e++)
     {
      dynamic_cast<TemplateFreeContactElementBase*>(
       Contact_element_mesh_pt->element_pt(e))->
       resulting_contact_force(el_contact_force);
      for (unsigned i=0;i<2;i++)
       {
        contact_force[i]+=el_contact_force[i];
       }
     }
    return contact_force;
   }

References Contact_element_mesh_pt, e(), oomph::Mesh::element_pt(), i, and oomph::Mesh::nelement().

Referenced by fill_in_contribution_to_residuals(), and set_equilibrium_target_forces().

◆ rigid_body_displacement()

Vector<double> HeatedCircularPenetratorElement::rigid_body_displacement ( ) const

inlinevirtual

Get rigid body displacement of reference point in penetrator.

Reimplemented from oomph::Penetrator.

    {    
     unsigned n=Orig_centre.size();
     Vector<double> displ(n);
     for (unsigned i=0;i<n;i++)
      {
       displ[i]=centre(i)-Orig_centre[i];
      }
     return displ;
    }

References centre(), i, n, and Orig_centre.

◆ rotation_angle_is_imposed()

bool HeatedCircularPenetratorElement::rotation_angle_is_imposed ( )

inline

Is angle of rotation about control node imposed? If false then horizontal force is imposed.

    {
     return (Target_rotation_angle_pt!=0);
    }

References Target_rotation_angle_pt.

Referenced by ContactProblem< ELEMENT >::complete_problem_setup().

◆ set_angle()

void HeatedCircularPenetratorElement::set_angle ( const double & angle )

inline

Set angle of rotation around contact point.

    {
     internal_data_pt(0)->set_value(0,angle);
    }

References angle(), oomph::GeneralisedElement::internal_data_pt(), and oomph::Data::set_value().

◆ set_contact_element_mesh_pt()

void HeatedCircularPenetratorElement::set_contact_element_mesh_pt ( Mesh * contact_element_mesh_pt )

inline

Set pointer to mesh of contact elements and setup external Data, i.e. Data that affects the residuals in this element. Also set the node pointed to by Control_node_pt as external Data for the elements in the contact mesh (unless they contain this node already).

   {
    Contact_element_mesh_pt=contact_element_mesh_pt;
    flush_external_data();
    
    // Store Data associated with control node: It contains the traded
    // Lagrange multiplier (contact pressure) 
    External_data_index_of_traded_contact_pressure=
     add_external_data(Control_node_pt);
    
    // Store its position data
    add_external_data(Control_node_pt->variable_position_pt());
  
    // Store it as Data (which includes the displacement)
    add_external_data(Control_node_pt);
  
    // Loop over all the elements in the contact mesh
    // If they don't contain the contact node already, its position
    // is external data because it affects the penetration.
    unsigned nel=Contact_element_mesh_pt->nelement();
    for (unsigned e=0;e<nel;e++)
     {
      bool el_contains_control_node=false;
      FiniteElement* el_pt=Contact_element_mesh_pt->finite_element_pt(e);
      unsigned nnod=el_pt->nnode();
      for (unsigned j=0;j<nnod;j++)
       {
        SolidNode* nod_pt=dynamic_cast<SolidNode*>(el_pt->node_pt(j));
        if (nod_pt==Control_node_pt)
         {
          el_contains_control_node=true;
         }
       }
      
      // Position of control node affects position of penetrator and
      // therefore is external data for all contact elements (apart from
      // any that contain the control node as one of their own)
      if (!el_contains_control_node)
       {
        // position
        el_pt->add_external_data(Control_node_pt->variable_position_pt());
        // displacement relative to position
        el_pt->add_external_data(Control_node_pt);
       }
      
      // Rotation angle angle affects position of penetrator and therefore
      // affects penetration at all contact elements
      el_pt->add_external_data(internal_data_pt(0));
     }
   }

References oomph::GeneralisedElement::add_external_data(), contact_element_mesh_pt(), Contact_element_mesh_pt, Control_node_pt, e(), External_data_index_of_traded_contact_pressure, oomph::Mesh::finite_element_pt(), oomph::GeneralisedElement::flush_external_data(), oomph::GeneralisedElement::internal_data_pt(), j, oomph::Mesh::nelement(), oomph::FiniteElement::nnode(), oomph::FiniteElement::node_pt(), and oomph::SolidNode::variable_position_pt().

Referenced by ContactProblem< ELEMENT >::complete_problem_setup().

◆ set_equilibrium_target_forces()

void HeatedCircularPenetratorElement::set_equilibrium_target_forces ( )

inline

Set target horizontal and vertical force to be in equilibrium.

    {
 #ifdef PARANOID
     if (Target_horizontal_force_pt==0)
      {
       std::stringstream junk;
       junk << "Target_horizontal_force_pt==0\n"
            << "Please set it by call to impose_weight(...)\n";
       throw OomphLibError(
        junk.str(),
        OOMPH_CURRENT_FUNCTION,
        OOMPH_EXCEPTION_LOCATION);
      } 
     if (Target_weight_pt==0)
      {
       std::stringstream junk;
       junk << "Target_weight_pt==0.\n"
            << "Please set it by call to impose_horizontal_force(...)\n";
       throw OomphLibError(
        junk.str(),
        OOMPH_CURRENT_FUNCTION,
        OOMPH_EXCEPTION_LOCATION);
      }
 #endif
     Vector<double> force(resulting_force());
     (*Target_horizontal_force_pt)=-force[0];
     (*Target_weight_pt)=-force[1];
    }

References OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, resulting_force(), Target_horizontal_force_pt, and Target_weight_pt.

◆ set_original_centre()

void HeatedCircularPenetratorElement::set_original_centre ( const Vector< double > & orig_centre )

inline

Set original centre of penetrator (for computation of rigid body displacement

    {
     Orig_centre=orig_centre;
    }

References Orig_centre.

◆ surface_coordinate()

void HeatedCircularPenetratorElement::surface_coordinate	(	const Vector< double > &	x,
		Vector< double > &	zeta
	)		const

inlinevirtual

Get surface coordinate along penetrator for given point x. We assume that point on the surface and given point share the same polar angle and return that polar angle

Reimplemented from oomph::Penetrator.

    {
     zeta[0]=atan2(x[1]-centre(1),x[0]-centre(0));
    }

References atan2(), centre(), plotDoE::x, and Eigen::zeta().

◆ target_horizontal_force()

double HeatedCircularPenetratorElement::target_horizontal_force ( )

inline

Target horizontal force (returns zero if not imposed)

    {
     if (Target_horizontal_force_pt==0)
      {
       return 0.0;
      }
     else
      {
       return *Target_horizontal_force_pt;
      }
    }

References Target_horizontal_force_pt.

◆ target_rotation_angle()

double HeatedCircularPenetratorElement::target_rotation_angle ( )

inline

Target rotation angle about contact point (returns zero if not imposed)

    {
     if (Target_rotation_angle_pt==0)
      {
       return 0.0;
      }
     else
      {
       return *Target_rotation_angle_pt;
      }
    }

References Target_rotation_angle_pt.

◆ target_weight()

double HeatedCircularPenetratorElement::target_weight ( )

inline

Target weight (returns zero if not imposed)

    {
     if (Target_weight_pt==0)
      {
       return 0.0;
      }
     else
      {
       return *Target_weight_pt;
      }
    }

References Target_weight_pt.

Referenced by ContactProblem< ELEMENT >::doc_solution().

◆ target_yc()

double HeatedCircularPenetratorElement::target_yc ( )

inline

Target vertical position of control point (returns zero if not imposed)

    {
     if (Target_yc_pt==0)
      {
       return 0.0;
      }
     else
      {
       return *Target_yc_pt;
      }
    }

References Target_yc_pt.

◆ temperature()

double HeatedCircularPenetratorElement::temperature ( const Vector< double > & x ) const

inlinevirtual

Get temperature on penetrator at point "associated" with point x using the same logic as for the position function). Here we assume that both points shrare the same polar angle relative to the centre of (circular!) penetrator

Implements oomph::HeatedPenetrator.

    {
     double phi=atan2(x[1]-centre(1),x[0]-centre(0));
     return cos(phi-0.5*MathematicalConstants::Pi);
    }

References atan2(), centre(), cos(), BiharmonicTestFunctions2::Pi, and plotDoE::x.

◆ yc_is_imposed()

bool HeatedCircularPenetratorElement::yc_is_imposed ( )

inline

Is vertical positon of control node imposed? If false then weight imposed.

    {
     return (Target_yc_pt!=0);
    }

References Target_yc_pt.

Referenced by ContactProblem< ELEMENT >::complete_problem_setup().

Member Data Documentation

◆ Contact_element_mesh_pt

Mesh* HeatedCircularPenetratorElement::Contact_element_mesh_pt

private

Mesh of contact elements that contribute to weight/horizontal force.

Referenced by contact_element_mesh_pt(), HeatedCircularPenetratorElement(), resulting_force(), and set_contact_element_mesh_pt().

◆ Control_node_pt

SolidNode* HeatedCircularPenetratorElement::Control_node_pt

private

Control node.

Referenced by centre(), fill_in_contribution_to_residuals(), HeatedCircularPenetratorElement(), and set_contact_element_mesh_pt().

◆ External_data_index_of_traded_contact_pressure

unsigned HeatedCircularPenetratorElement::External_data_index_of_traded_contact_pressure

private

Index of external data that contains the the contact pressure in its Index_of_contact_pressure-th value

Referenced by equilibrium_data(), fill_in_contribution_to_residuals(), and set_contact_element_mesh_pt().

◆ Index_of_contact_pressure

unsigned HeatedCircularPenetratorElement::Index_of_contact_pressure

private

Index at which contact pressure (Lagr mult) is stored in nodal data associated with control node

Referenced by equilibrium_data(), fill_in_contribution_to_residuals(), and HeatedCircularPenetratorElement().

◆ Index_of_horizontal_displacement

unsigned HeatedCircularPenetratorElement::Index_of_horizontal_displacement

private

Where is the horizontal displacement (linear_elasticity) stored?

Referenced by centre(), and HeatedCircularPenetratorElement().

◆ Index_of_vertical_displacement

unsigned HeatedCircularPenetratorElement::Index_of_vertical_displacement

private

Where is the vertical displacement (linear_elasticity) stored?

Referenced by centre(), fill_in_contribution_to_residuals(), and HeatedCircularPenetratorElement().

◆ Orig_centre

Vector<double> HeatedCircularPenetratorElement::Orig_centre

private

Original centre of penetrator (origin for cylindrical polar coordinate system)

Referenced by HeatedCircularPenetratorElement(), rigid_body_displacement(), and set_original_centre().

◆ Radius_pt

double* HeatedCircularPenetratorElement::Radius_pt

private

Pointer to radius of penetrator.

Referenced by HeatedCircularPenetratorElement(), and radius().

◆ Target_horizontal_force_pt

double* HeatedCircularPenetratorElement::Target_horizontal_force_pt

private

Pointer to target horizontal force (null if rotation angle angle about control node is imposed)

Referenced by equilibrium_data(), fill_in_contribution_to_residuals(), HeatedCircularPenetratorElement(), impose_horizontal_force(), impose_rotation_angle(), set_equilibrium_target_forces(), and target_horizontal_force().

◆ Target_rotation_angle_pt

double* HeatedCircularPenetratorElement::Target_rotation_angle_pt

private

Pointer to target rotation angle about control node (null if horizontal force is imposed)

Referenced by fill_in_contribution_to_residuals(), HeatedCircularPenetratorElement(), impose_horizontal_force(), impose_rotation_angle(), rotation_angle_is_imposed(), and target_rotation_angle().

◆ Target_weight_pt

double* HeatedCircularPenetratorElement::Target_weight_pt

private

Pointer to target weight (null if vertical displacement of control node is imposed)

Referenced by equilibrium_data(), fill_in_contribution_to_residuals(), HeatedCircularPenetratorElement(), impose_weight(), impose_yc(), set_equilibrium_target_forces(), and target_weight().

◆ Target_yc_pt

double* HeatedCircularPenetratorElement::Target_yc_pt

private

Pointer to target vertical displacement of control node (null if weight is imposed)

Referenced by fill_in_contribution_to_residuals(), HeatedCircularPenetratorElement(), impose_weight(), impose_yc(), target_yc(), and yc_is_imposed().

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

heated_linear_solid_contact_with_gravity.cc

Public Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ HeatedCircularPenetratorElement()

Member Function Documentation

◆ angle()

◆ centre() [1/2]

◆ centre() [2/2]

◆ contact_element_mesh_pt()

◆ equilibrium_data()

◆ fill_in_contribution_to_residuals()

◆ impose_horizontal_force()

◆ impose_rotation_angle()

◆ impose_weight()

◆ impose_yc()

◆ output()

◆ penetration()

◆ position_from_zeta()

◆ radius()

◆ resulting_force()

◆ rigid_body_displacement()

◆ rotation_angle_is_imposed()

◆ set_angle()

◆ set_contact_element_mesh_pt()

◆ set_equilibrium_target_forces()

◆ set_original_centre()

◆ surface_coordinate()

◆ target_horizontal_force()

◆ target_rotation_angle()

◆ target_weight()

◆ target_yc()

◆ temperature()

◆ yc_is_imposed()

Member Data Documentation

◆ Contact_element_mesh_pt

◆ Control_node_pt

◆ External_data_index_of_traded_contact_pressure

◆ Index_of_contact_pressure

◆ Index_of_horizontal_displacement

◆ Index_of_vertical_displacement

◆ Orig_centre

◆ Radius_pt

◆ Target_horizontal_force_pt

◆ Target_rotation_angle_pt

◆ Target_weight_pt

◆ Target_yc_pt