#include <tube_domain.h>

Inheritance diagram for oomph::TubeDomain:

Public Member Functions
	TubeDomain (GeomObject *volume_geom_object_pt, const Vector< double > &centreline_limits, const Vector< double > &theta_positions, const Vector< double > &radius_box, const unsigned &nlayer)

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

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

	~TubeDomain ()
	Destructor: Empty; cleanup done in base class. More...

void	macro_element_boundary (const unsigned &t, const unsigned &i_macro, const unsigned &i_direct, const Vector< double > &s, Vector< double > &f)

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

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

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

virtual	~Domain ()

MacroElement *	macro_element_pt (const unsigned &i)
	Access to i-th macro element. More...

unsigned	nmacro_element ()
	Number of macro elements in domain. More...

void	output (const std::string &filename, const unsigned &nplot)
	Output macro elements. More...

void	output (std::ostream &outfile, const unsigned &nplot)
	Output macro elements. More...

virtual void	macro_element_boundary (const double &t, const unsigned &i_macro, const unsigned &i_direct, const Vector< double > &s, Vector< double > &f)

void	macro_element_boundary (const unsigned &i_macro, const unsigned &i_direct, const Vector< double > &s, Vector< double > &f)

void	output_macro_element_boundaries (const std::string &filename, const unsigned &nplot)
	Output all macro element boundaries as tecplot zones. More...

void	output_macro_element_boundaries (std::ostream &outfile, const unsigned &nplot)
	Output all macro element boundaries as tecplot zones. More...

virtual void	dmacro_element_boundary (const unsigned &t, const unsigned &i_macro, const unsigned &i_direct, const Vector< double > &s, Vector< double > &f)

virtual void	dmacro_element_boundary (const double &t, const unsigned &i_macro, const unsigned &i_direct, const Vector< double > &s, Vector< double > &f)

void	dmacro_element_boundary (const unsigned &i_macro, const unsigned &i_direct, const Vector< double > &s, Vector< double > &f)

virtual void	d2macro_element_boundary (const unsigned &t, const unsigned &i_macro, const unsigned &i_direct, const Vector< double > &s, Vector< double > &f)

virtual void	d2macro_element_boundary (const double &t, const unsigned &i_macro, const unsigned &i_direct, const Vector< double > &s, Vector< double > &f)

void	d2macro_element_boundary (const unsigned &i_macro, const unsigned &i_direct, const Vector< double > &s, Vector< double > &f)

Private Member Functions
void	lin_interpolate (const Vector< double > &low, const Vector< double > &high, const double &s, Vector< double > &f)

Private Attributes
Vector< double >	Centreline_limits
	Storage for the limits of the centreline coordinate. More...

Vector< double >	Theta_positions

Vector< double >	Radius_box

unsigned	Nlayer
	Number of axial layers. More...

GeomObject *	Volume_pt
	Pointer to geometric object that represents the domain. More...

Additional Inherited Members
Protected Attributes inherited from oomph::Domain
Vector< MacroElement * >	Macro_element_pt
	Vector of pointers to macro elements. More...

Detailed Description

Tube as a domain. The entire domain must be defined by a GeomObject with the following convention: zeta[0] is the coordinate along the centreline, zeta[1] is the theta coordinate around the tube wall and zeta[2] is the radial coordinate. The outer boundary must lie at zeta[2] = 1.

The domain is parametrised by five macro elements (a central box surrounded by four curved elements) in each of the nlayer slices. The labelling of the macro elements is as follows with the zeta[0] coordinate coming out of the page.

|\ /| | \ Macro / | | 3 Element 3 2 | | \ / | | -------------—/ | | | | | | 4 | Macro | | | | Element 0 | 2 | | | | | | --------------— | | / \ | | 0 Macro 1 | | / Element 1 \ | | / | |/----------------------—|

Constructor & Destructor Documentation

◆ TubeDomain() [1/2]

oomph::TubeDomain::TubeDomain	(	GeomObject *	volume_geom_object_pt,
		const Vector< double > &	centreline_limits,
		const Vector< double > &	theta_positions,
		const Vector< double > &	radius_box,
		const unsigned &	nlayer
	)

inline

Constructor: Pass geometric object; start and end limit of the centreline coordinate; the theta locations marking the division between the elements of the outer ring, labelled from the lower left to the upper left in order, theta should be in the range \(-\pi\) to \(\pi\); the corresponding fractions of the radius at which the central box is to be placed; and the number of layers in the domain

       : Centreline_limits(centreline_limits),
         Theta_positions(theta_positions),
         Radius_box(radius_box),
         Nlayer(nlayer),
         Volume_pt(volume_geom_object_pt)
     {
       // There are five macro elements
       const unsigned n_macro = 5 * nlayer;
       Macro_element_pt.resize(n_macro);
  
       // Create the macro elements
       for (unsigned i = 0; i < n_macro; i++)
       {
         Macro_element_pt[i] = new QMacroElement<3>(this, i);
       }
     }

References i, and oomph::Domain::Macro_element_pt.

◆ TubeDomain() [2/2]

oomph::TubeDomain::TubeDomain ( const TubeDomain & )

delete

Broken copy constructor.

◆ ~TubeDomain()

oomph::TubeDomain::~TubeDomain ( )

inline

Destructor: Empty; cleanup done in base class.

108 {}

Member Function Documentation

◆ lin_interpolate()

void oomph::TubeDomain::lin_interpolate	(	const Vector< double > &	low,
		const Vector< double > &	high,
		const double &	s,
		Vector< double > &	f
	)

inlineprivate

A very little linear interpolation helper. Interpolate from the low point to the high point using the coordinate s which is assumed to run from -1 to 1.

     {
       // Loop over all coordinates
       for (unsigned i = 0; i < 3; i++)
       {
         f[i] = low[i] + (high[i] - low[i]) * 0.5 * (s + 1.0);
       }
     }

References f(), i, and s.

Referenced by macro_element_boundary().

◆ macro_element_boundary()

void oomph::TubeDomain::macro_element_boundary	(	const unsigned &	t,
		const unsigned &	imacro,
		const unsigned &	idirect,
		const Vector< double > &	s,
		Vector< double > &	f
	)

virtual

Vector representation of the i_macro-th macro element boundary i_direct (L/R/D/U/B/F) at time level t (t=0: present; t>0: previous): f(s).

////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////// Vector representation of the imacro-th macro element boundary idirect (L/R/D/U/B/F) at time level t (t=0: present; t>0: previous): f(s)

Implements oomph::Domain.

   {
     using namespace OcTreeNames;
  
 #ifdef WARN_ABOUT_SUBTLY_CHANGED_OOMPH_INTERFACES
     // Warn about time argument being moved to the front
     OomphLibWarning(
       "Order of function arguments has changed between versions 0.8 and 0.85",
       "TubeDomain::macro_element_boundary(...)",
       OOMPH_EXCEPTION_LOCATION);
 #endif
  
     // Get the number of the layer
     unsigned ilayer = unsigned(imacro / 5);
  
     // Get all required coordinates of the corners of the box
     // at each end of the layer
     Vector<Vector<Vector<double>>> Box(2);
  
     // Get the centreline coordinates at the ends of the layer
     Vector<double> zeta_centre(2);
     // Storage for position in the volume
     Vector<double> zeta(3);
  
     // Loop over the layers
     for (unsigned i = 0; i < 2; i++)
     {
       // Resize the storage
       Box[i].resize(4);
  
       // Get the centreline coordinate
       zeta_centre[i] =
         Centreline_limits[0] + (ilayer + i) *
                                  (Centreline_limits[1] - Centreline_limits[0]) /
                                  (double)(Nlayer);
  
       // Now get the coordinates of each corner
       zeta[0] = zeta_centre[i];
  
       // Loop over the angles
       for (unsigned j = 0; j < 4; j++)
       {
         // Set up the storage
         Box[i][j].resize(3);
  
         // Set the other values of zeta
         zeta[1] = Theta_positions[j];
         zeta[2] = Radius_box[j];
  
         // Now get the values
         Volume_pt->position(t, zeta, Box[i][j]);
       }
     }
  
     // Local storage for positions on the boundaries
     Vector<double> pos_1(3), pos_2(3);
  
     const double pi = MathematicalConstants::Pi;
  
     // Which macro element?
     // --------------------
     switch (imacro % 5)
     {
         // Macro element 0: Central box
       case 0:
  
         // Choose a direction
         switch (idirect)
         {
           case L:
             // Need to get the position from the domain
             // Get the centreline position
             zeta[0] = zeta_centre[0] +
                       (zeta_centre[1] - zeta_centre[0]) * 0.5 * (s[1] + 1.0);
             // Get the lower corner
             zeta[1] = Theta_positions[0];
             zeta[2] = Radius_box[0];
             Volume_pt->position(t, zeta, pos_1);
  
             // Get the upper corner
             zeta[1] = Theta_positions[3];
             zeta[2] = Radius_box[3];
             Volume_pt->position(t, zeta, pos_2);
  
             // Now interpolate between the two corner positions
             lin_interpolate(pos_1, pos_2, s[0], f);
             break;
  
           case R:
             // Need to get the position from the domain
             // Get the centreline position
             zeta[0] = zeta_centre[0] +
                       (zeta_centre[1] - zeta_centre[0]) * 0.5 * (s[1] + 1.0);
             // Get the lower corner
             zeta[1] = Theta_positions[1];
             zeta[2] = Radius_box[1];
             Volume_pt->position(t, zeta, pos_1);
  
             // Get the upper corner
             zeta[1] = Theta_positions[2];
             zeta[2] = Radius_box[2];
             Volume_pt->position(t, zeta, pos_2);
  
             // Now interpolate between the positions
             lin_interpolate(pos_1, pos_2, s[0], f);
             break;
  
           case D:
             // Need to get the position from the domain
             // Get the centreline position
             zeta[0] = zeta_centre[0] +
                       (zeta_centre[1] - zeta_centre[0]) * 0.5 * (s[1] + 1.0);
             // Get the left corner
             zeta[1] = Theta_positions[0];
             zeta[2] = Radius_box[0];
             Volume_pt->position(t, zeta, pos_1);
  
             // Get the right corner
             zeta[1] = Theta_positions[1];
             zeta[2] = Radius_box[1];
             Volume_pt->position(t, zeta, pos_2);
             // Now interpolate between the positions
             lin_interpolate(pos_1, pos_2, s[0], f);
             break;
  
           case U:
             // Need to get the position from the domain
             // Get the centreline position
             zeta[0] = zeta_centre[0] +
                       (zeta_centre[1] - zeta_centre[0]) * 0.5 * (s[1] + 1.0);
             // Get the left corner
             zeta[1] = Theta_positions[3];
             zeta[2] = Radius_box[3];
             Volume_pt->position(t, zeta, pos_1);
  
             // Get the right corner
             zeta[1] = Theta_positions[2];
             zeta[2] = Radius_box[2];
             Volume_pt->position(t, zeta, pos_2);
  
             // Now interpolate between the positions
             lin_interpolate(pos_1, pos_2, s[0], f);
             break;
  
           case B:
             // Linearly interpolate between lower left and lower right corners
             lin_interpolate(Box[0][0], Box[0][1], s[0], pos_1);
             // Linearly interpolate between upper left and upper right corners
             lin_interpolate(Box[0][3], Box[0][2], s[0], pos_2);
             // Finally, linearly interpolate between the upper and lower
             // positions
             lin_interpolate(pos_1, pos_2, s[1], f);
             break;
  
           case F:
             // Linearly interpolate between lower left and lower right corners
             lin_interpolate(Box[1][0], Box[1][1], s[0], pos_1);
             // Linearly interpolate between upper left and upper right corners
             lin_interpolate(Box[1][3], Box[1][2], s[0], pos_2);
             // Finally, linearly interpolate between the upper and lower
             // positions
             lin_interpolate(pos_1, pos_2, s[1], f);
             break;
  
           default:
             std::ostringstream error_stream;
             error_stream << "idirect is " << idirect
                          << " not one of L, R, D, U, B, F" << std::endl;
  
             throw OomphLibError(error_stream.str(),
                                 OOMPH_CURRENT_FUNCTION,
                                 OOMPH_EXCEPTION_LOCATION);
             break;
         }
  
         break;
  
  
         // Macro element 1: Bottom
       case 1:
  
         // Choose a direction
         switch (idirect)
         {
           case L:
             // Get the position on the wall
             zeta[0] = zeta_centre[0] +
                       (zeta_centre[1] - zeta_centre[0]) * 0.5 * (s[1] + 1.0);
             zeta[1] = Theta_positions[0];
             zeta[2] = 1.0;
             Volume_pt->position(t, zeta, pos_1);
  
             // Get the position on the box
             zeta[2] = Radius_box[0];
             Volume_pt->position(t, zeta, pos_2);
  
             // Now linearly interpolate between the two
             lin_interpolate(pos_1, pos_2, s[0], f);
             break;
  
           case R:
             // Get the position on the wall
             zeta[0] = zeta_centre[0] +
                       (zeta_centre[1] - zeta_centre[0]) * 0.5 * (s[1] + 1.0);
             zeta[1] = Theta_positions[1];
             zeta[2] = 1.0;
             Volume_pt->position(t, zeta, pos_1);
  
             // Get the position from the box
             zeta[2] = Radius_box[1];
             Volume_pt->position(t, zeta, pos_2);
  
             // Now linearly interpolate between the two
             lin_interpolate(pos_1, pos_2, s[0], f);
             break;
  
           case D:
             // This is entrirly on the wall
             zeta[0] = zeta_centre[0] +
                       (zeta_centre[1] - zeta_centre[0]) * 0.5 * (s[1] + 1.0);
             zeta[1] =
               Theta_positions[0] +
               (Theta_positions[1] - Theta_positions[0]) * 0.5 * (s[0] + 1.0);
             zeta[2] = 1.0;
             Volume_pt->position(t, zeta, f);
             break;
  
           case U:
             // Need to get the position from the domain
             // Get the centreline position
             zeta[0] = zeta_centre[0] +
                       (zeta_centre[1] - zeta_centre[0]) * 0.5 * (s[1] + 1.0);
             // Get the left corner
             zeta[1] = Theta_positions[0];
             zeta[2] = Radius_box[0];
             Volume_pt->position(t, zeta, pos_1);
  
             // Get the right corner
             zeta[1] = Theta_positions[1];
             zeta[2] = Radius_box[1];
             Volume_pt->position(t, zeta, pos_2);
             // Now interpolate between the positions
             lin_interpolate(pos_1, pos_2, s[0], f);
             break;
  
           case B:
             // Get the position on the wall
             zeta[0] = zeta_centre[0];
             zeta[1] =
               Theta_positions[0] +
               (Theta_positions[1] - Theta_positions[0]) * 0.5 * (s[0] + 1.0);
             zeta[2] = 1.0;
             Volume_pt->position(t, zeta, pos_1);
  
             // Now linearly interpolate the position on the box
             lin_interpolate(Box[0][0], Box[0][1], s[0], pos_2);
  
             // Now linearly interpolate between the two
             lin_interpolate(pos_1, pos_2, s[1], f);
             break;
  
           case F:
             // Get the position on the wall
             zeta[0] = zeta_centre[1];
             zeta[1] =
               Theta_positions[0] +
               (Theta_positions[1] - Theta_positions[0]) * 0.5 * (s[0] + 1.0);
             zeta[2] = 1.0;
             Volume_pt->position(t, zeta, pos_1);
  
             // Now linearly interpolate the position on the box
             lin_interpolate(Box[1][0], Box[1][1], s[0], pos_2);
  
             // Now linearly interpolate between the two
             lin_interpolate(pos_1, pos_2, s[1], f);
             break;
  
  
           default:
  
             std::ostringstream error_stream;
             error_stream << "idirect is " << idirect
                          << " not one of L, R, D, U, B, F" << std::endl;
  
             throw OomphLibError(error_stream.str(),
                                 OOMPH_CURRENT_FUNCTION,
                                 OOMPH_EXCEPTION_LOCATION);
             break;
         }
  
  
         break;
  
       // Macro element 2:Right
       case 2:
  
         // Which direction?
         switch (idirect)
         {
           case L:
             // Need to get the position from the domain
             // Get the centreline position
             zeta[0] = zeta_centre[0] +
                       (zeta_centre[1] - zeta_centre[0]) * 0.5 * (s[1] + 1.0);
             // Get the lower corner
             zeta[1] = Theta_positions[1];
             zeta[2] = Radius_box[1];
             Volume_pt->position(t, zeta, pos_1);
  
             // Get the upper corner
             zeta[1] = Theta_positions[2];
             zeta[2] = Radius_box[2];
             Volume_pt->position(t, zeta, pos_2);
             // Now interpolate between the positions
             lin_interpolate(pos_1, pos_2, s[0], f);
             break;
  
           case R:
             // Entirely on the wall
             zeta[0] = zeta_centre[0] +
                       (zeta_centre[1] - zeta_centre[0]) * 0.5 * (s[1] + 1.0);
             zeta[1] =
               Theta_positions[1] +
               (Theta_positions[2] - Theta_positions[1]) * 0.5 * (s[0] + 1.0);
             zeta[2] = 1.0;
             Volume_pt->position(t, zeta, f);
             break;
  
           case U:
             // Get the position on the wall
             zeta[0] = zeta_centre[0] +
                       (zeta_centre[1] - zeta_centre[0]) * 0.5 * (s[1] + 1.0);
             zeta[1] = Theta_positions[2];
             zeta[2] = 1.0;
             Volume_pt->position(t, zeta, pos_1);
  
             // Get the position of the box
             zeta[2] = Radius_box[2];
             Volume_pt->position(t, zeta, pos_2);
  
             // Now linearly interpolate between the two
             lin_interpolate(pos_2, pos_1, s[0], f);
             break;
  
           case D:
             // Get the position on the wall
             zeta[0] = zeta_centre[0] +
                       (zeta_centre[1] - zeta_centre[0]) * 0.5 * (s[1] + 1.0);
             zeta[1] = Theta_positions[1];
             zeta[2] = 1.0;
             Volume_pt->position(t, zeta, pos_1);
  
             // Get the position of the box
             zeta[2] = Radius_box[1];
             Volume_pt->position(t, zeta, pos_2);
  
             // Now linearly interpolate between the two
             lin_interpolate(pos_2, pos_1, s[0], f);
             break;
  
           case B:
             // Get the position on the wall
             zeta[0] = zeta_centre[0];
             zeta[1] =
               Theta_positions[1] +
               (Theta_positions[2] - Theta_positions[1]) * 0.5 * (s[1] + 1.0);
             zeta[2] = 1.0;
             Volume_pt->position(t, zeta, pos_1);
  
             // Now linearly interpolate the position on the box
             lin_interpolate(Box[0][1], Box[0][2], s[1], pos_2);
  
             // Now linearly interpolate between the two
             lin_interpolate(pos_2, pos_1, s[0], f);
             break;
  
           case F:
             // Get the position on the wall
             zeta[0] = zeta_centre[1];
             zeta[1] =
               Theta_positions[1] +
               (Theta_positions[2] - Theta_positions[1]) * 0.5 * (s[1] + 1.0);
             zeta[2] = 1.0;
             Volume_pt->position(t, zeta, pos_1);
  
             // Now linearly interpolate the position on the box
             lin_interpolate(Box[1][1], Box[1][2], s[1], pos_2);
  
             // Now linearly interpolate between the two
             lin_interpolate(pos_2, pos_1, s[0], f);
             break;
  
  
           default:
             std::ostringstream error_stream;
             error_stream << "idirect is " << idirect
                          << " not one of L, R, D, U, B, F" << std::endl;
  
             throw OomphLibError(error_stream.str(),
                                 OOMPH_CURRENT_FUNCTION,
                                 OOMPH_EXCEPTION_LOCATION);
         }
  
         break;
  
         // Macro element 3: Top
       case 3:
  
         // Which direction?
         switch (idirect)
         {
           case L:
             // Get the position on the wall
             zeta[0] = zeta_centre[0] +
                       (zeta_centre[1] - zeta_centre[0]) * 0.5 * (s[1] + 1.0);
             zeta[1] = Theta_positions[3];
             zeta[2] = 1.0;
             Volume_pt->position(t, zeta, pos_1);
  
             // Get the position on the box
             zeta[2] = Radius_box[3];
             Volume_pt->position(t, zeta, pos_2);
  
  
             // Now linearly interpolate between the two
             lin_interpolate(pos_2, pos_1, s[0], f);
             break;
  
           case R:
             // Get the position on the wall
             zeta[0] = zeta_centre[0] +
                       (zeta_centre[1] - zeta_centre[0]) * 0.5 * (s[1] + 1.0);
             zeta[1] = Theta_positions[2];
             zeta[2] = 1.0;
             Volume_pt->position(t, zeta, pos_1);
  
             // Get the position on the box
             zeta[2] = Radius_box[2];
             Volume_pt->position(t, zeta, pos_2);
  
  
             // Now linearly interpolate between the two
             lin_interpolate(pos_2, pos_1, s[0], f);
             break;
  
           case D:
             // This is entirely on the box
             // Need to get the position from the domain
             // Get the centreline position
             zeta[0] = zeta_centre[0] +
                       (zeta_centre[1] - zeta_centre[0]) * 0.5 * (s[1] + 1.0);
             zeta[1] = Theta_positions[3];
             zeta[2] = Radius_box[3];
             // Get the lower corner
             Volume_pt->position(t, zeta, pos_2);
  
             // Get the upper corner
             zeta[1] = Theta_positions[2];
             zeta[2] = Radius_box[2];
             // Get the upper corner
             Volume_pt->position(t, zeta, pos_1);
             // Now interpolate between the positions
             lin_interpolate(pos_2, pos_1, s[0], f);
             break;
  
           case U:
             // This is entirely on the wall
             zeta[0] = zeta_centre[0] +
                       (zeta_centre[1] - zeta_centre[0]) * 0.5 * (s[1] + 1.0);
             zeta[1] =
               Theta_positions[3] +
               (Theta_positions[2] - Theta_positions[3]) * 0.5 * (s[0] + 1.0);
             zeta[2] = 1.0;
             Volume_pt->position(t, zeta, f);
             break;
  
           case B:
             // Get the position on the wall
             zeta[0] = zeta_centre[0];
             zeta[1] =
               Theta_positions[3] +
               (Theta_positions[2] - Theta_positions[3]) * 0.5 * (s[0] + 1.0);
             zeta[2] = 1.0;
             Volume_pt->position(t, zeta, pos_1);
  
             // Now linearly interpolate the position on the box
             lin_interpolate(Box[0][3], Box[0][2], s[0], pos_2);
  
             // Now linearly interpolate between the two
             lin_interpolate(pos_2, pos_1, s[1], f);
             break;
  
           case F:
             // Get the position on the wall
             zeta[0] = zeta_centre[1];
             zeta[1] =
               Theta_positions[3] +
               (Theta_positions[2] - Theta_positions[3]) * 0.5 * (s[0] + 1.0);
             zeta[2] = 1.0;
             Volume_pt->position(t, zeta, pos_1);
  
             // Now linearly interpolate the position on the box
             lin_interpolate(Box[1][3], Box[1][2], s[0], pos_2);
  
             // Now linearly interpolate between the two
             lin_interpolate(pos_2, pos_1, s[1], f);
             break;
  
  
           default:
             std::ostringstream error_stream;
             error_stream << "idirect is " << idirect
                          << " not one of L, R, D, U, B, F" << std::endl;
  
             throw OomphLibError(error_stream.str(),
                                 OOMPH_CURRENT_FUNCTION,
                                 OOMPH_EXCEPTION_LOCATION);
         }
  
         break;
  
  
         // Macro element 4: Left
       case 4:
  
         // Which direction?
         switch (idirect)
         {
           case L:
             // Entirely on the wall, Need to be careful
             // because this is the point at which theta passes through the
             // branch cut
             zeta[0] = zeta_centre[0] +
                       (zeta_centre[1] - zeta_centre[0]) * 0.5 * (s[1] + 1.0);
             zeta[1] = Theta_positions[0] + 2.0 * pi +
                       (Theta_positions[3] - (Theta_positions[0] + 2.0 * pi)) *
                         0.5 * (s[0] + 1.0);
             zeta[2] = 1.0;
             Volume_pt->position(t, zeta, f);
             break;
  
           case R:
             // Entirely on the box
             // Need to get the position from the domain
             // Get the centreline position
             zeta[0] = zeta_centre[0] +
                       (zeta_centre[1] - zeta_centre[0]) * 0.5 * (s[1] + 1.0);
             zeta[1] = Theta_positions[0];
             zeta[2] = Radius_box[0];
             // Get the lower corner
             Volume_pt->position(t, zeta, pos_2);
  
             // Get the upper corner
             zeta[1] = Theta_positions[3];
             zeta[2] = Radius_box[3];
             // Get the upper corner
             Volume_pt->position(t, zeta, pos_1);
  
             lin_interpolate(pos_2, pos_1, s[0], f);
             break;
  
           case D:
             // Get the position on the wall
             zeta[0] = zeta_centre[0] +
                       (zeta_centre[1] - zeta_centre[0]) * 0.5 * (s[1] + 1.0);
             zeta[1] = Theta_positions[0];
             zeta[2] = 1.0;
             Volume_pt->position(t, zeta, pos_1);
  
  
             // Get the position on the box
             zeta[2] = Radius_box[0];
             Volume_pt->position(t, zeta, pos_2);
  
  
             // Now linearly interpolate between the two
             lin_interpolate(pos_1, pos_2, s[0], f);
             break;
  
           case U:
             // Get the position on the wall
             zeta[0] = zeta_centre[0] +
                       (zeta_centre[1] - zeta_centre[0]) * 0.5 * (s[1] + 1.0);
             zeta[1] = Theta_positions[3];
             zeta[2] = 1.0;
             Volume_pt->position(t, zeta, pos_1);
  
             // Get the position on the box
             zeta[2] = Radius_box[3];
             Volume_pt->position(t, zeta, pos_2);
  
             // Now linearly interpolate between the two
             lin_interpolate(pos_1, pos_2, s[0], f);
             break;
  
           case B:
             // Get the position on the wall
             // Again be careful of the branch cut
             zeta[0] = zeta_centre[0];
             zeta[1] = Theta_positions[0] + 2.0 * pi +
                       (Theta_positions[3] - (Theta_positions[0] + 2.0 * pi)) *
                         0.5 * (s[1] + 1.0);
             zeta[2] = 1.0;
             Volume_pt->position(t, zeta, pos_1);
  
             // Now linearly interpolate the position on the box
             lin_interpolate(Box[0][0], Box[0][3], s[1], pos_2);
  
             // Now linearly interpolate between the two
             lin_interpolate(pos_1, pos_2, s[0], f);
             break;
  
  
           case F:
             // Get the position on the wall
             // Again be careful of the branch cut
             zeta[0] = zeta_centre[1];
             zeta[1] = Theta_positions[0] + 2.0 * pi +
                       (Theta_positions[3] - (Theta_positions[0] + 2.0 * pi)) *
                         0.5 * (s[1] + 1.0);
             zeta[2] = 1.0;
             Volume_pt->position(t, zeta, pos_1);
  
             // Now linearly interpolate the position on the box
             lin_interpolate(Box[1][0], Box[1][3], s[1], pos_2);
  
             // Now linearly interpolate between the two
             lin_interpolate(pos_1, pos_2, s[0], f);
             break;
  
  
           default:
             std::ostringstream error_stream;
             error_stream << "idirect is " << idirect
                          << " not one of L, R, D, U, B, F" << std::endl;
  
             throw OomphLibError(error_stream.str(),
                                 OOMPH_CURRENT_FUNCTION,
                                 OOMPH_EXCEPTION_LOCATION);
         }
         break;
  
  
       default:
         // Error
         std::ostringstream error_stream;
         error_stream << "Wrong imacro " << imacro << std::endl;
         throw OomphLibError(
           error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
   }

References Centreline_limits, D, f(), oomph::OcTreeNames::F, i, j, L, lin_interpolate(), Nlayer, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, constants::pi, oomph::MathematicalConstants::Pi, oomph::GeomObject::position(), R, Radius_box, s, plotPSD::t, Theta_positions, RachelsAdvectionDiffusion::U, Volume_pt, and Eigen::zeta().

◆ operator=()

void oomph::TubeDomain::operator= ( const TubeDomain & )

delete

Broken assignment operator.

Member Data Documentation

◆ Centreline_limits

Vector<double> oomph::TubeDomain::Centreline_limits

private

Storage for the limits of the centreline coordinate.

Referenced by macro_element_boundary().

◆ Nlayer

unsigned oomph::TubeDomain::Nlayer

private

Number of axial layers.

Referenced by macro_element_boundary().

◆ Radius_box

Vector<double> oomph::TubeDomain::Radius_box

private

Storage for the fraction of the radius at which the central box should be located corresponding to the chosen values of theta.

Referenced by macro_element_boundary().

◆ Theta_positions

Vector<double> oomph::TubeDomain::Theta_positions

private

Storage for the dividing lines on the boundary starting from the lower left and proceeding anticlockwise to the upper left

Referenced by macro_element_boundary().

◆ Volume_pt

GeomObject* oomph::TubeDomain::Volume_pt

private

Pointer to geometric object that represents the domain.

Referenced by macro_element_boundary().

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

tube_domain.h

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ TubeDomain() [1/2]

◆ TubeDomain() [2/2]

◆ ~TubeDomain()

Member Function Documentation

◆ lin_interpolate()

◆ macro_element_boundary()

◆ operator=()

Member Data Documentation

◆ Centreline_limits

◆ Nlayer

◆ Radius_box

◆ Theta_positions

◆ Volume_pt