oomph::TopologicallyRectangularDomain Class Reference

#include <topologically_rectangular_domain.h>

Inheritance diagram for oomph::TopologicallyRectangularDomain:

Public Types
typedef void(*	BoundaryFctPt) (const double &s, Vector< double > &r)

Public Member Functions
	TopologicallyRectangularDomain (BoundaryFctPt north_pt, BoundaryFctPt east_pt, BoundaryFctPt south_pt, BoundaryFctPt west_pt)
	TopologicallyRectangularDomain (const double &l_x, const double &l_y)
	TopologicallyRectangularDomain (const double &x_min, const double &x_max, const double &y_min, const double &y_max)
	TopologicallyRectangularDomain (const TopologicallyRectangularDomain &)=delete
	Broken copy constructor. More...
void	operator= (const TopologicallyRectangularDomain &)=delete
	Broken assignment operator. More...
	~TopologicallyRectangularDomain ()
	Destructor - empty; clean up done in base class. More...
void	set_boundary_derivative_functions (BoundaryFctPt d_north_pt, BoundaryFctPt d_east_pt, BoundaryFctPt d_south_pt, BoundaryFctPt d_west_pt)
void	set_boundary_second_derivative_functions (BoundaryFctPt d2_north_pt, BoundaryFctPt d2_east_pt, BoundaryFctPt d2_south_pt, BoundaryFctPt d2_west_pt)
void	macro_element_boundary (const unsigned &t, const unsigned &i_macro, const unsigned &i_direct, const Vector< double > &s, Vector< double > &f)
void	dmacro_element_boundary (const unsigned &t, const unsigned &i_macro, const unsigned &i_direct, const Vector< double > &s, Vector< double > &f)
void	d2macro_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 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 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	r_N (const Vector< double > &s, Vector< double > &f)
void	r_E (const Vector< double > &s, Vector< double > &f)
void	r_S (const Vector< double > &s, Vector< double > &f)
void	r_W (const Vector< double > &s, Vector< double > &f)
void	dr_N (const Vector< double > &s, Vector< double > &dr)
void	dr_E (const Vector< double > &s, Vector< double > &dr)
void	dr_S (const Vector< double > &s, Vector< double > &dr)
void	dr_W (const Vector< double > &s, Vector< double > &dr)
void	d2r_N (const Vector< double > &s, Vector< double > &d2r)
void	d2r_E (const Vector< double > &s, Vector< double > &d2r)
void	d2r_S (const Vector< double > &s, Vector< double > &d2r)
void	d2r_W (const Vector< double > &s, Vector< double > &d2r)

Private Attributes
BoundaryFctPt	North_boundary_fn_pt
BoundaryFctPt	East_boundary_fn_pt
BoundaryFctPt	South_boundary_fn_pt
BoundaryFctPt	West_boundary_fn_pt
BoundaryFctPt	dNorth_boundary_fn_pt
BoundaryFctPt	dEast_boundary_fn_pt
BoundaryFctPt	dSouth_boundary_fn_pt
BoundaryFctPt	dWest_boundary_fn_pt
BoundaryFctPt	d2North_boundary_fn_pt
BoundaryFctPt	d2East_boundary_fn_pt
BoundaryFctPt	d2South_boundary_fn_pt
BoundaryFctPt	d2West_boundary_fn_pt
Vector< double >	x_south_west
Vector< double >	x_north_east

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

Detailed Description

Topologically Rectangular Domain - a domain dexcribing a topologically rectangular problem - primarily contains functions to access the position of the global boundary relative to the macro element boundary, as well as first and second derivates of the global boundary wrt the macro element boundary NOTE : suitable for HermiteElementQuadMesh

Member Typedef Documentation

BoundaryFctPt

typedef void(* oomph::TopologicallyRectangularDomain::BoundaryFctPt) (const double &s, Vector< double > &r)

boundary function pointer - for a given boundary takes the macro element coordinate position on that boundary and for that position returns the global coordinates (x) coordinates, or derivatives - dx_i/dm_t or second derivatives d2x_i/dm_t^2

Constructor & Destructor Documentation

TopologicallyRectangularDomain() [1/4]

oomph::TopologicallyRectangularDomain::TopologicallyRectangularDomain	(	BoundaryFctPt	north_pt,
		BoundaryFctPt	east_pt,
		BoundaryFctPt	south_pt,
		BoundaryFctPt	west_pt
	)

Constructor - domain boundaries are described with four boundary function pointers describing the topology of the north, east, south, and west boundaries

  {
    // domain comprises one macro element
    Macro_element_pt.resize(1);
 
    // Create the macro element
    Macro_element_pt[0] = new QMacroElement<2>(this, 0);
 
    // set boundary function pointers
    North_boundary_fn_pt = north_pt;
    East_boundary_fn_pt = east_pt;
    South_boundary_fn_pt = south_pt;
    West_boundary_fn_pt = west_pt;
 
    // by default derivative boundary function pointers are null
    dNorth_boundary_fn_pt = 0;
    dEast_boundary_fn_pt = 0;
    dSouth_boundary_fn_pt = 0;
    dWest_boundary_fn_pt = 0;
 
    // also by default second derivate boundary function pointers are null
    d2North_boundary_fn_pt = 0;
    d2East_boundary_fn_pt = 0;
    d2South_boundary_fn_pt = 0;
    d2West_boundary_fn_pt = 0;
 
    // paranoid self check to ensure that ends of boundaries meet
#ifdef PARANOID
    // error message stream
    std::ostringstream error_message;
    bool error_flag = false;
    // check NE corner
    {
      Vector<double> x_N(2);
      (*North_boundary_fn_pt)(1.0, x_N);
      Vector<double> x_E(2);
      (*East_boundary_fn_pt)(1.0, x_E);
      if (x_N[0] != x_E[0] || x_N[1] != x_E[1])
      {
        error_message << "North and East Boundaries do not meet at the "
                      << "North East Corner.\n"
                      << "North Boundary : x[0] = " << x_N[0] << "\n"
                      << "                 x[1] = " << x_N[1] << "\n"
                      << "East Boundary : x[0] = " << x_E[0] << "\n"
                      << "                x[1] = " << x_E[1] << "\n\n";
        error_flag = true;
      }
    }
    // check SE corner
    {
      Vector<double> x_S(2);
      (*South_boundary_fn_pt)(1.0, x_S);
      Vector<double> x_E(2);
      (*East_boundary_fn_pt)(-1.0, x_E);
      if (x_S[0] != x_E[0] || x_S[1] != x_E[1])
      {
        error_message << "South and East Boundaries do not meet at the "
                      << "South East Corner.\n"
                      << "South Boundary : x[0] = " << x_S[0] << "\n"
                      << "                 x[1] = " << x_S[1] << "\n"
                      << "East Boundary : x[0] = " << x_E[0] << "\n"
                      << "                x[1] = " << x_E[1] << "\n\n";
        error_flag = true;
      }
    }
    // check SW corner
    {
      Vector<double> x_S(2);
      (*South_boundary_fn_pt)(-1.0, x_S);
      Vector<double> x_W(2);
      (*West_boundary_fn_pt)(-1.0, x_W);
      if (x_S[0] != x_W[0] || x_S[1] != x_W[1])
      {
        error_message << "South and West Boundaries do not meet at the "
                      << "South West Corner.\n"
                      << "South Boundary : x[0] = " << x_S[0] << "\n"
                      << "                 x[1] = " << x_S[1] << "\n"
                      << "West Boundary : x[0] = " << x_W[0] << "\n"
                      << "                x[1] = " << x_W[1] << "\n\n";
        error_flag = true;
      }
    }
    // check NW corner
    {
      Vector<double> x_N(2);
      (*North_boundary_fn_pt)(-1.0, x_N);
      Vector<double> x_W(2);
      (*West_boundary_fn_pt)(1.0, x_W);
      if (x_N[0] != x_W[0] || x_N[1] != x_W[1])
      {
        error_message << "North and West Boundaries do not meet at the "
                      << "North West Corner.\n"
                      << "North Boundary : x[0] = " << x_N[0] << "\n"
                      << "                 x[1] = " << x_N[1] << "\n"
                      << "West Boundary : x[0] = " << x_W[0] << "\n"
                      << "                x[1] = " << x_W[1] << "\n\n";
        error_flag = true;
      }
    }
    if (error_flag)
    {
      throw OomphLibError(
        error_message.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
    }
#endif
  }

References d2East_boundary_fn_pt, d2North_boundary_fn_pt, d2South_boundary_fn_pt, d2West_boundary_fn_pt, dEast_boundary_fn_pt, dNorth_boundary_fn_pt, dSouth_boundary_fn_pt, dWest_boundary_fn_pt, East_boundary_fn_pt, oomph::Domain::Macro_element_pt, North_boundary_fn_pt, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, South_boundary_fn_pt, and West_boundary_fn_pt.

TopologicallyRectangularDomain() [2/4]

oomph::TopologicallyRectangularDomain::TopologicallyRectangularDomain	(	const double &	l_x,
		const double &	l_y
	)

Constructor - takes length of domain in x and y direction as arguements. Assumes domain is rectangular, and the south west (lower left) corner is at 0,0.

  {
    // domain comprises one macro element
    Macro_element_pt.resize(1);
 
    // Create the macro element
    Macro_element_pt[0] = new QMacroElement<2>(this, 0);
 
    // set the boundary function pointers to zero
    North_boundary_fn_pt = 0;
    East_boundary_fn_pt = 0;
    South_boundary_fn_pt = 0;
    West_boundary_fn_pt = 0;
 
    // resize x vectors
    x_south_west.resize(2);
    x_north_east.resize(2);
 
    // set south west corner to 0,0
    x_south_west[0] = 0.0;
    x_south_west[1] = 0.0;
 
    // set north east corner
    x_north_east[0] = l_x;
    x_north_east[1] = l_y;
 
    // by default derivative boundary function pointers are null
    dNorth_boundary_fn_pt = 0;
    dEast_boundary_fn_pt = 0;
    dSouth_boundary_fn_pt = 0;
    dWest_boundary_fn_pt = 0;
 
    // also by default second derivate boundary function pointers are null
    d2North_boundary_fn_pt = 0;
    d2East_boundary_fn_pt = 0;
    d2South_boundary_fn_pt = 0;
    d2West_boundary_fn_pt = 0;
  }

References d2East_boundary_fn_pt, d2North_boundary_fn_pt, d2South_boundary_fn_pt, d2West_boundary_fn_pt, dEast_boundary_fn_pt, dNorth_boundary_fn_pt, dSouth_boundary_fn_pt, dWest_boundary_fn_pt, East_boundary_fn_pt, oomph::Domain::Macro_element_pt, North_boundary_fn_pt, South_boundary_fn_pt, West_boundary_fn_pt, x_north_east, and x_south_west.

TopologicallyRectangularDomain() [3/4]

oomph::TopologicallyRectangularDomain::TopologicallyRectangularDomain	(	const double &	x_min,
		const double &	x_max,
		const double &	y_min,
		const double &	y_max
	)

Constructor - takes the minimum and maximum coordinates of the of an assumed rectanguler domain in the x and y direction

  {
    // domain comprises one macro element
    Macro_element_pt.resize(1);
 
    // Create the macro element
    Macro_element_pt[0] = new QMacroElement<2>(this, 0);
 
    // set the boundary function pointers to zero
    North_boundary_fn_pt = 0;
    East_boundary_fn_pt = 0;
    South_boundary_fn_pt = 0;
    West_boundary_fn_pt = 0;
 
    // resize x vectors
    x_south_west.resize(2);
    x_north_east.resize(2);
 
    // set vector values
    x_south_west[0] = x_min;
    x_south_west[1] = y_min;
    x_north_east[0] = x_max;
    x_north_east[1] = y_max;
 
    // by default derivative boundary function pointers are null
    dNorth_boundary_fn_pt = 0;
    dEast_boundary_fn_pt = 0;
    dSouth_boundary_fn_pt = 0;
    dWest_boundary_fn_pt = 0;
 
    // also by default second derivate boundary function pointers are null
    d2North_boundary_fn_pt = 0;
    d2East_boundary_fn_pt = 0;
    d2South_boundary_fn_pt = 0;
    d2West_boundary_fn_pt = 0;
  }

References d2East_boundary_fn_pt, d2North_boundary_fn_pt, d2South_boundary_fn_pt, d2West_boundary_fn_pt, dEast_boundary_fn_pt, dNorth_boundary_fn_pt, dSouth_boundary_fn_pt, dWest_boundary_fn_pt, East_boundary_fn_pt, oomph::Domain::Macro_element_pt, North_boundary_fn_pt, South_boundary_fn_pt, West_boundary_fn_pt, x_north_east, and x_south_west.

TopologicallyRectangularDomain() [4/4]

oomph::TopologicallyRectangularDomain::TopologicallyRectangularDomain ( const TopologicallyRectangularDomain &  )

delete

Broken copy constructor.

~TopologicallyRectangularDomain()

oomph::TopologicallyRectangularDomain::~TopologicallyRectangularDomain ( )

inline

Destructor - empty; clean up done in base class.

{}

Member Function Documentation

d2macro_element_boundary()

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

virtual

returns the second derivates of the global coordinate position (f) wrt to the macro element coordinate at macro macro element position s on boundary i_direct (e.g. N/S/W/E in 2D) at time t (no time dependence)

Reimplemented from oomph::Domain.

  {
    // use quad tree edge names to label edge of domain
    using namespace QuadTreeNames;
 
 
#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",
      "TopologicallyRectangularDomain::d2macro_element_boundary(...)",
      OOMPH_EXCEPTION_LOCATION);
#endif
 
    // north boundary
    if (i_direct == N) d2r_N(s, f);
    // east boundary
    else if (i_direct == E)
      d2r_E(s, f);
    // south boundary
    else if (i_direct == S)
      d2r_S(s, f);
    // west boundary
    else if (i_direct == W)
      d2r_W(s, f);
  }

References d2r_E(), d2r_N(), d2r_S(), d2r_W(), Global_Physical_Variables::E, f(), N, OOMPH_EXCEPTION_LOCATION, s, oomph::QuadTreeNames::S, and oomph::QuadTreeNames::W.

d2r_E()

void oomph::TopologicallyRectangularDomain::d2r_E ( const Vector< double > &  s, Vector< double > &  d2r  )

private

takes the macro element coordinate position along the east boundary and returns the second derivates of the global coordinates with respect to the boundary

  {
    // if E boundary fn provided
    if (East_boundary_fn_pt != 0)
    {
      // if d2E boundary fn provided
      if (d2East_boundary_fn_pt != 0)
      {
        (*d2East_boundary_fn_pt)(s[0], d2r);
      }
      // else compute by finite differencing
      else
      {
        // if dE boundary fn provided finite difference d2E from it
        if (dEast_boundary_fn_pt != 0)
        {
          const double h = 10e-8;
          Vector<double> dx_E_lower(2);
          (*dEast_boundary_fn_pt)(s[0] - 0.5 * h, dx_E_lower);
          Vector<double> dx_E_upper(2);
          (*dEast_boundary_fn_pt)(s[0] + 0.5 * h, dx_E_upper);
          d2r[0] = (dx_E_upper[0] - dx_E_lower[0]) / h;
          d2r[1] = (dx_E_upper[1] - dx_E_lower[1]) / h;
        }
        // else finite difference from E boundary fn
        else
        {
          const double h = 10e-8;
          Vector<double> E_left(2);
          (*East_boundary_fn_pt)(s[0] - h, E_left);
          Vector<double> E_right(2);
          (*East_boundary_fn_pt)(s[0] + h, E_right);
          Vector<double> E_centre(2);
          (*East_boundary_fn_pt)(s[0], E_centre);
          d2r[0] = (E_right[0] + E_left[0] - 2 * E_centre[0]) / (h * h);
          d2r[1] = (E_right[1] + E_left[1] - 2 * E_centre[1]) / (h * h);
        }
      }
    }
    // if E boundary fn not provided then mesh is rectangular
    else
    {
      d2r[0] = 0;
      d2r[1] = 0;
    }
  }

References d2East_boundary_fn_pt, dEast_boundary_fn_pt, e(), East_boundary_fn_pt, and s.

Referenced by d2macro_element_boundary().

d2r_N()

void oomph::TopologicallyRectangularDomain::d2r_N ( const Vector< double > &  s, Vector< double > &  d2r  )

private

takes the macro element coordinate position along the north boundary and returns the second derivates of the global coordinates with respect to the boundary

  {
    // if N boundary fn provided
    if (North_boundary_fn_pt != 0)
    {
      // if d2N boundary fn provided
      if (d2North_boundary_fn_pt != 0)
      {
        (*d2North_boundary_fn_pt)(s[0], d2r);
      }
      // else compute by finite differencing
      else
      {
        // if dN boundary fn provided finite difference d2N from it
        if (dNorth_boundary_fn_pt != 0)
        {
          const double h = 10e-8;
          Vector<double> dx_N_left(2);
          (*dNorth_boundary_fn_pt)(s[0] - 0.5 * h, dx_N_left);
          Vector<double> dx_N_right(2);
          (*dNorth_boundary_fn_pt)(s[0] + 0.5 * h, dx_N_right);
          d2r[0] = (dx_N_right[0] - dx_N_left[0]) / h;
          d2r[1] = (dx_N_right[1] - dx_N_left[1]) / h;
        }
        // else finite difference from N boundary fn
        else
        {
          const double h = 10e-8;
          Vector<double> N_left(2);
          (*North_boundary_fn_pt)(s[0] - h, N_left);
          Vector<double> N_right(2);
          (*North_boundary_fn_pt)(s[0] + h, N_right);
          Vector<double> N_centre(2);
          (*North_boundary_fn_pt)(s[0], N_centre);
          d2r[0] = (N_right[0] + N_left[0] - 2 * N_centre[0]) / (h * h);
          d2r[1] = (N_right[1] + N_left[1] - 2 * N_centre[1]) / (h * h);
        }
      }
    }
    // if N boundary fn not provided then mesh is rectangular
    else
    {
      d2r[0] = 0;
      d2r[1] = 0;
    }
  }

References d2North_boundary_fn_pt, dNorth_boundary_fn_pt, e(), North_boundary_fn_pt, and s.

Referenced by d2macro_element_boundary().

d2r_S()

void oomph::TopologicallyRectangularDomain::d2r_S ( const Vector< double > &  s, Vector< double > &  d2r  )

private

takes the macro element coordinate position along the south boundary and returns the second derivates of the global coordinates with respect to the boundary

  {
    // if S boundary fn provided
    if (South_boundary_fn_pt != 0)
    {
      // if d2S boundary fn provided
      if (d2South_boundary_fn_pt != 0)
      {
        (*d2South_boundary_fn_pt)(s[0], d2r);
      }
      // else compute by finite differencing
      else
      {
        // if dS boundary fn provided finite difference d2S from it
        if (dSouth_boundary_fn_pt != 0)
        {
          const double h = 10e-8;
          Vector<double> dx_S_left(2);
          (*dSouth_boundary_fn_pt)(s[0] - 0.5 * h, dx_S_left);
          Vector<double> dx_S_right(2);
          (*dSouth_boundary_fn_pt)(s[0] + 0.5 * h, dx_S_right);
          d2r[0] = (dx_S_right[0] - dx_S_left[0]) / h;
          d2r[1] = (dx_S_right[1] - dx_S_left[1]) / h;
        }
        // else finite difference from S boundary fn
        else
        {
          const double h = 10e-8;
          Vector<double> S_left(2);
          (*South_boundary_fn_pt)(s[0] - h, S_left);
          Vector<double> S_right(2);
          (*South_boundary_fn_pt)(s[0] + h, S_right);
          Vector<double> S_centre(2);
          (*South_boundary_fn_pt)(s[0], S_centre);
          d2r[0] = (S_right[0] + S_left[0] - 2 * S_centre[0]) / (h * h);
          d2r[1] = (S_right[1] + S_left[1] - 2 * S_centre[1]) / (h * h);
        }
      }
    }
    // if S boundary fn not provided then mesh is rectangular
    else
    {
      d2r[0] = 0;
      d2r[1] = 0;
    }
  }

References d2South_boundary_fn_pt, dSouth_boundary_fn_pt, e(), s, and South_boundary_fn_pt.

Referenced by d2macro_element_boundary().

d2r_W()

void oomph::TopologicallyRectangularDomain::d2r_W ( const Vector< double > &  s, Vector< double > &  d2r  )

private

takes the macro element coordinate position along the west boundary and returns the second derivates of the global coordinates with respect to the boundary

  {
    // if W boundary fn provided
    if (West_boundary_fn_pt != 0)
    {
      // if d2W boundary fn provided
      if (d2West_boundary_fn_pt != 0)
      {
        (*d2West_boundary_fn_pt)(s[0], d2r);
      }
      // else compute by finite differencing
      else
      {
        // if dW boundary fn provided finite difference d2W from it
        if (dWest_boundary_fn_pt != 0)
        {
          const double h = 10e-8;
          Vector<double> dx_W_lower(2);
          (*dWest_boundary_fn_pt)(s[0] - 0.5 * h, dx_W_lower);
          Vector<double> dx_W_upper(2);
          (*dWest_boundary_fn_pt)(s[0] + 0.5 * h, dx_W_upper);
          d2r[0] = (dx_W_upper[0] - dx_W_lower[0]) / h;
          d2r[1] = (dx_W_upper[1] - dx_W_lower[1]) / h;
        }
        // else finite difference from W boundary fn
        else
        {
          const double h = 10e-8;
          Vector<double> W_left(2);
          (*West_boundary_fn_pt)(s[0] - h, W_left);
          Vector<double> W_right(2);
          (*West_boundary_fn_pt)(s[0] + h, W_right);
          Vector<double> W_centre(2);
          (*West_boundary_fn_pt)(s[0], W_centre);
          d2r[0] = (W_right[0] + W_left[0] - 2 * W_centre[0]) / (h * h);
          d2r[1] = (W_right[1] + W_left[1] - 2 * W_centre[1]) / (h * h);
        }
      }
    }
    // if W boundary fn not provided then mesh is rectangular
    else
    {
      d2r[0] = 0;
      d2r[1] = 0;
    }
  }

References d2West_boundary_fn_pt, dWest_boundary_fn_pt, e(), s, and West_boundary_fn_pt.

Referenced by d2macro_element_boundary().

dmacro_element_boundary()

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

virtual

returns the derivates of the global coordinate position (f) wrt to the macro element coordinate at macro macro element position s on boundary i_direct (e.g. N/S/W/E in 2D) at time t (no time dependence)

Reimplemented from oomph::Domain.

  {
    // use quad tree edge names to label edge of domain
    using namespace QuadTreeNames;
 
#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",
      "TopologicallyRectangularDomain::dmacro_element_boundary(...)",
      OOMPH_EXCEPTION_LOCATION);
#endif
 
    // north boundary
    if (i_direct == N) dr_N(s, f);
    // east boundary
    else if (i_direct == E)
      dr_E(s, f);
    // south boundary
    else if (i_direct == S)
      dr_S(s, f);
    // west boundary
    else if (i_direct == W)
      dr_W(s, f);
  }

References dr_E(), dr_N(), dr_S(), dr_W(), Global_Physical_Variables::E, f(), N, OOMPH_EXCEPTION_LOCATION, s, oomph::QuadTreeNames::S, and oomph::QuadTreeNames::W.

dr_E()

void oomph::TopologicallyRectangularDomain::dr_E ( const Vector< double > &  s, Vector< double > &  dr  )

private

takes the macro element coordinate position along the E boundary and returns the derivates of the global coordinates with respect to the boundary

  {
    // if E boundary fn provided
    if (East_boundary_fn_pt != 0)
    {
      // if dE boundary fn provided
      if (dEast_boundary_fn_pt != 0)
      {
        (*dEast_boundary_fn_pt)(s[0], dr);
      }
      // else compute by finite differencing
      else
      {
        const double h = 10e-8;
        Vector<double> x_E_down(2);
        (*East_boundary_fn_pt)(s[0] - 0.5 * h, x_E_down);
        Vector<double> x_E_up(2);
        (*East_boundary_fn_pt)(s[0] + 0.5 * h, x_E_up);
        dr[0] = (x_E_up[0] - x_E_down[0]) / h;
        dr[1] = (x_E_up[1] - x_E_down[1]) / h;
      }
    }
    // if E boundary fn not provided then mesh is rectangular
    else
    {
      dr[0] = 0;
      dr[1] = (x_north_east[1] - x_south_west[1]) / 2;
    }
  }

References dEast_boundary_fn_pt, e(), East_boundary_fn_pt, s, x_north_east, and x_south_west.

Referenced by dmacro_element_boundary().

dr_N()

void oomph::TopologicallyRectangularDomain::dr_N ( const Vector< double > &  s, Vector< double > &  dr  )

private

takes the macro element coordinate position along the north boundary and returns the derivates of the global coordinates with respect to the boundary

  {
    // if N boundary fn provided
    if (North_boundary_fn_pt != 0)
    {
      // if dN boundary fn provided
      if (dNorth_boundary_fn_pt != 0)
      {
        (*dNorth_boundary_fn_pt)(s[0], dr);
      }
      // else compute by finite differencing
      else
      {
        const double h = 10e-8;
        Vector<double> x_N_left(2);
        (*North_boundary_fn_pt)(s[0] - 0.5 * h, x_N_left);
        Vector<double> x_N_right(2);
        (*North_boundary_fn_pt)(s[0] + 0.5 * h, x_N_right);
        dr[0] = (x_N_right[0] - x_N_left[0]) / h;
        dr[1] = (x_N_right[1] - x_N_left[1]) / h;
      }
    }
    // if N boundary fn not provided then mesh is rectangular
    else
    {
      dr[0] = (x_north_east[0] - x_south_west[0]) / 2;
      dr[1] = 0;
    }
  }

References dNorth_boundary_fn_pt, e(), North_boundary_fn_pt, s, x_north_east, and x_south_west.

Referenced by dmacro_element_boundary().

dr_S()

void oomph::TopologicallyRectangularDomain::dr_S ( const Vector< double > &  s, Vector< double > &  dr  )

private

takes the macro element coordinate position along the south boundary and returns the derivates of the global coordinates with respect to the boundary

  {
    // if S boundary fn provided
    if (South_boundary_fn_pt != 0)
    {
      // if dS boundary fn provided
      if (dSouth_boundary_fn_pt != 0)
      {
        (*dSouth_boundary_fn_pt)(s[0], dr);
      }
      // else compute by finite differencing
      else
      {
        const double h = 10e-8;
        Vector<double> x_N_left(2);
        (*South_boundary_fn_pt)(s[0] - 0.5 * h, x_N_left);
        Vector<double> x_N_right(2);
        (*South_boundary_fn_pt)(s[0] + 0.5 * h, x_N_right);
        dr[0] = (x_N_right[0] - x_N_left[0]) / h;
        dr[1] = (x_N_right[1] - x_N_left[1]) / h;
      }
    }
    // if S boundary fn not provided then mesh is rectangular
    else
    {
      dr[0] = (x_north_east[0] - x_south_west[0]) / 2;
      dr[1] = 0;
    }
  }

References dSouth_boundary_fn_pt, e(), s, South_boundary_fn_pt, x_north_east, and x_south_west.

Referenced by dmacro_element_boundary().

dr_W()

void oomph::TopologicallyRectangularDomain::dr_W ( const Vector< double > &  s, Vector< double > &  dr  )

private

takes the macro element coordinate position along the W boundary and returns the derivates of the global coordinates with respect to the boundary

  {
    // if W boundary fn provided
    if (West_boundary_fn_pt != 0)
    {
      // if dW boundary fn provided
      if (dWest_boundary_fn_pt != 0)
      {
        (*dWest_boundary_fn_pt)(s[0], dr);
      }
      // else compute by finite differencing
      else
      {
        const double h = 10e-8;
        Vector<double> x_W_down(2);
        (*West_boundary_fn_pt)(s[0] - 0.5 * h, x_W_down);
        Vector<double> x_W_up(2);
        (*West_boundary_fn_pt)(s[0] + 0.5 * h, x_W_up);
        dr[0] = (x_W_up[0] - x_W_down[0]) / h;
        dr[1] = (x_W_up[1] - x_W_down[1]) / h;
      }
    }
    // if E boundary fn not provided then mesh is rectangular
    else
    {
      dr[0] = 0;
      dr[1] = (x_north_east[1] - x_south_west[1]) / 2;
    }
  }

References dWest_boundary_fn_pt, e(), s, West_boundary_fn_pt, x_north_east, and x_south_west.

Referenced by dmacro_element_boundary().

macro_element_boundary()

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

virtual

returns the global coordinate position (f) of macro element position s on boundary i_direct (e.g. N/S/W/E in 2D) at time t (no time dependence)

Implements oomph::Domain.

  {
    // use quad tree edge names to label edge of domain
    using namespace QuadTreeNames;
 
#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",
      "TopologicallyRectangularDomain::macro_element_boundary(...)",
      OOMPH_EXCEPTION_LOCATION);
#endif
 
    // north boundary
    if (i_direct == N) r_N(s, f);
    // east boundary
    else if (i_direct == E)
      r_E(s, f);
    // south boundary
    else if (i_direct == S)
      r_S(s, f);
    // west boundary
    else if (i_direct == W)
      r_W(s, f);
  }

References Global_Physical_Variables::E, f(), N, OOMPH_EXCEPTION_LOCATION, r_E(), r_N(), r_S(), r_W(), s, oomph::QuadTreeNames::S, and oomph::QuadTreeNames::W.

operator=()

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

delete

Broken assignment operator.

r_E()

void oomph::TopologicallyRectangularDomain::r_E ( const Vector< double > &  s, Vector< double > &  f  )

private

takes the macro element coordinate position along the east boundary and returns the global coordinate position along that boundary

  {
    if (East_boundary_fn_pt != 0)
    {
      (*East_boundary_fn_pt)(s[0], f);
    }
    else
    {
      f[0] = x_north_east[0];
      f[1] =
        x_south_west[1] + (s[0] + 1) / 2 * (x_north_east[1] - x_south_west[1]);
    }
  }

References East_boundary_fn_pt, f(), s, x_north_east, and x_south_west.

Referenced by macro_element_boundary().

r_N()

void oomph::TopologicallyRectangularDomain::r_N ( const Vector< double > &  s, Vector< double > &  f  )

private

takes the macro element coordinate position along the north boundary and returns the global coordinate position along that boundary

  {
    if (North_boundary_fn_pt != 0)
    {
      (*North_boundary_fn_pt)(s[0], f);
    }
    else
    {
      f[0] =
        x_south_west[0] + (s[0] + 1) / 2 * (x_north_east[0] - x_south_west[0]);
      f[1] = x_north_east[1];
    }
  }

References f(), North_boundary_fn_pt, s, x_north_east, and x_south_west.

Referenced by macro_element_boundary().

r_S()

void oomph::TopologicallyRectangularDomain::r_S ( const Vector< double > &  s, Vector< double > &  f  )

private

takes the macro element coordinate position along the south boundary and returns the global coordinate position along that boundary

  {
    if (South_boundary_fn_pt != 0)
    {
      (*South_boundary_fn_pt)(s[0], f);
    }
    else
    {
      f[0] =
        x_south_west[0] + (s[0] + 1) / 2 * (x_north_east[0] - x_south_west[0]);
      f[1] = x_south_west[1];
    }
  }

References f(), s, South_boundary_fn_pt, x_north_east, and x_south_west.

Referenced by macro_element_boundary().

r_W()

void oomph::TopologicallyRectangularDomain::r_W ( const Vector< double > &  s, Vector< double > &  f  )

private

takes the macro element coordinate position along the west boundary and returns the global coordinate position along that boundary access down boundary function pointer

  {
    if (West_boundary_fn_pt != 0)
    {
      (*West_boundary_fn_pt)(s[0], f);
    }
    else
    {
      f[0] = x_south_west[0];
      f[1] =
        x_south_west[1] + (s[0] + 1) / 2 * (x_north_east[1] - x_south_west[1]);
    }
  }

References f(), s, West_boundary_fn_pt, x_north_east, and x_south_west.

Referenced by macro_element_boundary().

set_boundary_derivative_functions()

void oomph::TopologicallyRectangularDomain::set_boundary_derivative_functions	(	BoundaryFctPt	d_north_pt,
		BoundaryFctPt	d_east_pt,
		BoundaryFctPt	d_south_pt,
		BoundaryFctPt	d_west_pt
	)

allows the boundary derivate function pointers to be set. To compute the derivatives of the problem domain global coordinates (x_i) wrt the macro element coordinates (m_i), dx_i/dm_t is required along the domain boundaries (where dm_t is the macro element coordinate tangential to the domain boundary). The derivatives dx_i/dm_t can either be prescribed with function pointers, or if the function pointers are not provided then dx_i/dm_t is computed with finite differencing. Note - these functions are only required for domains contructed with boundary function pointers

  {
    // set the boundary derivate function pointers
    dNorth_boundary_fn_pt = d_north_pt;
    dEast_boundary_fn_pt = d_east_pt;
    dSouth_boundary_fn_pt = d_south_pt;
    dWest_boundary_fn_pt = d_west_pt;
  }

References dEast_boundary_fn_pt, dNorth_boundary_fn_pt, dSouth_boundary_fn_pt, and dWest_boundary_fn_pt.

set_boundary_second_derivative_functions()

void oomph::TopologicallyRectangularDomain::set_boundary_second_derivative_functions	(	BoundaryFctPt	d2_north_pt,
		BoundaryFctPt	d2_east_pt,
		BoundaryFctPt	d2_south_pt,
		BoundaryFctPt	d2_west_pt
	)

allows the boundary second derivate function pointers to be set. To compute the second derivatives of the problem domain global coordinates (x_i) wrt the macro element coordinates (m_i), d2x_i/dm_t^2 is required along the domain boundaries (where dm_t is the macro element coordinate tangential to the domain boundary). The derivatives d2x_i/dm_t^2 can either be prescribed with function pointers, or if the function pointers are not provided then dx_i/dm_t is computed with finite differencing. Note - these functions are only required for domains contructed with boundary function pointers

  {
    // set the boundary derivate function pointers
    d2North_boundary_fn_pt = d2_north_pt;
    d2East_boundary_fn_pt = d2_east_pt;
    d2South_boundary_fn_pt = d2_south_pt;
    d2West_boundary_fn_pt = d2_west_pt;
  }

References d2East_boundary_fn_pt, d2North_boundary_fn_pt, d2South_boundary_fn_pt, and d2West_boundary_fn_pt.

Member Data Documentation

d2East_boundary_fn_pt

BoundaryFctPt oomph::TopologicallyRectangularDomain::d2East_boundary_fn_pt

private

Function pointer to prescribe the second derivates of global coordinates wrt to the macro element coordinate tangential to the east boundary

Referenced by d2r_E(), set_boundary_second_derivative_functions(), and TopologicallyRectangularDomain().

d2North_boundary_fn_pt

BoundaryFctPt oomph::TopologicallyRectangularDomain::d2North_boundary_fn_pt

private

Function pointer to prescribe the second derivates of global coordinates wrt to the macro element coordinate tangential to the north boundary

Referenced by d2r_N(), set_boundary_second_derivative_functions(), and TopologicallyRectangularDomain().

d2South_boundary_fn_pt

BoundaryFctPt oomph::TopologicallyRectangularDomain::d2South_boundary_fn_pt

private

Function pointer to prescribe the second derivates of global coordinates wrt to the macro element coordinate tangential to the south boundary

Referenced by d2r_S(), set_boundary_second_derivative_functions(), and TopologicallyRectangularDomain().

d2West_boundary_fn_pt

BoundaryFctPt oomph::TopologicallyRectangularDomain::d2West_boundary_fn_pt

private

Function pointer to prescribe the second derivates of global coordinates wrt to the macro element coordinate tangential to the west boundary

Referenced by d2r_W(), set_boundary_second_derivative_functions(), and TopologicallyRectangularDomain().

dEast_boundary_fn_pt

BoundaryFctPt oomph::TopologicallyRectangularDomain::dEast_boundary_fn_pt

private

Function pointer to prescribe the derivates of global coordinates wrt to the macro element coordinate tangential to the east boundary

Referenced by d2r_E(), dr_E(), set_boundary_derivative_functions(), and TopologicallyRectangularDomain().

dNorth_boundary_fn_pt

BoundaryFctPt oomph::TopologicallyRectangularDomain::dNorth_boundary_fn_pt

private

Function pointer to prescribe the derivates of global coordinates wrt to the macro element coordinate tangential to the north boundary

Referenced by d2r_N(), dr_N(), set_boundary_derivative_functions(), and TopologicallyRectangularDomain().

dSouth_boundary_fn_pt

BoundaryFctPt oomph::TopologicallyRectangularDomain::dSouth_boundary_fn_pt

private

Function pointer to prescribe the derivates of global coordinates wrt to the macro element coordinate tangential to the south boundary

Referenced by d2r_S(), dr_S(), set_boundary_derivative_functions(), and TopologicallyRectangularDomain().

dWest_boundary_fn_pt

BoundaryFctPt oomph::TopologicallyRectangularDomain::dWest_boundary_fn_pt

private

Function pointer to prescribe the derivates of global coordinates wrt to the macro element coordinate tangential to the west boundary

Referenced by d2r_W(), dr_W(), set_boundary_derivative_functions(), and TopologicallyRectangularDomain().

East_boundary_fn_pt

BoundaryFctPt oomph::TopologicallyRectangularDomain::East_boundary_fn_pt

private

Function pointer to prescribe the east boundary of this topologically rectangular domain

Referenced by d2r_E(), dr_E(), r_E(), and TopologicallyRectangularDomain().

North_boundary_fn_pt

BoundaryFctPt oomph::TopologicallyRectangularDomain::North_boundary_fn_pt

private

Function pointer to prescribe the north boundary of this topologically rectangular domain

Referenced by d2r_N(), dr_N(), r_N(), and TopologicallyRectangularDomain().

South_boundary_fn_pt

BoundaryFctPt oomph::TopologicallyRectangularDomain::South_boundary_fn_pt

private

Function pointer to prescribe the north boundary of this topologically rectangular domain

Referenced by d2r_S(), dr_S(), r_S(), and TopologicallyRectangularDomain().

West_boundary_fn_pt

BoundaryFctPt oomph::TopologicallyRectangularDomain::West_boundary_fn_pt

private

Function pointer to prescribe the west boundary of this topologically rectangular domain

Referenced by d2r_W(), dr_W(), r_W(), and TopologicallyRectangularDomain().

x_north_east

Vector<double> oomph::TopologicallyRectangularDomain::x_north_east

private

coordinate position of north east corner of domain (only used if boundary functions are not used)

Referenced by dr_E(), dr_N(), dr_S(), dr_W(), r_E(), r_N(), r_S(), r_W(), and TopologicallyRectangularDomain().

x_south_west

Vector<double> oomph::TopologicallyRectangularDomain::x_south_west

private

coordinate position of south west corner of domain (only used if boundary functions are not used)

Referenced by dr_E(), dr_N(), dr_S(), dr_W(), r_E(), r_N(), r_S(), r_W(), and TopologicallyRectangularDomain().

---

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

• topologically_rectangular_domain.h
• topologically_rectangular_domain.cc