Inheritance diagram for AxisymOscillatingDisk:

Public Member Functions
	AxisymOscillatingDisk (const double &ampl, const double &nu, TimeStepper *time_stepper_pt)

	~AxisymOscillatingDisk ()
	Destructor (empty) More...

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

void	veloc (const Vector< double > &xi, Vector< double > &veloc)
	Parametrised velocity on object at current time: veloc = d r(xi)/dt. More...

void	accel (const Vector< double > &xi, Vector< double > &accel)

void	dposition_dt (const Vector< double > &xi, const unsigned &j, Vector< double > &drdt)

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 unsigned	ngeom_data () const

virtual Data *	geom_data_pt (const unsigned &j)

virtual void	position (const unsigned &t, const Vector< double > &zeta, Vector< double > &r) 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

Static Public Member Functions
static void	residual_for_dispersion (const Vector< double > &param, const Vector< double > &omega, Vector< double > &residual)

Private Attributes
double	Ampl
	Amplitude of oscillation. More...

double	T
	Period of oscillation. More...

double	Nu
	Poisson ratio nu. More...

double	Omega
	Eigenfrequency. More...

Additional Inherited Members
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

Detailed Description

//////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// Axisymmetrially oscillating disk with displacement field according to linear elasticity.

Constructor & Destructor Documentation

◆ AxisymOscillatingDisk()

AxisymOscillatingDisk::AxisymOscillatingDisk	(	const double &	ampl,
		const double &	nu,
		TimeStepper *	time_stepper_pt
	)

Constructor: 2 Lagrangian coordinate, 2 Eulerian coords. Pass amplitude of oscillation, Poisson ratio nu, and pointer to global timestepper.

Constructor: 2 Lagrangian coordinates, 2 Eulerian coords. Pass amplitude of oscillation, Poisson ratio nu, and pointer to global timestepper.

                                                                            : 
  GeomObject(2,2,time_stepper_pt), Ampl(ampl), Nu(nu)
 {
  // Parameters for dispersion relation
  Vector<double> param(1);
  param[0]=Nu;
  
  // Initial guess for eigenfrequency
  Vector<double> omega(1);
  omega[0]=2.0; 
  
  // Find eigenfrequency from black box Newton solver
  BlackBoxFDNewtonSolver::black_box_fd_newton_solve(residual_for_dispersion,
                                                    param,omega);
  
  // Assign eigenfrequency
  Omega=omega[0];
  
  // Assign/doc period of oscillation
  T=2.0*MathematicalConstants::Pi/Omega;
  
  std::cout << "Period of oscillation: " << T << std::endl;
  
 }

References oomph::BlackBoxFDNewtonSolver::black_box_fd_newton_solve(), Nu, Eigen::internal::omega(), Omega, BiharmonicTestFunctions2::Pi, and residual_for_dispersion().

◆ ~AxisymOscillatingDisk()

AxisymOscillatingDisk::~AxisymOscillatingDisk ( )

inline

Destructor (empty)

96 {}

Member Function Documentation

◆ accel()

void AxisymOscillatingDisk::accel	(	const Vector< double > &	xi,
		Vector< double > &	accel
	)

Parametrised acceleration on object at current time: accel = d^2 r(xi)/dt^2.

 {
  // Parameter values at present time
  double time=Geom_object_time_stepper_pt->time_pt()->time();
  
  // Radius in Lagrangian coordinates
  double lagr_radius=sqrt(pow(xi[0],2)+pow(xi[1],2));
  
  
  if (lagr_radius<1.0e-12)
   {
    // Veloc vector
    accel[0]=0.0;
    accel[1]=0.0;
   }
  else
   {
    // Bessel fcts J_0(x), J_1(x), Y_0(x), Y_1(x) and their derivatives
    double j0,j1,y0,y1,j0p,j1p,y0p,y1p;
    CRBond_Bessel::bessjy01a(Omega*lagr_radius,j0,j1,y0,y1,j0p,j1p,y0p,y1p);
    
    // Deriv of displacement field
    double udotdot=-pow(2.0*MathematicalConstants::Pi/T,2)*Ampl*j1*
     sin(2.0*MathematicalConstants::Pi*time/T);
    
    // Veloc
    accel[0]=(xi[0]/lagr_radius*udotdot);
    accel[1]=(xi[1]/lagr_radius*udotdot);
  
   }
 }

References Ampl, CRBond_Bessel::bessjy01a(), oomph::GeomObject::Geom_object_time_stepper_pt, Omega, BiharmonicTestFunctions2::Pi, Eigen::bfloat16_impl::pow(), sin(), sqrt(), oomph::Time::time(), and oomph::TimeStepper::time_pt().

◆ dposition_dt()

void AxisymOscillatingDisk::dposition_dt	(	const Vector< double > &	xi,
		const unsigned &	j,
		Vector< double > &	drdt
	)

inlinevirtual

Parametrised j-th time-derivative on object at current time: \( \frac{d^{j} r(\zeta)}{dt^j} \).

Reimplemented from oomph::GeomObject.

   {
    switch (j)
     {
      // Current position
     case 0:
      position(xi,drdt);
      break;
      
      // Velocity:
     case 1:
      veloc(xi,drdt);
      break;
  
      // Acceleration:
     case 2:
      accel(xi,drdt);
      break;
      
     default:
      std::ostringstream error_message;
      error_message << j << "th derivative not implemented\n";
      
      throw OomphLibError(error_message.str(),
                          OOMPH_CURRENT_FUNCTION,
                          OOMPH_EXCEPTION_LOCATION);
     }
   }

References j, OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

◆ position()

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

virtual

Position vector at Lagrangian coordinate xi at present time

Position Vector at Lagrangian coordinate xi at present time

Implements oomph::GeomObject.

 {
  // Parameter values at present time
  double time=Geom_object_time_stepper_pt->time_pt()->time();
  
  // Radius in Lagrangian coordinates
  double lagr_radius=sqrt( pow(xi[0],2) + pow(xi[1],2) );
  
  if (lagr_radius<1.0e-12)
   {
    // Position Vector
    r[0]=0.0;
    r[1]=0.0;
   }
  else
   {
    // Bessel fcts J_0(x), J_1(x), Y_0(x), Y_1(x) and their derivatives
    double j0,j1,y0,y1,j0p,j1p,y0p,y1p;
    CRBond_Bessel::bessjy01a(Omega*lagr_radius,j0,j1,y0,y1,j0p,j1p,y0p,y1p);
    
    // Displacement field 
    double u=Ampl*j1*sin(2.0*MathematicalConstants::Pi*time/T);
    
    // Position Vector
    r[0]=(xi[0]+xi[0]/lagr_radius*u);
    r[1]=(xi[1]+xi[1]/lagr_radius*u);
   }
  
 } //end position

References Ampl, CRBond_Bessel::bessjy01a(), oomph::GeomObject::Geom_object_time_stepper_pt, Omega, BiharmonicTestFunctions2::Pi, Eigen::bfloat16_impl::pow(), UniformPSDSelfTest::r, sin(), sqrt(), oomph::Time::time(), and oomph::TimeStepper::time_pt().

◆ residual_for_dispersion()

void AxisymOscillatingDisk::residual_for_dispersion	(	const Vector< double > &	param,
		const Vector< double > &	omega,
		Vector< double > &	residual
	)

static

Residual of dispersion relation for use in black-box Newton method which requires global (or static) functions. Poisson's ratio is passed as parameter.

Residual of dispersion relation for use in black box Newton method which requires global (or static) functions. Poisson's ratio is passed as parameter.

 {
  // Extract parameters
  double nu=param[0];
  
  // Argument of various Bessel functions
  double arg=omega[0];
   
  // Bessel fcts J_0(x), J_1(x), Y_0(x), Y_1(x) and their derivatives
  double j0,j1,y0,y1,j0p,j1p,y0p,y1p;
  CRBond_Bessel::bessjy01a(arg,j0,j1,y0,y1,j0p,j1p,y0p,y1p);
  
  // Residual of dispersion relation
  residual[0]=nu/(1.0-2.0*nu)*(j1+(j0-j1/omega[0])*omega[0])+
   (j0-j1/omega[0])*omega[0];
  
 }

References CRBond_Bessel::bessjy01a(), and Eigen::internal::omega().

Referenced by AxisymOscillatingDisk().

◆ veloc()

void AxisymOscillatingDisk::veloc	(	const Vector< double > &	xi,
		Vector< double > &	veloc
	)

Parametrised velocity on object at current time: veloc = d r(xi)/dt.

 {
  // Parameter values at present time
  double time=Geom_object_time_stepper_pt->time_pt()->time();
  
  // Radius in Lagrangian coordinates
  double lagr_radius=sqrt(pow(xi[0],2)+pow(xi[1],2));
  
  if (lagr_radius<1.0e-12)
   {
    // Veloc vector
    veloc[0]=0.0;
    veloc[1]=0.0;
   }
  else
   {
    // Bessel fcts J_0(x), J_1(x), Y_0(x), Y_1(x) and their derivatives
    double j0,j1,y0,y1,j0p,j1p,y0p,y1p;
    CRBond_Bessel::bessjy01a(Omega*lagr_radius,j0,j1,y0,y1,j0p,j1p,y0p,y1p);
    
    // Deriv of displacement field 
    double udot=2.0*MathematicalConstants::Pi/T*Ampl*j1*
     cos(2.0*MathematicalConstants::Pi*time/T);
    
    // Veloc
    veloc[0]=(xi[0]/lagr_radius*udot);
    veloc[1]=(xi[1]/lagr_radius*udot);
   }
 }