oomph::QMacroElement< 3 > Class Reference

#include <macro_element.h>

Inheritance diagram for oomph::QMacroElement< 3 >:

Public Member Functions
	QMacroElement (Domain *domain_pt, const unsigned &macro_element_number)
	QMacroElement ()
	Default constructor (empty and broken) More...
	QMacroElement (const QMacroElement &dummy)=delete
	Broken copy constructor. More...
void	operator= (const QMacroElement &)=delete
	Broken assignment operator. More...
virtual	~QMacroElement ()
	Empty destructor. More...
void	output (const unsigned &t, std::ostream &outfile, const unsigned &nplot)
void	output_macro_element_boundaries (std::ostream &outfile, const unsigned &nplot)
	Output all macro element boundaries as tecplot zones. More...
void	macro_map (const unsigned &t, const Vector< double > &S, Vector< double > &r)
Public Member Functions inherited from oomph::MacroElement
	MacroElement (Domain *domain_pt, const unsigned &macro_element_number)
	MacroElement ()
	Default constructor (empty and broken) More...
	MacroElement (const MacroElement &dummy)=delete
	Broken copy constructor. More...
void	operator= (const MacroElement &)=delete
	Broken assignment operator. More...
virtual	~MacroElement ()
	Empty destructor. More...
void	output (std::ostream &outfile, const int &nplot)
void	macro_map (const Vector< double > &s, Vector< double > &r)
	The mapping from local to global coordinates at the current time : r(s) More...
virtual void	macro_map (const double &t, const Vector< double > &s, Vector< double > &r)
	Get global position r(s) at continuous time value, t. More...
virtual void	assemble_macro_to_eulerian_jacobian (const unsigned &t, const Vector< double > &s, DenseMatrix< double > &jacobian)
virtual void	assemble_macro_to_eulerian_jacobian2 (const unsigned &t, const Vector< double > &s, DenseMatrix< double > &jacobian2)
void	assemble_macro_to_eulerian_jacobian (const Vector< double > &s, DenseMatrix< double > &jacobian)
void	assemble_macro_to_eulerian_jacobian2 (const Vector< double > &s, DenseMatrix< double > &jacobian2)
unsigned &	macro_element_number ()
	Access function to the Macro_element_number. More...
Domain *&	domain_pt ()
	Access function to the Domain_pt. More...

Additional Inherited Members
Protected Attributes inherited from oomph::MacroElement
Domain *	Domain_pt
	Pointer to domain. More...
unsigned	Macro_element_number
	What is the number of the current macro element within its domain. More...

Detailed Description

QMacroElement specialised to 3 spatial dimensions.

The macro element mapping is based on the member function pointer to the associated Domain 's

Domain::macro_element_boundary(...) 

function which provides a parametrisation of the macro element's boundaries in the form:

\[ {\bf f}_{i} (t,{\bf S}) \]

where

• \( i \) labels the boundary (L/R/D/U/B/F)
• \( {\bf S} \in [-1,1]^2 \) is the (2D) Vector of local coordinate(s) along the boundary.
• \( {\bf f} \) is the position Vector to the boundary.
• \( t \) is the time level (t=0: current; t>0 previous timestep)

Constructor & Destructor Documentation

QMacroElement() [1/3]

oomph::QMacroElement< 3 >::QMacroElement ( Domain *  domain_pt, const unsigned &  macro_element_number  )

inline

Constructor: Pass the pointer to the domain and the macro element's number within this domain

      : MacroElement(domain_pt, macro_element_number){};

QMacroElement() [2/3]

oomph::QMacroElement< 3 >::QMacroElement ( )

inline

Default constructor (empty and broken)

    {
      throw OomphLibError("Don't call empty constructor for QMacroElement!",
                          OOMPH_CURRENT_FUNCTION,
                          OOMPH_EXCEPTION_LOCATION);
    }

References OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

QMacroElement() [3/3]

oomph::QMacroElement< 3 >::QMacroElement ( const QMacroElement< 3 > &  dummy )

delete

Broken copy constructor.

~QMacroElement()

virtual oomph::QMacroElement< 3 >::~QMacroElement ( )

inlinevirtual

Empty destructor.

{};

Member Function Documentation

macro_map()

void oomph::QMacroElement< 3 >::macro_map ( const unsigned &  t, const Vector< double > &  S, Vector< double > &  r  )

virtual

Get global position r(S) at discrete time level t. t=0: Present time; t>0: previous timestep.

/////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////// Get global position r(S) at discrete time level t. t=0: Present time; t>0: previous timestep.

Implements oomph::MacroElement.

  {
    // get the eight corners
    Vector<double> corner_LDB(3);
    Vector<double> corner_RDB(3);
    Vector<double> corner_LUB(3);
    Vector<double> corner_RUB(3);
    Vector<double> corner_LDF(3);
    Vector<double> corner_RDF(3);
    Vector<double> corner_LUF(3);
    Vector<double> corner_RUF(3);
 
    Vector<double> zeta(2);
    zeta[0] = -1.0;
    zeta[1] = -1.0;
    Domain_pt->macro_element_boundary(
      t, Macro_element_number, OcTreeNames::B, zeta, corner_LDB);
    Domain_pt->macro_element_boundary(
      t, Macro_element_number, OcTreeNames::U, zeta, corner_LUB);
    Domain_pt->macro_element_boundary(
      t, Macro_element_number, OcTreeNames::F, zeta, corner_LDF);
    Domain_pt->macro_element_boundary(
      t, Macro_element_number, OcTreeNames::R, zeta, corner_RDB);
    zeta[0] = 1.0;
    zeta[1] = 1.0;
    Domain_pt->macro_element_boundary(
      t, Macro_element_number, OcTreeNames::B, zeta, corner_RUB);
    Domain_pt->macro_element_boundary(
      t, Macro_element_number, OcTreeNames::D, zeta, corner_RDF);
    Domain_pt->macro_element_boundary(
      t, Macro_element_number, OcTreeNames::L, zeta, corner_LUF);
    Domain_pt->macro_element_boundary(
      t, Macro_element_number, OcTreeNames::R, zeta, corner_RUF);
 
 
    // get the position of the 4 corners of the center slice
    Vector<double> corner_LD(3);
    Vector<double> corner_RD(3);
    Vector<double> corner_LU(3);
    Vector<double> corner_RU(3);
 
    zeta[0] = -1.0;
    zeta[1] = S[2];
    Domain_pt->macro_element_boundary(
      t, Macro_element_number, OcTreeNames::D, zeta, corner_LD);
    Domain_pt->macro_element_boundary(
      t, Macro_element_number, OcTreeNames::U, zeta, corner_LU);
    zeta[0] = 1.0;
    Domain_pt->macro_element_boundary(
      t, Macro_element_number, OcTreeNames::D, zeta, corner_RD);
    Domain_pt->macro_element_boundary(
      t, Macro_element_number, OcTreeNames::U, zeta, corner_RU);
 
    // get position on the B,F faces;
    Vector<double> face_B(3);
    Vector<double> face_F(3);
 
    zeta[0] = S[0];
    zeta[1] = S[1];
    Domain_pt->macro_element_boundary(
      t, Macro_element_number, OcTreeNames::B, zeta, face_B);
    Domain_pt->macro_element_boundary(
      t, Macro_element_number, OcTreeNames::F, zeta, face_F);
 
 
    // get position on the edges of the middle slice
    Vector<double> edge_mid_L(3);
    Vector<double> edge_mid_R(3);
    Vector<double> edge_mid_D(3);
    Vector<double> edge_mid_U(3);
    zeta[0] = S[0];
    zeta[1] = S[2];
    Domain_pt->macro_element_boundary(
      t, Macro_element_number, OcTreeNames::U, zeta, edge_mid_U);
 
    Domain_pt->macro_element_boundary(
      t, Macro_element_number, OcTreeNames::D, zeta, edge_mid_D);
    zeta[0] = S[1];
    zeta[1] = S[2];
    Domain_pt->macro_element_boundary(
      t, Macro_element_number, OcTreeNames::L, zeta, edge_mid_L);
 
    Domain_pt->macro_element_boundary(
      t, Macro_element_number, OcTreeNames::R, zeta, edge_mid_R);
 
    // get position on the edges of the back slice
    Vector<double> edge_back_L(3);
    Vector<double> edge_back_R(3);
    Vector<double> edge_back_D(3);
    Vector<double> edge_back_U(3);
    zeta[0] = S[0];
    zeta[1] = -1.0;
    Domain_pt->macro_element_boundary(
      t, Macro_element_number, OcTreeNames::U, zeta, edge_back_U);
 
    Domain_pt->macro_element_boundary(
      t, Macro_element_number, OcTreeNames::D, zeta, edge_back_D);
    zeta[0] = S[1];
    zeta[1] = -1.0;
    Domain_pt->macro_element_boundary(
      t, Macro_element_number, OcTreeNames::L, zeta, edge_back_L);
 
    Domain_pt->macro_element_boundary(
      t, Macro_element_number, OcTreeNames::R, zeta, edge_back_R);
 
    // get position on the edges of the front slice
    Vector<double> edge_front_L(3);
    Vector<double> edge_front_R(3);
    Vector<double> edge_front_D(3);
    Vector<double> edge_front_U(3);
    zeta[0] = S[0];
    zeta[1] = 1.0;
    Domain_pt->macro_element_boundary(
      t, Macro_element_number, OcTreeNames::U, zeta, edge_front_U);
 
    Domain_pt->macro_element_boundary(
      t, Macro_element_number, OcTreeNames::D, zeta, edge_front_D);
    zeta[0] = S[1];
    zeta[1] = 1.0;
    Domain_pt->macro_element_boundary(
      t, Macro_element_number, OcTreeNames::L, zeta, edge_front_L);
 
    Domain_pt->macro_element_boundary(
      t, Macro_element_number, OcTreeNames::R, zeta, edge_front_R);
 
 
    for (unsigned i = 0; i < 3; i++)
    {
      // Position on the middle slice
      // ============================
      double slice_mid;
 
      // the points on the up and down edges of the middle "rectangular slice"
      double ptUp, ptDo;
      ptUp = corner_LU[i] + (corner_RU[i] - corner_LU[i]) * 0.5 * (S[0] + 1.0);
      ptDo = corner_LD[i] + (corner_RD[i] - corner_LD[i]) * 0.5 * (S[0] + 1.0);
      // position in the rectangular middle slice
      slice_mid = ptDo + 0.5 * (1.0 + S[1]) * (ptUp - ptDo);
 
      // get the differences to the edges of the middle slice
      double diff_L, diff_R, diff_D, diff_U;
      diff_L = edge_mid_L[i] - slice_mid;
      diff_R = edge_mid_R[i] - slice_mid;
      diff_D = edge_mid_D[i] - slice_mid;
      diff_U = edge_mid_U[i] - slice_mid;
 
      // Map it to get the position in the middle slice
      slice_mid +=
        diff_L * (1.0 - 0.5 * (S[0] + 1.0)) + diff_R * 0.5 * (S[0] + 1.0) +
        diff_D * (1.0 - 0.5 * (S[1] + 1.0)) + diff_U * 0.5 * (S[1] + 1.0);
 
 
      // Position on the back slice
      //===========================
      double slice_back;
 
      // the points on the up and down edges of the back "rectangular slice"
      ptUp =
        corner_LUB[i] + (corner_RUB[i] - corner_LUB[i]) * 0.5 * (S[0] + 1.0);
      ptDo =
        corner_LDB[i] + (corner_RDB[i] - corner_LDB[i]) * 0.5 * (S[0] + 1.0);
      // position in the rectangular back slice
      slice_back = ptDo + 0.5 * (1.0 + S[1]) * (ptUp - ptDo);
 
      // get the differences to the edges of the middle slice
      diff_L = edge_back_L[i] - slice_back;
      diff_R = edge_back_R[i] - slice_back;
      diff_D = edge_back_D[i] - slice_back;
      diff_U = edge_back_U[i] - slice_back;
 
      // Map it to get the position in the back slice
      slice_back +=
        diff_L * (1.0 - 0.5 * (S[0] + 1.0)) + diff_R * 0.5 * (S[0] + 1.0) +
        diff_D * (1.0 - 0.5 * (S[1] + 1.0)) + diff_U * 0.5 * (S[1] + 1.0);
 
      // Position on the front slice
      //============================
      double slice_front;
 
      // the points on the up and down edges of the back "rectangular slice"
      ptUp =
        corner_LUF[i] + (corner_RUF[i] - corner_LUF[i]) * 0.5 * (S[0] + 1.0);
      ptDo =
        corner_LDF[i] + (corner_RDF[i] - corner_LDF[i]) * 0.5 * (S[0] + 1.0);
      // position in the rectangular back slice
      slice_front = ptDo + 0.5 * (1.0 + S[1]) * (ptUp - ptDo);
 
      // get the differences to the edges of the middle slice
      diff_L = edge_front_L[i] - slice_front;
      diff_R = edge_front_R[i] - slice_front;
      diff_D = edge_front_D[i] - slice_front;
      diff_U = edge_front_U[i] - slice_front;
 
      // Map it to get the position in the back slice
      slice_front +=
        diff_L * (1.0 - 0.5 * (S[0] + 1.0)) + diff_R * 0.5 * (S[0] + 1.0) +
        diff_D * (1.0 - 0.5 * (S[1] + 1.0)) + diff_U * 0.5 * (S[1] + 1.0);
 
      // Get difference between the back and front slices and the actual
      // boundary
      // ========================================================================
 
      double diff_back = face_B[i] - slice_back;
      double diff_front = face_F[i] - slice_front;
 
      // final map
      //==========
 
      r[i] = slice_mid + 0.5 * (1 + S[2]) * diff_front +
             0.5 * (1 - S[2]) * diff_back;
    }
  }

References oomph::OcTreeNames::B, oomph::OcTreeNames::D, oomph::MacroElement::Domain_pt, oomph::OcTreeNames::F, i, oomph::OcTreeNames::L, oomph::Domain::macro_element_boundary(), oomph::MacroElement::Macro_element_number, UniformPSDSelfTest::r, oomph::OcTreeNames::R, oomph::QuadTreeNames::S, plotPSD::t, oomph::OcTreeNames::U, and Eigen::zeta().

operator=()

void oomph::QMacroElement< 3 >::operator= ( const QMacroElement< 3 > &  )

delete

Broken assignment operator.

output()

void oomph::QMacroElement< 3 >::output ( const unsigned &  t, std::ostream &  outfile, const unsigned &  nplot  )

inlinevirtual

Plot: x,y in tecplot format at time level t (t=0: current; t>0: previous)

Implements oomph::MacroElement.

    {
      Vector<double> x(3), f(3);
 
      outfile << "ZONE I=" << nplot << ", J=" << nplot << ", k=" << nplot
              << std::endl;
      for (unsigned i = 0; i < nplot; i++)
      {
        x[2] = -1.0 + 2.0 * double(i) / double(nplot - 1);
 
        for (unsigned j = 0; j < nplot; j++)
        {
          x[1] = -1.0 + 2.0 * double(j) / double(nplot - 1);
 
          for (unsigned k = 0; k < nplot; k++)
          {
            x[0] = -1.0 + 2.0 * double(k) / double(nplot - 1);
 
            macro_map(t, x, f);
 
            outfile << f[0] << " " << f[1] << " " << f[2] << std::endl;
          }
        }
      }
    }

References f(), i, j, k, oomph::MacroElement::macro_map(), plotPSD::t, and plotDoE::x.

output_macro_element_boundaries()

void oomph::QMacroElement< 3 >::output_macro_element_boundaries ( std::ostream &  outfile, const unsigned &  nplot  )

virtual

Output all macro element boundaries as tecplot zones.

Implements oomph::MacroElement.

  {
    using namespace OcTreeNames;
 
    Vector<double> s(2);
    Vector<double> f(3);
    // Dump at present time
    unsigned t = 0;
    for (unsigned idirect = L; idirect <= F; idirect++)
    {
      outfile << "ZONE I=" << nplot << ", J=" << nplot << std::endl;
      for (unsigned i = 0; i < nplot; i++)
      {
        s[1] = -1.0 + 2.0 * double(i) / double(nplot - 1);
        for (unsigned j = 0; j < nplot; j++)
        {
          s[0] = -1.0 + 2.0 * double(j) / double(nplot - 1);
          Domain_pt->macro_element_boundary(
            t, Macro_element_number, idirect, s, f);
          outfile << f[0] << " " << f[1] << " " << f[2] << std::endl;
        }
      }
    }
  }

References oomph::MacroElement::Domain_pt, f(), oomph::OcTreeNames::F, i, j, L, oomph::Domain::macro_element_boundary(), oomph::MacroElement::Macro_element_number, s, and plotPSD::t.

---

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

• macro_element.h
• macro_element.cc