https://mooseframework.inl.gov
Public Types | Public Member Functions | Static Public Member Functions | Static Public Attributes | Protected Member Functions | Protected Attributes | Static Protected Attributes | List of all members
SlopeReconstruction1DInterface< is_ad > Class Template Referenceabstract

Interface class for 1-D slope reconstruction. More...

#include <SlopeReconstruction1DInterface.h>

Public Types

enum  ESlopeReconstructionType {
  None, Full, Minmod, MC,
  Superbee
}
 Slope reconstruction type. More...
 

Public Member Functions

 SlopeReconstruction1DInterface (const MooseObject *moose_object)
 

Static Public Member Functions

static MooseEnum getSlopeReconstructionMooseEnum (const std::string &name="")
 Gets a MooseEnum for slope reconstruction type. More...
 
static InputParameters validParams ()
 

Static Public Attributes

static const std::map< std::string, ESlopeReconstructionType > _slope_reconstruction_type_to_enum
 Map of slope reconstruction type string to enum. More...
 

Protected Member Functions

virtual void getNeighborPrimitiveVariables (const Elem *elem, std::vector< std::vector< GenericReal< is_ad >>> &W_neighbor, std::vector< Point > &x_neighbor) const
 Gets the primitive solution vector and position of neighbor(s) More...
 
std::vector< GenericReal< is_ad > > getElementSlopes (const Elem *elem) const
 Gets limited slopes for the primitive variables in the 1-D direction. More...
 
std::vector< GenericReal< is_ad > > getBoundaryElementSlopes (const std::vector< GenericReal< is_ad >> &W_elem, const Point &x_elem, const RealVectorValue &dir, std::vector< std::vector< GenericReal< is_ad >>> W_neighbor, std::vector< Point > x_neighbor, const std::vector< GenericReal< is_ad >> &W_boundary) const
 Gets limited slopes for the primitive variables in the 1-D direction for boundary element. More...
 
std::vector< GenericReal< is_ad > > getElementSlopes (const std::vector< GenericReal< is_ad >> &W_elem, const Point &x_elem, const RealVectorValue &dir, const std::vector< std::vector< GenericReal< is_ad >>> &W_neighbor, const std::vector< Point > &x_neighbor) const
 Gets limited slopes for the primitive variables in the 1-D direction. More...
 
virtual std::vector< GenericReal< is_ad > > computeElementPrimitiveVariables (const Elem *elem) const =0
 Computes the cell-average primitive variable values for an element. More...
 

Protected Attributes

const MooseObject *const _moose_object
 MooseObject this interface is extending. More...
 
const ESlopeReconstructionType _scheme
 Slope reconstruction scheme. More...
 

Static Protected Attributes

static const unsigned int _n_side = 2
 Number of sides. More...
 
static const unsigned int _n_sten = 3
 Number of elemental values in stencil for computing slopes. More...
 

Detailed Description

template<bool is_ad>
class SlopeReconstruction1DInterface< is_ad >

Interface class for 1-D slope reconstruction.

This class provides interfaces for generating slopes for an arbitrary set of variables. A number of reconstruction options are provided, including a number of TVD slope limiters.

Definition at line 30 of file SlopeReconstruction1DInterface.h.

Member Enumeration Documentation

◆ ESlopeReconstructionType

template<bool is_ad>
enum SlopeReconstruction1DInterface::ESlopeReconstructionType

Slope reconstruction type.

Enumerator
None 

No reconstruction; Godunov scheme.

Full 

Full reconstruction; no limitation.

Minmod 

Minmod slope limiter.

MC 

Monotonized Central-Difference slope limiter.

Superbee 

Superbee slope limiter.

Definition at line 36 of file SlopeReconstruction1DInterface.h.

37  {
38  None,
39  Full,
40  Minmod,
41  MC,
42  Superbee
43  };
SlopeReconstruction1DInterface::MC
Monotonized Central-Difference slope limiter.
Definition: SlopeReconstruction1DInterface.h:41
SlopeReconstruction1DInterface::Full
Full reconstruction; no limitation.
Definition: SlopeReconstruction1DInterface.h:39

Constructor & Destructor Documentation

◆ SlopeReconstruction1DInterface()

template<bool is_ad>
SlopeReconstruction1DInterface< is_ad >::SlopeReconstruction1DInterface ( const MooseObject *  moose_object)

Definition at line 188 of file SlopeReconstruction1DInterface.h.

190  : _moose_object(moose_object),
191  _scheme(THM::stringToEnum<ESlopeReconstructionType>(
192  moose_object->parameters().get<MooseEnum>("scheme")))
193 {
194 }
SlopeReconstruction1DInterface::_moose_object
const MooseObject *const _moose_object
MooseObject this interface is extending.
Definition: SlopeReconstruction1DInterface.h:126
InputParameters::get
std::vector< std::pair< R1, R2 > > get(const std::string &param1, const std::string &param2) const
MooseObject::parameters
const InputParameters & parameters() const
SlopeReconstruction1DInterface::_scheme
const ESlopeReconstructionType _scheme
Slope reconstruction scheme.
Definition: SlopeReconstruction1DInterface.h:129

Member Function Documentation

◆ computeElementPrimitiveVariables()

template<bool is_ad>
virtual std::vector<GenericReal<is_ad> > SlopeReconstruction1DInterface< is_ad >::computeElementPrimitiveVariables ( const Elem *  elem) const
protectedpure virtual

Computes the cell-average primitive variable values for an element.

Parameters
[in]elemElement for which to get values
Returns
Vector of values on element

Implemented in ADJunctionOneToOne1PhaseUserObject, ADRDG3EqnMaterial, RDG3EqnMaterial, and SlopeReconstructionGasMixMaterial.

◆ getBoundaryElementSlopes()

template<bool is_ad>
std::vector< GenericReal< is_ad > > SlopeReconstruction1DInterface< is_ad >::getBoundaryElementSlopes ( const std::vector< GenericReal< is_ad >> &  W_elem,
const Point &  x_elem,
const RealVectorValue &  dir,
std::vector< std::vector< GenericReal< is_ad >>>  W_neighbor,
std::vector< Point >  x_neighbor,
const std::vector< GenericReal< is_ad >> &  W_boundary 
) const
protected

Gets limited slopes for the primitive variables in the 1-D direction for boundary element.

Parameters
[in]W_elemPrimitive solution for element
[in]x_elemPosition for element
[in]dirDirection for element
[in]W_neighborPrimitive solution vector for each neighbor
[in]x_neighborPosition for each neighbor
[in]W_boundaryPrimitive solution vector for boundary
Returns
Vector of slopes for the element in the 1-D direction

Definition at line 235 of file SlopeReconstruction1DInterface.h.

242 {
243  if (W_neighbor.size() == 1)
244  {
245  W_neighbor.push_back(W_boundary);
246 
247  // The boundary point will be assumed to be the same distance away as neighbor
248  const Point dx = x_elem - x_neighbor[0];
249  const Point x_boundary = x_elem + dx;
250  x_neighbor.push_back(x_boundary);
251  }
252 
253  return getElementSlopes(W_elem, x_elem, dir, W_neighbor, x_neighbor);
254 }
SlopeReconstruction1DInterface::getElementSlopes
std::vector< GenericReal< is_ad > > getElementSlopes(const Elem *elem) const
Gets limited slopes for the primitive variables in the 1-D direction.
Definition: SlopeReconstruction1DInterface.h:218

◆ getElementSlopes() [1/2]

template<bool is_ad>
std::vector< GenericReal< is_ad > > SlopeReconstruction1DInterface< is_ad >::getElementSlopes ( const Elem *  elem) const
protected

Gets limited slopes for the primitive variables in the 1-D direction.

Parameters
[in]elemElement for which to get slopes
Returns
Vector of slopes for the element in the 1-D direction

Definition at line 218 of file SlopeReconstruction1DInterface.h.

219 {
220  mooseAssert(elem, "The supplied element is a nullptr.");
221 
222  const auto W_elem = computeElementPrimitiveVariables(elem);
223  const Point x_elem = elem->vertex_average();
224  const RealVectorValue dir = (elem->node_ref(1) - elem->node_ref(0)).unit();
225 
226  std::vector<Point> x_neighbor;
227  std::vector<std::vector<GenericReal<is_ad>>> W_neighbor;
228  getNeighborPrimitiveVariables(elem, W_neighbor, x_neighbor);
229 
230  return getElementSlopes(W_elem, x_elem, dir, W_neighbor, x_neighbor);
231 }
SlopeReconstruction1DInterface::getNeighborPrimitiveVariables
virtual void getNeighborPrimitiveVariables(const Elem *elem, std::vector< std::vector< GenericReal< is_ad >>> &W_neighbor, std::vector< Point > &x_neighbor) const
Gets the primitive solution vector and position of neighbor(s)
Definition: SlopeReconstruction1DInterface.h:198
SlopeReconstruction1DInterface::computeElementPrimitiveVariables
virtual std::vector< GenericReal< is_ad > > computeElementPrimitiveVariables(const Elem *elem) const =0
Computes the cell-average primitive variable values for an element.
SlopeReconstruction1DInterface::getElementSlopes
std::vector< GenericReal< is_ad > > getElementSlopes(const Elem *elem) const
Gets limited slopes for the primitive variables in the 1-D direction.
Definition: SlopeReconstruction1DInterface.h:218

◆ getElementSlopes() [2/2]

template<bool is_ad>
std::vector< GenericReal< is_ad > > SlopeReconstruction1DInterface< is_ad >::getElementSlopes ( const std::vector< GenericReal< is_ad >> &  W_elem,
const Point &  x_elem,
const RealVectorValue &  dir,
const std::vector< std::vector< GenericReal< is_ad >>> &  W_neighbor,
const std::vector< Point > &  x_neighbor 
) const
protected

Gets limited slopes for the primitive variables in the 1-D direction.

Parameters
[in]W_elemPrimitive solution for element
[in]x_elemPosition for element
[in]dirDirection for element
[in]W_neighborPrimitive solution vector for each neighbor
[in]x_neighborPosition for each neighbor
Returns
Vector of slopes for the element in the 1-D direction

Definition at line 258 of file SlopeReconstruction1DInterface.h.

264 {
265  mooseAssert(x_neighbor.size() == W_neighbor.size(),
266  "Neighbor positions size must equal neighbor solutions size.");
267 
268  using std::abs, std::min, std::max;
269 
270  // get the number of slopes to be stored
271  const unsigned int n_slopes = W_elem.size();
272 
273  // compute one-sided slope(s)
274  std::vector<std::vector<GenericReal<is_ad>>> slopes_one_sided;
275  for (unsigned int i = 0; i < W_neighbor.size(); i++)
276  {
277  const Real dx = (x_elem - x_neighbor[i]) * dir;
278 
279  std::vector<GenericReal<is_ad>> slopes(n_slopes, 0.0);
280  for (unsigned int m = 0; m < n_slopes; m++)
281  slopes[m] = (W_elem[m] - W_neighbor[i][m]) / dx;
282 
283  slopes_one_sided.push_back(slopes);
284  }
285 
286  // Fill in any missing one-sided slopes and compute central slope
287  std::vector<GenericReal<is_ad>> slopes_central(n_slopes, 0.0);
288  if (W_neighbor.size() == 2)
289  {
290  const Real dx = (x_neighbor[0] - x_neighbor[1]) * dir;
291  for (unsigned int m = 0; m < n_slopes; m++)
292  slopes_central[m] = (W_neighbor[0][m] - W_neighbor[1][m]) / dx;
293  }
294  else if (W_neighbor.size() == 1)
295  {
296  slopes_one_sided.push_back(slopes_one_sided[0]);
297  slopes_central = slopes_one_sided[0];
298  }
299  else // only one element; use zero slopes
300  {
301  slopes_one_sided.push_back(slopes_central);
302  slopes_one_sided.push_back(slopes_central);
303  }
304 
305  // vector for the (possibly limited) slopes
306  std::vector<GenericReal<is_ad>> slopes_limited(n_slopes, 0.0);
307 
308  // limit the slopes
309  switch (_scheme)
310  {
311  // first-order, zero slope
312  case None:
313  break;
314 
315  // full reconstruction; no limitation
316  case Full:
317 
318  slopes_limited = slopes_central;
319  break;
320 
321  // minmod limiter
322  case Minmod:
323 
324  for (unsigned int m = 0; m < n_slopes; m++)
325  {
326  if ((slopes_one_sided[0][m] * slopes_one_sided[1][m]) > 0.0)
327  {
328  if (abs(slopes_one_sided[0][m]) < abs(slopes_one_sided[1][m]))
329  slopes_limited[m] = slopes_one_sided[0][m];
330  else
331  slopes_limited[m] = slopes_one_sided[1][m];
332  }
333  }
334  break;
335 
336  // MC (monotonized central-difference) limiter
337  case MC:
338 
339  for (unsigned int m = 0; m < n_slopes; m++)
340  {
341  if (slopes_central[m] > 0.0 && slopes_one_sided[0][m] > 0.0 && slopes_one_sided[1][m] > 0.0)
342  slopes_limited[m] =
343  min(slopes_central[m], 2.0 * min(slopes_one_sided[0][m], slopes_one_sided[1][m]));
344  else if (slopes_central[m] < 0.0 && slopes_one_sided[0][m] < 0.0 &&
345  slopes_one_sided[1][m] < 0.0)
346  slopes_limited[m] =
347  max(slopes_central[m], 2.0 * max(slopes_one_sided[0][m], slopes_one_sided[1][m]));
348  }
349  break;
350 
351  // superbee limiter
352  case Superbee:
353 
354  for (unsigned int m = 0; m < n_slopes; m++)
355  {
356  GenericReal<is_ad> slope1 = 0.0;
357  GenericReal<is_ad> slope2 = 0.0;
358 
359  // calculate slope1 with minmod
360  if (slopes_one_sided[1][m] > 0.0 && slopes_one_sided[0][m] > 0.0)
361  slope1 = min(slopes_one_sided[1][m], 2.0 * slopes_one_sided[0][m]);
362  else if (slopes_one_sided[1][m] < 0.0 && slopes_one_sided[0][m] < 0.0)
363  slope1 = max(slopes_one_sided[1][m], 2.0 * slopes_one_sided[0][m]);
364 
365  // calculate slope2 with minmod
366  if (slopes_one_sided[1][m] > 0.0 && slopes_one_sided[0][m] > 0.0)
367  slope2 = min(2.0 * slopes_one_sided[1][m], slopes_one_sided[0][m]);
368  else if (slopes_one_sided[1][m] < 0.0 && slopes_one_sided[0][m] < 0.0)
369  slope2 = max(2.0 * slopes_one_sided[1][m], slopes_one_sided[0][m]);
370 
371  // calculate slope with maxmod
372  if (slope1 > 0.0 && slope2 > 0.0)
373  slopes_limited[m] = max(slope1, slope2);
374  else if (slope1 < 0.0 && slope2 < 0.0)
375  slopes_limited[m] = min(slope1, slope2);
376  }
377  break;
378 
379  default:
380  mooseError("Unknown slope reconstruction scheme");
381  break;
382  }
383  return slopes_limited;
384 }
abs
MetaPhysicL::DualNumber< V, D, asd > abs(const MetaPhysicL::DualNumber< V, D, asd > &a)
GenericReal
Moose::GenericType< Real, is_ad > GenericReal
SlopeReconstruction1DInterface::MC
Monotonized Central-Difference slope limiter.
Definition: SlopeReconstruction1DInterface.h:41
mooseError
void mooseError(Args &&... args)
SlopeReconstruction1DInterface::Full
Full reconstruction; no limitation.
Definition: SlopeReconstruction1DInterface.h:39
max
auto max(const L &left, const R &right)
SlopeReconstruction1DInterface::_scheme
const ESlopeReconstructionType _scheme
Slope reconstruction scheme.
Definition: SlopeReconstruction1DInterface.h:129
Real
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
min
auto min(const L &left, const R &right)

◆ getNeighborPrimitiveVariables()

template<bool is_ad>
void SlopeReconstruction1DInterface< is_ad >::getNeighborPrimitiveVariables ( const Elem *  elem,
std::vector< std::vector< GenericReal< is_ad >>> &  W_neighbor,
std::vector< Point > &  x_neighbor 
) const
protectedvirtual

Gets the primitive solution vector and position of neighbor(s)

Parameters
[in]elemElement for which to get slopes
[in]W_neighborPrimitive solution vector for each neighbor
[in]x_neighborPosition for each neighbor

Definition at line 198 of file SlopeReconstruction1DInterface.h.

202 {
203  W_neighbor.clear();
204  x_neighbor.clear();
205  for (unsigned int i_side = 0; i_side < _n_side; i_side++)
206  {
207  auto neighbor = elem->neighbor_ptr(i_side);
208  if (neighbor && (neighbor->processor_id() == _moose_object->processor_id()))
209  {
210  x_neighbor.push_back(neighbor->vertex_average());
211  W_neighbor.push_back(computeElementPrimitiveVariables(neighbor));
212  }
213  }
214 }
SlopeReconstruction1DInterface::_moose_object
const MooseObject *const _moose_object
MooseObject this interface is extending.
Definition: SlopeReconstruction1DInterface.h:126
SlopeReconstruction1DInterface::_n_side
static const unsigned int _n_side
Number of sides.
Definition: SlopeReconstruction1DInterface.h:136
SlopeReconstruction1DInterface::computeElementPrimitiveVariables
virtual std::vector< GenericReal< is_ad > > computeElementPrimitiveVariables(const Elem *elem) const =0
Computes the cell-average primitive variable values for an element.
libMesh::ParallelObject::processor_id
processor_id_type processor_id() const

◆ getSlopeReconstructionMooseEnum()

template<bool is_ad>
MooseEnum SlopeReconstruction1DInterface< is_ad >::getSlopeReconstructionMooseEnum ( const std::string &  name = "")
static

Gets a MooseEnum for slope reconstruction type.

Parameters
[in]namedefault value
Returns
MooseEnum for slope reconstruction type

Definition at line 161 of file SlopeReconstruction1DInterface.h.

Referenced by FlowChannel1PhaseBase::validParams(), and SlopeReconstruction1DInterface< true >::validParams().

162 {
163  return THM::getMooseEnum<SlopeReconstruction1DInterface<is_ad>::ESlopeReconstructionType>(
164  name, _slope_reconstruction_type_to_enum);
165 }
SlopeReconstruction1DInterface::_slope_reconstruction_type_to_enum
static const std::map< std::string, ESlopeReconstructionType > _slope_reconstruction_type_to_enum
Map of slope reconstruction type string to enum.
Definition: SlopeReconstruction1DInterface.h:45
name
const std::string name
Definition: Setup.h:20

◆ validParams()

template<bool is_ad>
InputParameters SlopeReconstruction1DInterface< is_ad >::validParams ( )
static

Definition at line 175 of file SlopeReconstruction1DInterface.h.

Referenced by SlopeReconstructionGasMixMaterial::validParams(), RDG3EqnMaterial::validParams(), ADRDG3EqnMaterial::validParams(), and ADJunctionOneToOne1PhaseUserObject::validParams().

176 {
177  InputParameters params = emptyInputParameters();
178 
179  params.addRequiredParam<MooseEnum>(
180  "scheme",
181  SlopeReconstruction1DInterface::getSlopeReconstructionMooseEnum("None"),
182  "Slope reconstruction scheme");
183 
184  return params;
185 }
InputParameters::addRequiredParam
void addRequiredParam(const std::string &name, const std::string &doc_string)
emptyInputParameters
InputParameters emptyInputParameters()
SlopeReconstruction1DInterface::getSlopeReconstructionMooseEnum
static MooseEnum getSlopeReconstructionMooseEnum(const std::string &name="")
Gets a MooseEnum for slope reconstruction type.
Definition: SlopeReconstruction1DInterface.h:161

Member Data Documentation

◆ _moose_object

template<bool is_ad>
const MooseObject* const SlopeReconstruction1DInterface< is_ad >::_moose_object
protected

MooseObject this interface is extending.

Definition at line 126 of file SlopeReconstruction1DInterface.h.

◆ _n_side

template<bool is_ad>
const unsigned int SlopeReconstruction1DInterface< is_ad >::_n_side = 2
staticprotected

Number of sides.

Definition at line 136 of file SlopeReconstruction1DInterface.h.

◆ _n_sten

template<bool is_ad>
const unsigned int SlopeReconstruction1DInterface< is_ad >::_n_sten = 3
staticprotected

Number of elemental values in stencil for computing slopes.

Definition at line 138 of file SlopeReconstruction1DInterface.h.

◆ _scheme

template<bool is_ad>
const ESlopeReconstructionType SlopeReconstruction1DInterface< is_ad >::_scheme
protected

Slope reconstruction scheme.

Definition at line 129 of file SlopeReconstruction1DInterface.h.

◆ _slope_reconstruction_type_to_enum

template<bool is_ad>
const std::map< std::string, typename SlopeReconstruction1DInterface< is_ad >::ESlopeReconstructionType > SlopeReconstruction1DInterface< is_ad >::_slope_reconstruction_type_to_enum
static
Initial value:
{
{"NONE", None}, {"FULL", Full}, {"MINMOD", Minmod}, {"MC", MC}, {"SUPERBEE", Superbee}}

Map of slope reconstruction type string to enum.

Definition at line 45 of file SlopeReconstruction1DInterface.h.

The documentation for this class was generated from the following file:
Generated on Wed Nov 5 2025 20:31:36 for https://mooseframework.inl.gov by   doxygen 1.8.14