Postprocessor that computes the minimum value of h_min/|u|, where |u| is coupled in as an aux variable. More...

#include <INSExplicitTimestepSelector.h>

Inheritance diagram for INSExplicitTimestepSelector:

Public Member Functions
	INSExplicitTimestepSelector (const InputParameters &parameters)

virtual	~INSExplicitTimestepSelector ()

virtual void	initialize ()

virtual void	execute ()

virtual Real	getValue ()

virtual void	threadJoin (const UserObject &uo)

Protected Attributes
Real	_value
	The value of dt (NOTE: _dt member variable is already defined) More...

const VariableValue &	_vel_mag
	Velocity magnitude. Hint: Use VectorMagnitudeAux in Moose for this. More...

Real	_beta
	We can compute maximum stable timesteps based on the linearized theory, but even those timesteps are sometimes still too large for explicit timestepping in a "real" problem. More...

const MaterialProperty< Real > &	_mu
	Material properties: the explicit time scheme limit for the viscous problem also depends on the kinematic viscosity. More...

const MaterialProperty< Real > &	_rho

Detailed Description

Postprocessor that computes the minimum value of h_min/|u|, where |u| is coupled in as an aux variable.

Definition at line 23 of file INSExplicitTimestepSelector.h.

Constructor & Destructor Documentation

◆ INSExplicitTimestepSelector()

INSExplicitTimestepSelector::INSExplicitTimestepSelector ( const InputParameters & parameters )

Definition at line 39 of file INSExplicitTimestepSelector.C.

   : ElementPostprocessor(parameters),
     _vel_mag(coupledValue("vel_mag")),
  
     // Other parameters
     _beta(getParam<Real>("beta")),
  
     // Material properties
     _mu(getMaterialProperty<Real>("mu_name")),
     _rho(getMaterialProperty<Real>("rho_name"))
 {
 }

◆ ~INSExplicitTimestepSelector()

INSExplicitTimestepSelector::~INSExplicitTimestepSelector ( )

virtual

Definition at line 52 of file INSExplicitTimestepSelector.C.

52 {}

Member Function Documentation

◆ execute()

void INSExplicitTimestepSelector::execute ( )

virtual

Definition at line 61 of file INSExplicitTimestepSelector.C.

 {
   Real h_min = _current_elem->hmin();
  
   // The space dimension plays a role in the diffusive dt limit.  The more
   // space dimensions there are, the smaller this limit is.
   Real dim = static_cast<Real>(_current_elem->dim());
  
   for (unsigned qp = 0; qp < _qrule->n_points(); ++qp)
   {
     // Don't divide by zero...
     Real vel_mag = std::max(_vel_mag[qp], std::numeric_limits<Real>::epsilon());
  
     // For explicit Euler, we always have to satisfy the Courant condition for stability.
     Real courant_limit_dt = h_min / vel_mag;
  
     // But we also have to obey the diffusive time restriction,
     // dt <= 1/(2*nu)*(1/h1^2 + 1/h2^2 + 1/h3^2)^(-1) <=
     //    <= h_min^2 / n_dim / (2*nu)
     Real diffusive_limit_dt = 0.5 * h_min * h_min / (_mu[qp] / _rho[qp]) / dim;
  
     // And the "combined" condition, dt <= 2*nu/|u|^2
     Real combined_limit_dt = 2. * (_mu[qp] / _rho[qp]) / vel_mag / vel_mag;
  
     // // Debugging:
     // Moose::out << "courant_limit_dt   = " << courant_limit_dt   << "\n"
     //           << "diffusive_limit_dt = " << diffusive_limit_dt << "\n"
     //           << "combined_limit_dt  = " << combined_limit_dt
     //           << std::endl;
  
     _value = std::min(
         _value,
         _beta * std::min(std::min(courant_limit_dt, diffusive_limit_dt), combined_limit_dt));
   }
 }

◆ getValue()

Real INSExplicitTimestepSelector::getValue ( )

virtual

Definition at line 98 of file INSExplicitTimestepSelector.C.

 {
   _communicator.min(_value);
   return _value;
 }

◆ initialize()

void INSExplicitTimestepSelector::initialize ( )

virtual

Definition at line 55 of file INSExplicitTimestepSelector.C.

 {
   _value = std::numeric_limits<Real>::max();
 }

◆ threadJoin()

void INSExplicitTimestepSelector::threadJoin ( const UserObject & uo )

virtual

Definition at line 105 of file INSExplicitTimestepSelector.C.

 {
   const INSExplicitTimestepSelector & pps = dynamic_cast<const INSExplicitTimestepSelector &>(uo);
   _value = std::min(_value, pps._value);
 }

Member Data Documentation

◆ _beta

Real INSExplicitTimestepSelector::_beta

protected

We can compute maximum stable timesteps based on the linearized theory, but even those timesteps are sometimes still too large for explicit timestepping in a "real" problem.

Therefore, we provide an additional "fudge" factor, 0 < beta < 1, that can be used to reduce the selected timestep even further.

Definition at line 46 of file INSExplicitTimestepSelector.h.

Referenced by execute().