SpikedLine Class Reference

Inheritance diagram for SpikedLine:

Public Member Functions
	SpikedLine (const Vector< Data * > &geom_data_pt)
	SpikedLine (const double &height, const double &amplitude, const double &zeta_min, const double &zeta_max)
	~SpikedLine ()
	Destructor: Clean up if necessary. More...
void	position (const Vector< double > &zeta, Vector< double > &r) const
	Position Vector at Lagrangian coordinate zeta. More...
void	position (const unsigned &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
unsigned	ngeom_data () const
	How many items of Data does the shape of the object depend on? More...
Data *	geom_data_pt (const unsigned &j)
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_dt (const Vector< double > &zeta, const unsigned &j, Vector< double > &drdt)
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

Private Attributes
Vector< Data * >	Geom_data_pt
	Vector of pointers to Data items that affects the object's shape. More...
bool	Must_clean_up
	Do I need to clean up? 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

//////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// Steady, spiked 1D line in 2D space

\[ x = \zeta \]

\[ y = \left\{ \begin{array}{cl} H + 2A\left(\frac{\zeta - \zeta_{\mbox{min}}} {\zeta_{\mbox{max}} - \zeta_{\mbox{min}}}\right) & \mbox{for } \zeta \leq \frac{1}{2} \left(\zeta_{\mbox{max}} + \zeta_{\mbox{min}}\right)\\H + 2A\left(\frac{\zeta - \zeta_{\mbox{max}}} {\zeta_{\mbox{min}} - \zeta_{\mbox{max}}}\right) & \mbox{for } \zeta > \frac{1}{2} \left(\zeta_{\mbox{max}} + \zeta_{\mbox{min}}\right)\\ \end{array} \right.\]

Constructor & Destructor Documentation

SpikedLine() [1/2]

SpikedLine::SpikedLine ( const Vector< Data * > &  geom_data_pt )

inline

Constructor: Four item of geometric data:

Geom_data_pt[0]->value(0) = height
Geom_data_pt[0]->value(1) = amplitude
Geom_data_pt[0]->value(2) = zeta_min
Geom_data_pt[0]->value(3) = zeta_max

                                               : GeomObject(1,2)
  {
#ifdef PARANOID
   if (geom_data_pt.size()!=1)
    {
     std::ostringstream error_stream;
     error_stream 
      << "Wrong size for geom_data_pt " << geom_data_pt.size() << std::endl;
     if (geom_data_pt[0]->nvalue()!=1)
      {
       error_stream << "Wrong geom_data_pt[0]->nvalue() " 
                    << geom_data_pt[0]->nvalue() << std::endl;
      }
     
     throw OomphLibError(error_stream.str(),
                         OOMPH_CURRENT_FUNCTION,
                         OOMPH_EXCEPTION_LOCATION);
    }
#endif
   Geom_data_pt.resize(1);
   Geom_data_pt[0]=geom_data_pt[0];
 
   // Data has been created externally: Must not clean up
   Must_clean_up=false;
  }

References OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

SpikedLine() [2/2]

SpikedLine::SpikedLine ( const double &  height, const double &  amplitude, const double &  zeta_min, const double &  zeta_max  )

inline

Constructor: Pass height, amplitude, zeta min and zeta max (all are pinned by default)

  : GeomObject(1,2)
  {
   // Create Data for deflected-line object
   Geom_data_pt.resize(1);
   
   // Create data: Four value, no timedependence, free by default
   Geom_data_pt[0] = new Data(4);
 
   // I've created the data, I need to clean up
   Must_clean_up=true;
   
   // Pin the data
   for (unsigned i=0;i<4;i++) {Geom_data_pt[0]->pin(i);}
   
   // Give it a value: Initial height
   Geom_data_pt[0]->set_value(0,height);
   Geom_data_pt[0]->set_value(1,amplitude);
   Geom_data_pt[0]->set_value(2,zeta_min);
   Geom_data_pt[0]->set_value(3,zeta_max);
  }

References Global_Physical_Variables::height(), and i.

~SpikedLine()

SpikedLine::~SpikedLine ( )

inline

Destructor: Clean up if necessary.

  {
   // Do I need to clean up?
   if (Must_clean_up)
    {
     delete Geom_data_pt[0];
     Geom_data_pt[0]=0;
    }
  }

Member Function Documentation

d2position() [1/2]

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

inlinevirtual

2nd derivative of position Vector w.r.t. to coordinates: \( \frac{d^2R_i}{d \zeta_\alpha d \zeta_\beta}\) = ddrdzeta(alpha,beta,i). Evaluated at current time.

Reimplemented from oomph::GeomObject.

  {
   // Derivative of tangent vector
   ddrdzeta(0,0,0)=0.0;
   ddrdzeta(0,0,1)=0.0;
  }

d2position() [2/2]

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

inlinevirtual

Posn Vector and its 1st & 2nd derivatives w.r.t. to coordinates: \( \frac{dR_i}{d \zeta_\alpha}\) = drdzeta(alpha,i). \( \frac{d^2R_i}{d \zeta_\alpha d \zeta_\beta}\) = ddrdzeta(alpha,beta,i). Evaluated at current time.

Reimplemented from oomph::GeomObject.

  {
   // Get parametres
   double H = Geom_data_pt[0]->value(0);
   double A = Geom_data_pt[0]->value(1);
   double zeta_min = Geom_data_pt[0]->value(2);
   double zeta_max = Geom_data_pt[0]->value(3);
   double halfLz = (zeta_max-zeta_min)/2.0;
 
   // Position Vector
   r[0] = zeta[0];
   if (zeta[0]-zeta_min<=halfLz)
    {
     r[1] = H + A*(zeta[0]-zeta_min)/halfLz;
    }
   else
    {
     r[1] = H - A*(zeta[0]-zeta_max)/halfLz;
    }
 
   // Tangent vector
   drdzeta(0,0)=1.0;
   if (zeta[0]-zeta_min<=halfLz)
    {
     drdzeta(0,1)=A/halfLz;
    }
   else
    {
     drdzeta(0,1)=-A/halfLz;
    }
 
   // Derivative of tangent vector
   ddrdzeta(0,0,0)=0.0;
   ddrdzeta(0,0,1)=0.0;
  }

References H, UniformPSDSelfTest::r, and Eigen::zeta().

dposition()

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

inlinevirtual

Derivative of position Vector w.r.t. to coordinates: \( \frac{dR_i}{d \zeta_\alpha}\) = drdzeta(alpha,i). Evaluated at current time.

Reimplemented from oomph::GeomObject.

  {
   // Get parametres
   double A = Geom_data_pt[0]->value(1);
   double zeta_min = Geom_data_pt[0]->value(2);
   double zeta_max = Geom_data_pt[0]->value(3);
   double halfLz = (zeta_max-zeta_min)/2.0;
 
   // Tangent vector
   drdzeta(0,0)=1.0;
   if (zeta[0]-zeta_min<=halfLz)
    {
     drdzeta(0,1)=A/halfLz;
    }
   else
    {
     drdzeta(0,1)=-A/halfLz;
    }
  }

References Eigen::zeta().

geom_data_pt()

Data* SpikedLine::geom_data_pt ( const unsigned &  j )

inlinevirtual

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

Reimplemented from oomph::GeomObject.

{return Geom_data_pt[j];}

References j.

ngeom_data()

unsigned SpikedLine::ngeom_data ( ) const

inlinevirtual

How many items of Data does the shape of the object depend on?

Reimplemented from oomph::GeomObject.

{return Geom_data_pt.size();}

position() [1/2]

void SpikedLine::position ( const unsigned &  t, const Vector< double > &  zeta, Vector< double > &  r  ) const

inlinevirtual

Parametrised position on object: r(zeta). Evaluated at previous timestep. t=0: current time; t>0: previous timestep.

Reimplemented from oomph::GeomObject.

  {
#ifdef PARANOID
   if (t>Geom_data_pt[0]->time_stepper_pt()->nprev_values())
    {
     std::ostringstream error_stream;
     error_stream 
      << "t > nprev_values() in SpikedLine:  " << t << " " 
      << Geom_data_pt[0]->time_stepper_pt()->nprev_values() << std::endl;
 
     throw OomphLibError(error_stream.str(),
                         OOMPH_CURRENT_FUNCTION,
                         OOMPH_EXCEPTION_LOCATION);
    }
#endif
 
   // Get parametres
   double H = Geom_data_pt[0]->value(t,0);
   double A = Geom_data_pt[0]->value(t,1);
   double zeta_min = Geom_data_pt[0]->value(t,2);
   double zeta_max = Geom_data_pt[0]->value(t,3);
   double halfLz = (zeta_max-zeta_min)/2.0;
   
   // Position Vector
   r[0] = zeta[0];
   if (zeta[0]-zeta_min<=halfLz)
    {
     r[1] = H + A*(zeta[0]-zeta_min)/halfLz;
    }
   else
    {
     r[1] = H - A*(zeta[0]-zeta_max)/halfLz;
    }
  }

References H, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, UniformPSDSelfTest::r, plotPSD::t, and Eigen::zeta().

position() [2/2]

void SpikedLine::position ( const Vector< double > &  zeta, Vector< double > &  r  ) const

inlinevirtual

Position Vector at Lagrangian coordinate zeta.

Implements oomph::GeomObject.

  {
#ifdef PARANOID
   if (r.size()!=Ndim)
    {
     throw OomphLibError("The vector r has the wrong dimension\n",
                         OOMPH_CURRENT_FUNCTION,
                         OOMPH_EXCEPTION_LOCATION);
    }
#endif
   // Get parametres
   double H = Geom_data_pt[0]->value(0);
   double A = Geom_data_pt[0]->value(1);
   double zeta_min = Geom_data_pt[0]->value(2);
   double zeta_max = Geom_data_pt[0]->value(3);
   double halfLz = (zeta_max-zeta_min)/2.0;
   
   // Position Vector
   r[0] = zeta[0];
   if (zeta[0]-zeta_min<=halfLz)
    {
     r[1] = H + A*(zeta[0]-zeta_min)/halfLz;
    }
   else
    {
     r[1] = H - A*(zeta[0]-zeta_max)/halfLz;
    }
  }

References H, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, UniformPSDSelfTest::r, and Eigen::zeta().

Member Data Documentation

Geom_data_pt

Vector<Data*> SpikedLine::Geom_data_pt

private

Vector of pointers to Data items that affects the object's shape.

Must_clean_up

bool SpikedLine::Must_clean_up

private

Do I need to clean up?

---

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

• spine_channel2.cc