oomph::MinModLimiter Class Reference

#include <dg_elements.h>

Inheritance diagram for oomph::MinModLimiter:

Public Member Functions
	MinModLimiter (const double &m=0.0, const bool &muscl=false)
virtual	~MinModLimiter ()
	Empty destructor. More...
double	minmod (Vector< double > &args)
	The basic minmod function. More...
double	minmodB (Vector< double > &args, const double &h)
	The modified minmod function. More...
void	limit (const unsigned &i, const Vector< DGElement * > &required_element_pt)
	The limit function. More...
Public Member Functions inherited from oomph::SlopeLimiter
	SlopeLimiter ()
	Empty constructor. More...
virtual	~SlopeLimiter ()
	virtual destructor More...

Private Attributes
double	M
bool	MUSCL
	Boolean flag to indicate a MUSCL or straight min-mod limiter. More...

Constructor & Destructor Documentation

MinModLimiter()

oomph::MinModLimiter::MinModLimiter ( const double &  m = 0.0, const bool &  muscl = false  )

inline

Constructor takes a value for the modification parameter M (default to zero — classic min mod) and a flag to indicate whether we use MUSCL limiting or not — default false

      : SlopeLimiter(), M(m), MUSCL(muscl)
    {
    }

~MinModLimiter()

virtual oomph::MinModLimiter::~MinModLimiter ( )

inlinevirtual

Empty destructor.

{}

Member Function Documentation

limit()

void oomph::MinModLimiter::limit ( const unsigned &  i, const Vector< DGElement * > &  required_element_pt  )

virtual

The limit function.

Implement the limiter function for the basic MinModlimiter.

Reimplemented from oomph::SlopeLimiter.

  {
    // Set the tolerance
    const double tol = 1.0e-16;
 
    // Find the geometric parameters of the element
    const unsigned n_node = required_element_pt[0]->nnode();
    const double x_l = required_element_pt[0]->node_pt(0)->x(0);
    const double x_r = required_element_pt[0]->node_pt(n_node - 1)->x(0);
    const double h = x_r - x_l;
    const double x0 = 0.5 * (x_l + x_r);
    // Find the average value
    const double u_av = required_element_pt[0]->average_value(i);
 
    // Storage for the gradients to the minmod function
    Vector<double> arg;
    arg.reserve(3);
 
    // Add the approximation for the element's left flux
    arg.push_back(u_av - required_element_pt[0]->node_pt(0)->value(i));
 
    // If there is a left element add the approximate gradient
    // to the argument vector
    if (required_element_pt[1] != required_element_pt[0])
    {
      arg.push_back(u_av - required_element_pt[1]->average_value(i));
    }
    // If there is a right element add the approximate gradient
    // to the argument vector
    if (required_element_pt[2] != required_element_pt[0])
    {
      arg.push_back(required_element_pt[2]->average_value(i) - u_av);
    }
 
    // Set the left value
    const double u_l = u_av - this->minmod(arg);
 
    // Now replace the first term in the argument list with the
    // approximation for the element's right flux
    arg.front() = required_element_pt[0]->node_pt(n_node - 1)->value(i) - u_av;
 
    // Set the right value
    const double u_r = u_av + this->minmod(arg);
 
    // If the basic limited values are different from
    // the unlimited values then limit
    if ((std::fabs(u_l - required_element_pt[0]->node_pt(0)->value(i)) > tol) &&
        (std::fabs(
           u_r - required_element_pt[0]->node_pt(n_node - 1)->value(i)) > tol))
    {
      // Find the centre of the element on the left
      const double x0_l =
        0.5 * (required_element_pt[1]
                 ->node_pt(required_element_pt[1]->nnode() - 1)
                 ->x(0) +
               required_element_pt[1]->node_pt(0)->x(0));
      // Find the centre of the element on the right
      const double x0_r =
        0.5 * (required_element_pt[2]
                 ->node_pt(required_element_pt[2]->nnode() - 1)
                 ->x(0) +
               required_element_pt[2]->node_pt(0)->x(0));
 
      // Clear the argument list and reserve its size to
      arg.clear();
      arg.reserve(3);
 
      // Approximate the gradient over the whole cell
      arg.push_back((required_element_pt[0]->node_pt(n_node - 1)->value(i) -
                     required_element_pt[0]->node_pt(0)->value(i)) /
                    h);
 
      // Adjust the estimates for the gradient calculated from neighbouring
      // averages for the straight min-mod and MUSCL limiters
      double gradient_factor = 0.5;
      if (MUSCL)
      {
        gradient_factor = 1.0;
      }
 
      // If there is a left element, form the gradient
      if (required_element_pt[0] != required_element_pt[1])
      {
        arg.push_back((u_av - required_element_pt[1]->average_value(i)) /
                      (gradient_factor * (x0 - x0_l)));
      }
 
      // If there is a right element, form the gradient
      if (required_element_pt[0] != required_element_pt[2])
      {
        arg.push_back((required_element_pt[2]->average_value(i) - u_av) /
                      (gradient_factor * (x0_r - x0)));
      }
 
      // Calculate the limited gradient of these three
      double limited_gradient = this->minmodB(arg, h);
 
      // Loop over the nodes and limit
      for (unsigned n = 0; n < n_node; n++)
      {
        double x = required_element_pt[0]->node_pt(n)->x(0) - x0;
        required_element_pt[0]->node_pt(n)->set_value(
          i, u_av + x * limited_gradient);
      }
    }
  }

References boost::multiprecision::fabs(), i, minmod(), minmodB(), MUSCL, n, Global_Parameters::u_r(), Eigen::value, plotDoE::x, and Global::x0.

minmod()

double oomph::MinModLimiter::minmod

(

Vector< double > &

args

)

The basic minmod function.

Helper minmod function.

  {
    const unsigned n_arg = args.size();
    // If no arguments return zero
    if (n_arg == 0)
    {
      return 0.0;
    }
 
    // Initialise the sign from the sign of the first entry
    int sign = 0;
    if (args[0] < 0.0)
    {
      sign = -1;
    }
    else if (args[0] > 0.0)
    {
      sign = 1;
    }
    else
    {
      return 0.0;
    }
 
    // Initialise the minimum value
    double min = std::fabs(args[0]);
 
    // Now loop over the rest of the values
    for (unsigned i = 1; i < n_arg; i++)
    {
      if (sign == 1)
      {
        if (args[i] < 0.0)
        {
          return 0.0;
        }
        else if (args[i] < min)
        {
          min = args[i];
        }
      }
      else if (sign == -1)
      {
        if (args[i] > 0.0)
        {
          return 0.0;
        }
        else if (std::fabs(args[i]) < min)
        {
          min = std::fabs(args[i]);
        }
      }
    }
 
    // Make sure to return the sign multiplied by the minimum value
    return sign * min;
  }

References compute_granudrum_aor::args, boost::multiprecision::fabs(), i, min, and SYCL::sign().

Referenced by limit(), and minmodB().

minmodB()

double oomph::MinModLimiter::minmodB	(	Vector< double > &	args,
		const double &	h
	)

The modified minmod function.

Modified minmod limiter to fix behaviour in smooth regions.

  {
    const unsigned n_arg = args.size();
    // If no arguments return zero
    if (n_arg == 0)
    {
      return 0.0;
    }
 
    // Modification to fix extrema
    if (std::fabs(args[0]) < this->M * h * h)
    {
      return args[0];
    }
    // Otherwise just return the usual minmod
    else
    {
      return minmod(args);
    }
  }

References compute_granudrum_aor::args, boost::multiprecision::fabs(), and minmod().

Referenced by limit().

Member Data Documentation

M

double oomph::MinModLimiter::M

private

Constant that is used in the modified min-mod function to provide better properties at extrema

MUSCL

bool oomph::MinModLimiter::MUSCL

private

Boolean flag to indicate a MUSCL or straight min-mod limiter.

Referenced by limit().

---

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

• dg_elements.h
• dg_elements.cc