oomph::FullCircleDomain Class Reference

#include <full_circle_domain.h>

Inheritance diagram for oomph::FullCircleDomain:

Public Member Functions
	FullCircleDomain (GeomObject *area_geom_object_pt, const Vector< double > &theta_positions, const Vector< double > &radius_box)
	FullCircleDomain (const FullCircleDomain &)=delete
	Broken copy constructor. More...
void	operator= (const FullCircleDomain &)=delete
	Broken assignment operator. More...
	~FullCircleDomain ()
	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 >	Theta_positions
Vector< double >	Radius_box
GeomObject *	Area_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

Topologically circular domain, e.g. a tube cross section. The entire domain must be defined by a GeomObject with the following convention: zeta[0] is the radial coordinate and zeta[1] is the theta coordinate around the cross-sectin. The outer boundary must lie at zeta[0] = 1.

The domain is parametrised by five macro elements (a central box surrounded by four curved elements). The labelling of the macro elements is shown below.

---

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

Constructor & Destructor Documentation

FullCircleDomain() [1/2]

oomph::FullCircleDomain::FullCircleDomain ( GeomObject *  area_geom_object_pt, const Vector< double > &  theta_positions, const Vector< double > &  radius_box  )

inline

Constructor: Pass geometric object; 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\); and the corresponding fractions of the radius at which the central box is to be placed.

      : Theta_positions(theta_positions),
        Radius_box(radius_box),
        Area_pt(area_geom_object_pt)
    {
      // There are five macro elements
      const unsigned n_macro = 5;
      Macro_element_pt.resize(n_macro);
 
      // Create the macro elements
      for (unsigned i = 0; i < n_macro; i++)
      {
        Macro_element_pt[i] = new QMacroElement<2>(this, i);
      }
    }

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

FullCircleDomain() [2/2]

oomph::FullCircleDomain::FullCircleDomain ( const FullCircleDomain &  )

delete

Broken copy constructor.

~FullCircleDomain()

oomph::FullCircleDomain::~FullCircleDomain ( )

inline

Destructor: Empty; cleanup done in base class.

{}

Member Function Documentation

lin_interpolate()

void oomph::FullCircleDomain::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 (we are working in 2D)
      for (unsigned i = 0; i < 2; 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::FullCircleDomain::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 (N/S/W/E) at time level t (t=0: present; t>0: previous): f(s).

////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////// Vector representation of the imacro-th macro element boundary idirect (N/S/W/E) at time level t (t=0: present; t>0: previous): f(s)

Implements oomph::Domain.

  {
    using namespace QuadTreeNames;
 
    // Get the coordinates of the corners of the box
    Vector<Vector<double>> Box(4);
    // Get the corresponding coordinates on the boundary
    Vector<Vector<double>> Wall(4);
 
    // Storage for position in the area
    Vector<double> zeta(2);
 
    // Loop over the angles
    for (unsigned j = 0; j < 4; j++)
    {
      // Set up the storage
      Box[j].resize(2);
      Wall[j].resize(2);
 
      // Set the other values of zeta
      zeta[0] = Radius_box[j];
      zeta[1] = Theta_positions[j];
      // Now get the values
      Area_pt->position(t, zeta, Box[j]);
 
      // Now get the position on the boundary
      zeta[0] = 1.0;
      Area_pt->position(t, zeta, Wall[j]);
    }
 
    // Define pi
    const double pi = MathematicalConstants::Pi;
 
    // Which macro element?
    // --------------------
    switch (imacro)
    {
        // Macro element 0: Central box
      case 0:
 
        // Choose a direction
        switch (idirect)
        {
          case N:
            // Linearly interpolate between the two corners of the box
            lin_interpolate(Box[3], Box[2], s[0], f);
            break;
 
          case S:
            // Linearly interpolate between the two corners of the box
            lin_interpolate(Box[0], Box[1], s[0], f);
 
          case W:
            // Linearly interpolate between the two corners of the box
            lin_interpolate(Box[0], Box[3], s[0], f);
            break;
 
          case E:
            // Linearly interpolate between the two corners of the box
            lin_interpolate(Box[1], Box[2], s[0], f);
            break;
 
          default:
            std::ostringstream error_stream;
            error_stream << "idirect is " << idirect << " not one of N, S, E, W"
                         << 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 N:
            // Linearly interpolate between the two corners of the box
            lin_interpolate(Box[0], Box[1], s[0], f);
            break;
 
          case S:
            // Get the position on the wall by linearly interpolating in theta
            zeta[0] = 1.0;
            zeta[1] =
              Theta_positions[0] +
              (Theta_positions[1] - Theta_positions[0]) * 0.5 * (s[0] + 1.0);
 
            Area_pt->position(t, zeta, f);
            break;
 
          case W:
            // Now linearly interpolate between the wall and the box
            lin_interpolate(Wall[0], Box[0], s[0], f);
            break;
 
          case E:
            // Linearly interpolate between the wall and the box
            lin_interpolate(Wall[1], Box[1], s[0], f);
            break;
 
          default:
 
            std::ostringstream error_stream;
            error_stream << "idirect is " << idirect << " not one of N, S, E, W"
                         << 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 N:
            // Linearly interpolate between the box and the wall
            lin_interpolate(Box[2], Wall[2], s[0], f);
            break;
 
          case S:
            // Linearly interpolate between the box and the wall
            lin_interpolate(Box[1], Wall[1], s[0], f);
            break;
 
          case W:
            // Linearly interpolate between the two corners of the box
            lin_interpolate(Box[1], Box[2], s[0], f);
            break;
 
          case E:
            // Get the position on the wall by linearly interpolating in theta
            zeta[0] = 1.0;
            zeta[1] =
              Theta_positions[1] +
              (Theta_positions[2] - Theta_positions[1]) * 0.5 * (s[0] + 1.0);
 
            Area_pt->position(t, zeta, f);
            break;
 
          default:
            std::ostringstream error_stream;
            error_stream << "idirect is " << idirect << " not one of N, S, W, E"
                         << 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 N:
            // Get the position on the wall by linearly interpolating in theta
            zeta[0] = 1.0;
            zeta[1] =
              Theta_positions[3] +
              (Theta_positions[2] - Theta_positions[3]) * 0.5 * (s[0] + 1.0);
 
            Area_pt->position(t, zeta, f);
            break;
 
          case S:
            // Linearly interpolate between the two corners of the box
            lin_interpolate(Box[3], Box[1], s[0], f);
            break;
 
          case W:
            // Linearly interpolate between the box and the wall
            lin_interpolate(Box[3], Wall[3], s[0], f);
            break;
 
          case E:
            // Linearly interpolate between the box and the wall
            lin_interpolate(Box[2], Wall[2], s[0], f);
            break;
 
          default:
            std::ostringstream error_stream;
            error_stream << "idirect is " << idirect << " not one of N, S, E, W"
                         << 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 N:
            // Linearly interpolate between the wall and the box
            lin_interpolate(Wall[3], Box[3], s[0], f);
            break;
 
          case S:
            // Linearly interpolate between the wall and the box
            lin_interpolate(Wall[0], Box[0], s[0], f);
            break;
 
          case W:
            // Entirely on the wall, Need to be careful
            // because this is the point at which theta passes through the
            //"branch cut"
            zeta[0] = 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);
 
            Area_pt->position(t, zeta, f);
            break;
 
          case E:
            // Linearly interpolate between the two corners of the box
            lin_interpolate(Box[0], Box[3], s[0], f);
            break;
 
          default:
            std::ostringstream error_stream;
            error_stream << "idirect is " << idirect << " not one of N, S, W, E"
                         << 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 Area_pt, Global_Physical_Variables::E, f(), j, lin_interpolate(), N, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, constants::pi, oomph::MathematicalConstants::Pi, oomph::GeomObject::position(), Radius_box, s, oomph::QuadTreeNames::S, plotPSD::t, Theta_positions, oomph::QuadTreeNames::W, and Eigen::zeta().

operator=()

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

delete

Broken assignment operator.

Member Data Documentation

Area_pt

GeomObject* oomph::FullCircleDomain::Area_pt

private

Pointer to geometric object that represents the domain.

Referenced by macro_element_boundary().

Radius_box

Vector<double> oomph::FullCircleDomain::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::FullCircleDomain::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().

---

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

• full_circle_domain.h