oomph::QExtrudedMacroElement< 3 > Class Reference

#include <extruded_macro_element.h>

Inheritance diagram for oomph::QExtrudedMacroElement< 3 >:

Public Member Functions
	QExtrudedMacroElement (ExtrudedDomain *domain_pt, const unsigned &macro_element_number)
	QExtrudedMacroElement ()
	Default constructor (empty and broken) More...
	QExtrudedMacroElement (const QExtrudedMacroElement &dummy)=delete
	Broken copy constructor. More...
void	operator= (const QExtrudedMacroElement &)=delete
	Broken assignment operator. More...
virtual	~QExtrudedMacroElement ()
	Empty destructor. More...
void	output (const unsigned &t, std::ostream &outfile, const unsigned &nplot)
	Plot: x,y,t in tecplot format. More...
void	macro_map (const unsigned &t, const Vector< double > &s, Vector< double > &r)
	Get the global position r(s) at the continuous time, t. More...
void	output_macro_element_boundaries (std::ostream &outfile, const unsigned &nplot)
	Output all macro element boundaries as tecplot zones. More...
Public Member Functions inherited from oomph::ExtrudedMacroElement
	ExtrudedMacroElement (ExtrudedDomain *extruded_domain_pt, unsigned macro_element_number)
	ExtrudedMacroElement ()
	Default constructor (empty and broken) More...
	ExtrudedMacroElement (const ExtrudedMacroElement &dummy)=delete
	Broken copy constructor. More...
void	operator= (const ExtrudedMacroElement &)=delete
	Broken assignment operator. More...
virtual	~ExtrudedMacroElement ()
	Empty destructor. More...
ExtrudedDomain *&	extruded_domain_pt ()
	Access function to the ExtrudedDomain. More...
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::ExtrudedMacroElement
ExtrudedDomain *	Extruded_domain_pt
	Pointer to the extruded domain. More...
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

DRAIG: FILL IN COMPLETE DESCRIPTION ONCE FINISHED...

Constructor & Destructor Documentation

QExtrudedMacroElement() [1/3]

oomph::QExtrudedMacroElement< 3 >::QExtrudedMacroElement ( ExtrudedDomain *  domain_pt, const unsigned &  macro_element_number  )

inline

Constructor: Pass the pointer to the domain and the ID number of this extruded macro element

      : MacroElement(0, macro_element_number),
        ExtrudedMacroElement(domain_pt, macro_element_number)
    {
    }

QExtrudedMacroElement() [2/3]

oomph::QExtrudedMacroElement< 3 >::QExtrudedMacroElement ( )

inline

Default constructor (empty and broken)

    {
      // Create an error message
      std::string error =
        "Don't call empty constructor for QExtrudedMacroElement!";
 
      // Throw the error message
      throw OomphLibError(
        error, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
    } // End of QExtrudedMacroElement

References calibrate::error, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, and oomph::Global_string_for_annotation::string().

QExtrudedMacroElement() [3/3]

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

delete

Broken copy constructor.

~QExtrudedMacroElement()

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

inlinevirtual

Empty destructor.

{}

Member Function Documentation

macro_map()

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

virtual

Get the global position r(s) at the continuous time, t.

Get global position r(s) at the continuous time, t.

Implements oomph::MacroElement.

  {
    // Make sure that t=0 otherwise this doesn't make sense
    if (t != 0)
    {
      // Create an output stream
      std::ostringstream error_message_stream;
 
      // Create an error message
      error_message_stream << "This output function outputs a space-time\n"
                           << "representation of the solution. As such, it\n"
                           << "does not make sense to output the solution\n"
                           << "at a previous time level!" << std::endl;
 
      // Throw an error
      throw OomphLibError(error_message_stream.str(),
                          OOMPH_CURRENT_FUNCTION,
                          OOMPH_EXCEPTION_LOCATION);
    }
 
    // Storage for the eight corners
    Vector<double> corner_LDB(3, 0.0);
    Vector<double> corner_RDB(3, 0.0);
    Vector<double> corner_LUB(3, 0.0);
    Vector<double> corner_RUB(3, 0.0);
    Vector<double> corner_LDF(3, 0.0);
    Vector<double> corner_RDF(3, 0.0);
    Vector<double> corner_LUF(3, 0.0);
    Vector<double> corner_RUF(3, 0.0);
 
    // Lagrangian coordinates of a point on a 2D surface in 3D space
    Vector<double> zeta(2, 0.0);
 
    // First coordinate of the bottom-left coordinates of a surface
    zeta[0] = -1.0;
 
    // Second coordinate of the bottom-left coordinates of a surface
    zeta[1] = -1.0;
 
    // Calculate the space-time coordinates of the LDB corner
    Extruded_domain_pt->macro_element_boundary(
      t, Macro_element_number, OcTreeNames::B, zeta, corner_LDB);
 
    // Calculate the space-time coordinates of the LUB corner
    Extruded_domain_pt->macro_element_boundary(
      t, Macro_element_number, OcTreeNames::U, zeta, corner_LUB);
 
    // Calculate the space-time coordinates of the LDF corner
    Extruded_domain_pt->macro_element_boundary(
      t, Macro_element_number, OcTreeNames::F, zeta, corner_LDF);
 
    // Calculate the space-time coordinates of the RDB corner
    Extruded_domain_pt->macro_element_boundary(
      t, Macro_element_number, OcTreeNames::R, zeta, corner_RDB);
 
    // First coordinate of the the top-right coordinates of a surface
    zeta[0] = 1.0;
 
    // Second coordinate of the the top-right coordinates of a surface
    zeta[1] = 1.0;
 
    // Calculate the space-time coordinates of the RUB corner
    Extruded_domain_pt->macro_element_boundary(
      t, Macro_element_number, OcTreeNames::B, zeta, corner_RUB);
 
    // Calculate the space-time coordinates of the RDF corner
    Extruded_domain_pt->macro_element_boundary(
      t, Macro_element_number, OcTreeNames::D, zeta, corner_RDF);
 
    // Calculate the space-time coordinates of the LUF corner
    Extruded_domain_pt->macro_element_boundary(
      t, Macro_element_number, OcTreeNames::L, zeta, corner_LUF);
 
    // Calculate the space-time coordinates of the RUF corner
    Extruded_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, 0.0);
    Vector<double> corner_RD(3, 0.0);
    Vector<double> corner_LU(3, 0.0);
    Vector<double> corner_RU(3, 0.0);
 
    // Set the coordinates of the point on a surface
    zeta[0] = -1.0;
    zeta[1] = s[2];
 
    Extruded_domain_pt->macro_element_boundary(
      t, Macro_element_number, OcTreeNames::D, zeta, corner_LD);
    Extruded_domain_pt->macro_element_boundary(
      t, Macro_element_number, OcTreeNames::U, zeta, corner_LU);
    zeta[0] = 1.0;
    Extruded_domain_pt->macro_element_boundary(
      t, Macro_element_number, OcTreeNames::D, zeta, corner_RD);
    Extruded_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];
    Extruded_domain_pt->macro_element_boundary(
      t, Macro_element_number, OcTreeNames::B, zeta, face_B);
    Extruded_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];
    Extruded_domain_pt->macro_element_boundary(
      t, Macro_element_number, OcTreeNames::U, zeta, edge_mid_U);
 
    Extruded_domain_pt->macro_element_boundary(
      t, Macro_element_number, OcTreeNames::D, zeta, edge_mid_D);
    zeta[0] = s[1];
    zeta[1] = s[2];
    Extruded_domain_pt->macro_element_boundary(
      t, Macro_element_number, OcTreeNames::L, zeta, edge_mid_L);
 
    Extruded_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;
    Extruded_domain_pt->macro_element_boundary(
      t, Macro_element_number, OcTreeNames::U, zeta, edge_back_U);
 
    Extruded_domain_pt->macro_element_boundary(
      t, Macro_element_number, OcTreeNames::D, zeta, edge_back_D);
    zeta[0] = s[1];
    zeta[1] = -1.0;
    Extruded_domain_pt->macro_element_boundary(
      t, Macro_element_number, OcTreeNames::L, zeta, edge_back_L);
 
    Extruded_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;
    Extruded_domain_pt->macro_element_boundary(
      t, Macro_element_number, OcTreeNames::U, zeta, edge_front_U);
 
    Extruded_domain_pt->macro_element_boundary(
      t, Macro_element_number, OcTreeNames::D, zeta, edge_front_D);
    zeta[0] = s[1];
    zeta[1] = 1.0;
    Extruded_domain_pt->macro_element_boundary(
      t, Macro_element_number, OcTreeNames::L, zeta, edge_front_L);
 
    Extruded_domain_pt->macro_element_boundary(
      t, Macro_element_number, OcTreeNames::R, zeta, edge_front_R);
 
    // The number of dimensions (=space+time)
    unsigned n_dim = 3;
 
    // Loop over the coordinate directions
    for (unsigned i = 0; i < n_dim; i++)
    {
      //-----------------------------
      // Position on the middle slice
      //-----------------------------
      double slice_mid;
 
      // The points on the up and down edges of the middle "rectangular slice"
      double point_up = 0.0;
      double point_down = 0.0;
 
      // Calculate the point on the upper edge
      point_up =
        corner_LU[i] + (corner_RU[i] - corner_LU[i]) * 0.5 * (s[0] + 1.0);
 
      // Calculate the point on the lower edge
      point_down =
        corner_LD[i] + (corner_RD[i] - corner_LD[i]) * 0.5 * (s[0] + 1.0);
 
      // Position in the rectangular middle slice
      slice_mid = point_down + 0.5 * (1.0 + s[1]) * (point_up - point_down);
 
      // 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;
 
      // Calculate the point on the upper edge of the back "rectangular slice"
      point_up =
        corner_LUB[i] + (corner_RUB[i] - corner_LUB[i]) * 0.5 * (s[0] + 1.0);
 
      // Calculate the point on the lower edge of the back "rectangular slice"
      point_down =
        corner_LDB[i] + (corner_RDB[i] - corner_LDB[i]) * 0.5 * (s[0] + 1.0);
 
      // Position in the rectangular back slice
      slice_back = point_down + 0.5 * (1.0 + s[1]) * (point_up - point_down);
 
      // 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;
 
      // Calculate the point on the upper edge of the back "rectangular slice"
      point_up =
        corner_LUF[i] + (corner_RUF[i] - corner_LUF[i]) * 0.5 * (s[0] + 1.0);
 
      // Calculate the point on the lower edge of the back "rectangular slice"
      point_down =
        corner_LDF[i] + (corner_RDF[i] - corner_LDF[i]) * 0.5 * (s[0] + 1.0);
 
      // Position in the rectangular back slice
      slice_front = point_down + 0.5 * (1.0 + s[1]) * (point_up - point_down);
 
      // 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.0 + s[2]) * diff_front +
             0.5 * (1.0 - s[2]) * diff_back;
    }
  } // End of macro_map

References oomph::OcTreeNames::B, oomph::OcTreeNames::D, oomph::ExtrudedMacroElement::Extruded_domain_pt, oomph::OcTreeNames::F, i, oomph::OcTreeNames::L, oomph::ExtrudedDomain::macro_element_boundary(), oomph::MacroElement::Macro_element_number, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, UniformPSDSelfTest::r, oomph::OcTreeNames::R, s, plotPSD::t, oomph::OcTreeNames::U, and Eigen::zeta().

operator=()

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

delete

Broken assignment operator.

output()

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

inlinevirtual

Plot: x,y,t in tecplot format.

Implements oomph::MacroElement.

    {
      // Make sure that t=0 otherwise this doesn't make sense
      if (t != 0)
      {
        // Create an output stream
        std::ostringstream error_message_stream;
 
        // Create an error message
        error_message_stream << "This output function outputs a space-time\n"
                             << "representation of the solution. As such, it\n"
                             << "does not make sense to output the solution\n"
                             << "at a previous time level!" << std::endl;
 
        // Throw an error
        throw OomphLibError(error_message_stream.str(),
                            OOMPH_CURRENT_FUNCTION,
                            OOMPH_EXCEPTION_LOCATION);
      }
 
      // Storage for the local (space-time) coordinates
      Vector<double> s(3, 0.0);
 
      // Storage for the global (space-time) coordinates
      Vector<double> x(3, 0.0);
 
      // Output the header
      outfile << "ZONE I=" << nplot << ", J=" << nplot << ", K=" << nplot
              << std::endl;
 
      // Loop over the plot points in the t-direction
      for (unsigned i = 0; i < nplot; i++)
      {
        // Calculate the time value
        // s[2]=-1.0+2.0*double(i)/double(nplot-1);
        s[2] = -1.0 + 2.0 * double(i) / double(nplot - 1);
 
        // Loop over the plot points in the y-direction
        for (unsigned j = 0; j < nplot; j++)
        {
          // Calculate the y value
          s[1] = -1.0 + 2.0 * double(j) / double(nplot - 1);
 
          // Loop over the plot points in the x-direction
          for (unsigned k = 0; k < nplot; k++)
          {
            // Calculate the x value
            s[0] = -1.0 + 2.0 * double(k) / double(nplot - 1);
 
            // Get the corresponding global space-time coordinates.
            // NOTE: Calling the macro_map function from the base class requires
            // the time level. To make the call function normally, we simply
            // pass the argument t=0 and the appropriate function will be
            // called.
            macro_map(t, s, x);
 
            // Output the global coordinates
            outfile << x[0] << " " << x[1] << " " << x[2] << " " << 0.0
                    << std::endl;
          }
        } // for (unsigned j=0;j<nplot;j++)
      } // for (unsigned i=0;i<nplot;i++)
    } // End of output

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

output_macro_element_boundaries()

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

virtual

Output all macro element boundaries as tecplot zones.

Implements oomph::MacroElement.

  {
    // Use the OcTree enumeration for corners, edges and faces
    using namespace OcTreeNames;
 
    // Storage for the local coordinates (of a point on a face)
    Vector<double> s(2);
 
    // Storage for the global coordinates
    Vector<double> x(3);
 
    // Loop over the faces
    for (unsigned idirect = L; idirect <= F; idirect++)
    {
      // Output the header
      outfile << "ZONE I=" << nplot << ", J=" << nplot << std::endl;
 
      // Loop over the plot points in the second surface direction
      for (unsigned i = 0; i < nplot; i++)
      {
        // Calculate the second local coordinate associated with this plot point
        s[1] = -1.0 + 2.0 * double(i) / double(nplot - 1);
 
        // Loop over the plot points in the first surface direction
        for (unsigned j = 0; j < nplot; j++)
        {
          // Calculate the first local coordinate associated with this plot
          // point
          s[0] = -1.0 + 2.0 * double(j) / double(nplot - 1);
 
          // To make the extrusion machinery consistent with the Domain
          // machinery a time level argument has to be provided. For our
          // purposes we set this to zero to ensure that the appropriate output
          // is provided.
          unsigned t = 0;
 
          // Get the global coordinates associated with these local coordinates
          Extruded_domain_pt->macro_element_boundary(
            t, Macro_element_number, idirect, s, x);
 
          // Output the global (space-time) coordinates
          outfile << x[0] << " " << x[1] << " " << x[2] << std::endl;
        }
      } // for (unsigned i=0;i<nplot;i++)
    } // for (unsigned idirect=L;idirect<=F;idirect++)
  } // End of output_macro_element_boundaries

References oomph::ExtrudedMacroElement::Extruded_domain_pt, oomph::OcTreeNames::F, i, j, L, oomph::ExtrudedDomain::macro_element_boundary(), oomph::MacroElement::Macro_element_number, s, plotPSD::t, and plotDoE::x.

---

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

• extruded_macro_element.h
• extruded_macro_element.cc