https://mooseframework.inl.gov
Loading...
Searching...
No Matches
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.
 
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.
 

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)
 
std::vector< GenericReal< is_ad > > getElementSlopes (const Elem *elem) const
 Gets limited slopes for the primitive variables in the 1-D direction.
 
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.
 
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.
 
virtual std::vector< GenericReal< is_ad > > computeElementPrimitiveVariables (const Elem *elem) const =0
 Computes the cell-average primitive variable values for an element.
 

Protected Attributes

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

Static Protected Attributes

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

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::None
@ None
No reconstruction; Godunov scheme.
Definition SlopeReconstruction1DInterface.h:38
SlopeReconstruction1DInterface::Full
@ Full
Full reconstruction; no limitation.
Definition SlopeReconstruction1DInterface.h:39
SlopeReconstruction1DInterface::MC
@ MC
Monotonized Central-Difference slope limiter.
Definition SlopeReconstruction1DInterface.h:41

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}
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
SlopeReconstruction1DInterface::_moose_object
const MooseObject *const _moose_object
MooseObject this interface is extending.
Definition SlopeReconstruction1DInterface.h:126

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 ADRDG3EqnMaterial, RDG3EqnMaterial, SlopeReconstructionGasMixMaterial, and ADJunctionOneToOne1PhaseUserObject.

◆ 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::computeElementPrimitiveVariables
virtual std::vector< GenericReal< is_ad > > computeElementPrimitiveVariables(const Elem *elem) const =0
Computes the cell-average primitive variable values for an element.
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
libMesh::RealVectorValue
VectorValue< Real > RealVectorValue

◆ 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}
mooseError
void mooseError(Args &&... args)
GenericReal
Moose::GenericType< Real, is_ad > GenericReal
CompileTimeDerivatives::max
auto max(const L &left, const R &right)
CompileTimeDerivatives::min
auto min(const L &left, const R &right)
Eigen::internal::abs
MetaPhysicL::DualNumber< V, D, asd > abs(const MetaPhysicL::DualNumber< V, D, asd > &a)
libMesh::Real
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real

◆ 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::_n_side
static const unsigned int _n_side
Number of sides.
Definition SlopeReconstruction1DInterface.h:136
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.

162{
163 return THM::getMooseEnum<SlopeReconstruction1DInterface<is_ad>::ESlopeReconstructionType>(
164 name, _slope_reconstruction_type_to_enum);
165}
name
const std::string name
Definition Setup.h:21
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

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

◆ validParams()

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

Definition at line 175 of file SlopeReconstruction1DInterface.h.

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}
emptyInputParameters
InputParameters emptyInputParameters()
InputParameters::addRequiredParam
void addRequiredParam(const std::string &name, const std::string &doc_string)
SlopeReconstruction1DInterface::getSlopeReconstructionMooseEnum
static MooseEnum getSlopeReconstructionMooseEnum(const std::string &name="")
Gets a MooseEnum for slope reconstruction type.
Definition SlopeReconstruction1DInterface.h:161

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

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 Fri Aug 21 2026 13:43:51 for https://mooseframework.inl.gov by doxygen 1.9.8