[P]arallel [Hi]gh-order [Li]brary for [P]DEs  Latest
Parallel High-Order Library for PDEs through hp-adaptive Discontinuous Galerkin methods
flow_solver_factory.cpp
1 #include "flow_solver_factory.h"
2 
3 #include <stdlib.h>
4 
5 // all flow solver cases:
6 #include "flow_solver_cases/periodic_turbulence.h"
7 #include "flow_solver_cases/periodic_1D_unsteady.h"
8 #include "flow_solver_cases/periodic_entropy_tests.h"
9 #include "flow_solver_cases/1D_burgers_rewienski_snapshot.h"
10 #include "flow_solver_cases/1d_burgers_viscous_snapshot.h"
11 #include "flow_solver_cases/naca0012.h"
12 #include "flow_solver_cases/gaussian_bump.h"
13 #include "flow_solver_cases/non_periodic_cube_flow.h"
14 #include "flow_solver_cases/limiter_convergence_tests.h"
15 
16 namespace PHiLiP {
17 
18 namespace FlowSolver {
19 
20 //=========================================================
21 // FLOW SOLVER FACTORY
22 //=========================================================
23 template <int dim, int nstate>
24 std::unique_ptr < FlowSolver<dim,nstate> >
26 ::select_flow_case(const Parameters::AllParameters *const parameters_input,
27  const dealii::ParameterHandler &parameter_handler_input)
28 {
29  // Get the flow case type
30  using FlowCaseEnum = Parameters::FlowSolverParam::FlowCaseType;
31  const FlowCaseEnum flow_type = parameters_input->flow_solver_param.flow_case_type;
32  if (flow_type == FlowCaseEnum::taylor_green_vortex){
33  if constexpr (dim==3 && nstate==dim+2){
34  std::shared_ptr<FlowSolverCaseBase<dim, nstate>> flow_solver_case = std::make_shared<PeriodicTurbulence<dim,nstate>>(parameters_input);
35  return std::make_unique<FlowSolver<dim,nstate>>(parameters_input, flow_solver_case, parameter_handler_input);
36  }
37  } else if (flow_type == FlowCaseEnum::decaying_homogeneous_isotropic_turbulence){
38  if constexpr (dim==3 && nstate==dim+2){
39  std::shared_ptr<FlowSolverCaseBase<dim, nstate>> flow_solver_case = std::make_shared<PeriodicTurbulence<dim,nstate>>(parameters_input);
40  return std::make_unique<FlowSolver<dim,nstate>>(parameters_input, flow_solver_case, parameter_handler_input);
41  }
42  } else if (flow_type == FlowCaseEnum::burgers_viscous_snapshot){
43  if constexpr (dim==1 && nstate==dim) {
44  std::shared_ptr<FlowSolverCaseBase<dim, nstate>> flow_solver_case = std::make_shared<BurgersViscousSnapshot<dim,nstate>>(parameters_input);
45  return std::make_unique<FlowSolver<dim,nstate>>(parameters_input, flow_solver_case, parameter_handler_input);
46  }
47  } else if (flow_type == FlowCaseEnum::burgers_rewienski_snapshot){
48  if constexpr (dim==1 && nstate==dim){
49  std::shared_ptr<FlowSolverCaseBase<dim, nstate>> flow_solver_case = std::make_shared<BurgersRewienskiSnapshot<dim,nstate>>(parameters_input);
50  return std::make_unique<FlowSolver<dim,nstate>>(parameters_input, flow_solver_case, parameter_handler_input);
51  }
52  } else if (flow_type == FlowCaseEnum::naca0012){
53  if constexpr (dim==2 && nstate==dim+2){
54  std::shared_ptr<FlowSolverCaseBase<dim, nstate>> flow_solver_case = std::make_shared<NACA0012<dim,nstate>>(parameters_input);
55  return std::make_unique<FlowSolver<dim,nstate>>(parameters_input, flow_solver_case, parameter_handler_input);
56  }
57  } else if (flow_type == FlowCaseEnum::periodic_1D_unsteady){
58  if constexpr (dim==1 && nstate==dim){
59  std::shared_ptr<FlowSolverCaseBase<dim, nstate>> flow_solver_case = std::make_shared<Periodic1DUnsteady<dim,nstate>>(parameters_input);
60  return std::make_unique<FlowSolver<dim,nstate>>(parameters_input, flow_solver_case, parameter_handler_input);
61  }
62  } else if (flow_type == FlowCaseEnum::isentropic_vortex){
63  if constexpr (nstate==dim+2 && dim!=1){
64  std::shared_ptr<FlowSolverCaseBase<dim, nstate>> flow_solver_case = std::make_shared<PeriodicEntropyTests<dim,nstate>>(parameters_input);
65  return std::make_unique<FlowSolver<dim,nstate>>(parameters_input, flow_solver_case, parameter_handler_input);
66  }
67  } else if (flow_type == FlowCaseEnum::gaussian_bump){
68  if constexpr (dim>1 && nstate==dim+2){
69  std::shared_ptr<FlowSolverCaseBase<dim, nstate>> flow_solver_case = std::make_shared<GaussianBump<dim, nstate>>(parameters_input);
70  return std::make_unique<FlowSolver<dim, nstate>>(parameters_input, flow_solver_case, parameter_handler_input);
71  }
72  } else if (flow_type == FlowCaseEnum::kelvin_helmholtz_instability){
73  if constexpr (dim==2 && nstate==dim+2){
74  std::shared_ptr<FlowSolverCaseBase<dim, nstate>> flow_solver_case = std::make_shared<PeriodicEntropyTests<dim,nstate>>(parameters_input);
75  return std::make_unique<FlowSolver<dim,nstate>>(parameters_input, flow_solver_case, parameter_handler_input);
76  }
77  } else if (flow_type == FlowCaseEnum::non_periodic_cube_flow){
78  if constexpr (dim==2 && nstate==1){
79  std::shared_ptr<FlowSolverCaseBase<dim, nstate>> flow_solver_case = std::make_shared<NonPeriodicCubeFlow<dim, nstate>>(parameters_input);
80  return std::make_unique<FlowSolver<dim, nstate>>(parameters_input, flow_solver_case, parameter_handler_input);
81  }
82  } else if (flow_type == FlowCaseEnum::sod_shock_tube){
83  if constexpr (dim==1 && nstate==dim+2){
84  std::shared_ptr<FlowSolverCaseBase<dim, nstate>> flow_solver_case = std::make_shared<NonPeriodicCubeFlow<dim, nstate>>(parameters_input);
85  return std::make_unique<FlowSolver<dim, nstate>>(parameters_input, flow_solver_case, parameter_handler_input);
86  }
87  } else if (flow_type == FlowCaseEnum::leblanc_shock_tube){
88  if constexpr (dim==1 && nstate==dim+2){
89  std::shared_ptr<FlowSolverCaseBase<dim, nstate>> flow_solver_case = std::make_shared<NonPeriodicCubeFlow<dim, nstate>>(parameters_input);
90  return std::make_unique<FlowSolver<dim, nstate>>(parameters_input, flow_solver_case, parameter_handler_input);
91  }
92  } else if (flow_type == FlowCaseEnum::shu_osher_problem) {
93  if constexpr (dim == 1 && nstate == dim + 2) {
94  std::shared_ptr<FlowSolverCaseBase<dim, nstate>> flow_solver_case = std::make_shared<NonPeriodicCubeFlow<dim, nstate>>(parameters_input);
95  return std::make_unique<FlowSolver<dim, nstate>>(parameters_input, flow_solver_case, parameter_handler_input);
96  }
97  } else if (flow_type == FlowCaseEnum::advection_limiter) {
98  if constexpr (dim < 3 && nstate == 1) {
99  std::shared_ptr<FlowSolverCaseBase<dim, nstate>> flow_solver_case = std::make_shared<LimiterConvergenceTests<dim, nstate>>(parameters_input);
100  return std::make_unique<FlowSolver<dim, nstate>>(parameters_input, flow_solver_case, parameter_handler_input);
101  }
102  } else if (flow_type == FlowCaseEnum::burgers_limiter) {
103  if constexpr (dim < 3 && nstate == dim) {
104  std::shared_ptr<FlowSolverCaseBase<dim, nstate>> flow_solver_case = std::make_shared<LimiterConvergenceTests<dim, nstate>>(parameters_input);
105  return std::make_unique<FlowSolver<dim, nstate>>(parameters_input, flow_solver_case, parameter_handler_input);
106  }
107  } else if (flow_type == FlowCaseEnum::low_density_2d) {
108  if constexpr (dim == 2 && nstate == dim + 2) {
109  std::shared_ptr<FlowSolverCaseBase<dim, nstate>> flow_solver_case = std::make_shared<LimiterConvergenceTests<dim, nstate>>(parameters_input);
110  return std::make_unique<FlowSolver<dim, nstate>>(parameters_input, flow_solver_case, parameter_handler_input);
111  }
112  } else {
113  std::cout << "Invalid flow case. You probably forgot to add it to the list of flow cases in flow_solver_factory.cpp" << std::endl;
114  std::abort();
115  }
116  return nullptr;
117 }
118 
119 template<int dim, int nstate>
120 std::unique_ptr< FlowSolverBase > FlowSolverFactory<dim,nstate>
121 ::create_flow_solver(const Parameters::AllParameters *const parameters_input,
122  const dealii::ParameterHandler &parameter_handler_input)
123 {
124  // Recursive templating required because template parameters must be compile time constants
125  // As a results, this recursive template initializes all possible dimensions with all possible nstate
126  // without having 15 different if-else statements
127  if(dim == parameters_input->dimension)
128  {
129  // This template parameters dim and nstate match the runtime parameters
130  // then create the selected flow case with template parameters dim and nstate
131  // Otherwise, keep decreasing nstate and dim until it matches
132  if(nstate == parameters_input->nstate)
133  return FlowSolverFactory<dim,nstate>::select_flow_case(parameters_input,parameter_handler_input);
134  else if constexpr (nstate > 1)
135  return FlowSolverFactory<dim,nstate-1>::create_flow_solver(parameters_input,parameter_handler_input);
136  else
137  return nullptr;
138  }
139  else if constexpr (dim > 1)
140  {
141  //return FlowSolverFactory<dim-1,nstate>::create_flow_solver(parameters_input);
142  return nullptr;
143  }
144  else
145  {
146  return nullptr;
147  }
148 }
149 
150 template class FlowSolverFactory <PHILIP_DIM,5>;
151 
152 } // FlowSolver namespace
153 } // PHiLiP namespace
154 
FlowCaseType
Selects the flow case to be simulated.
FlowCaseType flow_case_type
Selected FlowCaseType from the input file.
FlowSolverParam flow_solver_param
Contains the parameters for simulation cases (flow solver test)
Files for the baseline physics.
Definition: ADTypes.hpp:10
static std::unique_ptr< FlowSolverBase > create_flow_solver(const Parameters::AllParameters *const parameters_input, const dealii::ParameterHandler &parameter_handler_input)
Recursive factory that will create FlowSolverBase (i.e. FlowSolver<dim,nstate>)
unsigned int dimension
Number of dimensions. Note that it has to match the executable PHiLiP_xD.
Main parameter class that contains the various other sub-parameter classes.
static std::unique_ptr< FlowSolver< dim, nstate > > select_flow_case(const Parameters::AllParameters *const parameters_input, const dealii::ParameterHandler &parameter_handler_input)
Factory to return the correct flow solver given input file.
int nstate
Number of state variables. Will depend on PDE.
Create specified flow solver as FlowSolver object.