forked from idaholab/moose
/
Limiter.C
90 lines (72 loc) · 2.18 KB
/
Limiter.C
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
//* This file is part of the MOOSE framework
//* https://www.mooseframework.org
//*
//* All rights reserved, see COPYRIGHT for full restrictions
//* https://github.com/idaholab/moose/blob/master/COPYRIGHT
//*
//* Licensed under LGPL 2.1, please see LICENSE for details
//* https://www.gnu.org/licenses/lgpl-2.1.html
#include "MooseEnum.h"
#include "VanLeerLimiter.h"
#include "UpwindLimiter.h"
#include "CentralDifferenceLimiter.h"
#include "MinModLimiter.h"
#include "SOULimiter.h"
#include "QUICKLimiter.h"
#include "MooseError.h"
#include "MathFVUtils.h"
#include <memory>
namespace Moose
{
namespace FV
{
const MooseEnum
moose_limiter_type("vanLeer=0 upwind=1 central_difference=2 min_mod=3 sou=4 quick=5", "upwind");
template <typename T>
std::unique_ptr<Limiter<T>>
Limiter<T>::build(const LimiterType limiter)
{
switch (limiter)
{
case LimiterType::VanLeer:
return std::make_unique<VanLeerLimiter<T>>();
case LimiterType::Upwind:
return std::make_unique<UpwindLimiter<T>>();
case LimiterType::CentralDifference:
return std::make_unique<CentralDifferenceLimiter<T>>();
case LimiterType::MinMod:
return std::make_unique<MinModLimiter<T>>();
case LimiterType::SOU:
return std::make_unique<SOULimiter<T>>();
case LimiterType::QUICK:
return std::make_unique<QUICKLimiter<T>>();
default:
mooseError("Unrecognized limiter type ", unsigned(limiter));
}
}
LimiterType
limiterType(const InterpMethod interp_method)
{
switch (interp_method)
{
case InterpMethod::Average:
return LimiterType::CentralDifference;
case InterpMethod::Upwind:
return LimiterType::Upwind;
case InterpMethod::VanLeer:
return LimiterType::VanLeer;
case InterpMethod::MinMod:
return LimiterType::MinMod;
case InterpMethod::SOU:
return LimiterType::SOU;
case InterpMethod::QUICK:
return LimiterType::QUICK;
default:
mooseError("Unrecognized interpolation method type.");
}
}
// instantiations we care about
template std::unique_ptr<Limiter<Real>> Limiter<Real>::build(const LimiterType limiter);
template std::unique_ptr<Limiter<ADReal>> Limiter<ADReal>::build(const LimiterType limiter);
}
}