[P]arallel [Hi]gh-order [Li]brary for [P]DEs  Latest
Parallel High-Order Library for PDEs through hp-adaptive Discontinuous Galerkin methods
model_factory.cpp
1 #include "parameters/all_parameters.h"
2 #include "parameters/parameters_manufactured_solution.h"
3 
4 #include <deal.II/base/tensor.h>
5 
6 #include "ADTypes.hpp"
7 
8 #include "model_factory.h"
9 #include "manufactured_solution.h"
10 #include "large_eddy_simulation.h"
11 #include "reynolds_averaged_navier_stokes.h"
12 #include "negative_spalart_allmaras_rans_model.h"
13 
14 namespace PHiLiP {
15 namespace Physics {
16 
17 template <int dim, int nstate, typename real>
18 std::shared_ptr < ModelBase<dim,nstate,real> >
19 ModelFactory<dim,nstate,real>
20 ::create_Model(const Parameters::AllParameters *const parameters_input)
21 {
22  using PDE_enum = Parameters::AllParameters::PartialDifferentialEquation;
23  PDE_enum pde_type = parameters_input->pde_type;
24 
25  if(pde_type == PDE_enum::physics_model) {
26  // generating the manufactured solution from the manufactured solution factory
27  std::shared_ptr< ManufacturedSolutionFunction<dim,real> > manufactured_solution_function
28  = ManufacturedSolutionFactory<dim,real>::create_ManufacturedSolution(parameters_input, nstate);
29 
30  using Model_enum = Parameters::AllParameters::ModelType;
31  Model_enum model_type = parameters_input->model_type;
32 
33  // ===============================================================================
34  // Model
35  // ===============================================================================
36  // -------------------------------------------------------------------------------
37  // Large Eddy Simulation (LES)
38  // -------------------------------------------------------------------------------
39  if (model_type == Model_enum::large_eddy_simulation) {
40  if constexpr ((nstate==dim+2) && (dim==3)) {
41  // Create Large Eddy Simulation (LES) model based on the SGS model type
42  using SGS_enum = Parameters::PhysicsModelParam::SubGridScaleModel;
43  SGS_enum sgs_model_type = parameters_input->physics_model_param.SGS_model_type;
44  if (sgs_model_type == SGS_enum::smagorinsky) {
45  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
46  // Smagorinsky model
47  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
48  return std::make_shared < LargeEddySimulation_Smagorinsky<dim,nstate,real> > (
49  parameters_input,
50  parameters_input->euler_param.ref_length,
51  parameters_input->euler_param.gamma_gas,
52  parameters_input->euler_param.mach_inf,
53  parameters_input->euler_param.angle_of_attack,
54  parameters_input->euler_param.side_slip_angle,
55  parameters_input->navier_stokes_param.prandtl_number,
56  parameters_input->navier_stokes_param.reynolds_number_inf,
57  parameters_input->navier_stokes_param.use_constant_viscosity,
58  parameters_input->navier_stokes_param.nondimensionalized_constant_viscosity,
59  parameters_input->navier_stokes_param.temperature_inf,
60  parameters_input->physics_model_param.turbulent_prandtl_number,
61  parameters_input->physics_model_param.ratio_of_filter_width_to_cell_size,
62  parameters_input->physics_model_param.smagorinsky_model_constant,
63  parameters_input->navier_stokes_param.nondimensionalized_isothermal_wall_temperature,
64  parameters_input->navier_stokes_param.thermal_boundary_condition_type,
65  manufactured_solution_function,
66  parameters_input->two_point_num_flux_type);
67  } else if (sgs_model_type == SGS_enum::wall_adaptive_local_eddy_viscosity) {
68  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
69  // WALE (Wall-Adapting Local Eddy-viscosity) eddy viscosity model
70  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
71  return std::make_shared < LargeEddySimulation_WALE<dim,nstate,real> > (
72  parameters_input,
73  parameters_input->euler_param.ref_length,
74  parameters_input->euler_param.gamma_gas,
75  parameters_input->euler_param.mach_inf,
76  parameters_input->euler_param.angle_of_attack,
77  parameters_input->euler_param.side_slip_angle,
78  parameters_input->navier_stokes_param.prandtl_number,
79  parameters_input->navier_stokes_param.reynolds_number_inf,
80  parameters_input->navier_stokes_param.use_constant_viscosity,
81  parameters_input->navier_stokes_param.nondimensionalized_constant_viscosity,
82  parameters_input->navier_stokes_param.temperature_inf,
83  parameters_input->physics_model_param.turbulent_prandtl_number,
84  parameters_input->physics_model_param.ratio_of_filter_width_to_cell_size,
85  parameters_input->physics_model_param.WALE_model_constant,
86  parameters_input->navier_stokes_param.nondimensionalized_isothermal_wall_temperature,
87  parameters_input->navier_stokes_param.thermal_boundary_condition_type,
88  manufactured_solution_function,
89  parameters_input->two_point_num_flux_type);
90  } else if (sgs_model_type == SGS_enum::vreman) {
91  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
92  // Vreman eddy viscosity model
93  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
94  return std::make_shared < LargeEddySimulation_Vreman<dim,nstate,real> > (
95  parameters_input,
96  parameters_input->euler_param.ref_length,
97  parameters_input->euler_param.gamma_gas,
98  parameters_input->euler_param.mach_inf,
99  parameters_input->euler_param.angle_of_attack,
100  parameters_input->euler_param.side_slip_angle,
101  parameters_input->navier_stokes_param.prandtl_number,
102  parameters_input->navier_stokes_param.reynolds_number_inf,
103  parameters_input->navier_stokes_param.use_constant_viscosity,
104  parameters_input->navier_stokes_param.nondimensionalized_constant_viscosity,
105  parameters_input->navier_stokes_param.temperature_inf,
106  parameters_input->physics_model_param.turbulent_prandtl_number,
107  parameters_input->physics_model_param.ratio_of_filter_width_to_cell_size,
108  parameters_input->physics_model_param.vreman_model_constant,
109  parameters_input->navier_stokes_param.nondimensionalized_isothermal_wall_temperature,
110  parameters_input->navier_stokes_param.thermal_boundary_condition_type,
111  manufactured_solution_function,
112  parameters_input->two_point_num_flux_type);
113  }
114  else {
115  std::cout << "Can't create LargeEddySimulationBase, invalid SGSModelType type: " << sgs_model_type << std::endl;
116  assert(0==1 && "Can't create LargeEddySimulationBase, invalid SGSModelType type");
117  return nullptr;
118  }
119  }
120  else {
121  // LES does not exist for nstate!=(dim+2) || dim!=3
122  manufactured_solution_function = nullptr;
123  return nullptr;
124  }
125  }
126  // -------------------------------------------------------------------------------
127  // Reynolds-Averaged Navier-Stokes (RANS) + RANS model
128  // -------------------------------------------------------------------------------
129  else if (model_type == Model_enum::reynolds_averaged_navier_stokes) {
130  using RANSModel_enum = Parameters::PhysicsModelParam::ReynoldsAveragedNavierStokesModel;
131  RANSModel_enum rans_model_type = parameters_input->physics_model_param.RANS_model_type;
132  // Create Reynolds-Averaged Navier-Stokes (RANS) model with one-equation model
133  if(rans_model_type == RANSModel_enum::SA_negative){
134  if constexpr (nstate==dim+3) {
135  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
136  // SA negative model
137  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
138  return std::make_shared < ReynoldsAveragedNavierStokes_SAneg<dim,nstate,real> > (
139  parameters_input,
140  parameters_input->euler_param.ref_length,
141  parameters_input->euler_param.gamma_gas,
142  parameters_input->euler_param.mach_inf,
143  parameters_input->euler_param.angle_of_attack,
144  parameters_input->euler_param.side_slip_angle,
145  parameters_input->navier_stokes_param.prandtl_number,
146  parameters_input->navier_stokes_param.reynolds_number_inf,
147  parameters_input->navier_stokes_param.use_constant_viscosity,
148  parameters_input->navier_stokes_param.nondimensionalized_constant_viscosity,
149  parameters_input->physics_model_param.turbulent_prandtl_number,
150  parameters_input->navier_stokes_param.temperature_inf,
151  parameters_input->navier_stokes_param.nondimensionalized_isothermal_wall_temperature,
152  parameters_input->navier_stokes_param.thermal_boundary_condition_type,
153  manufactured_solution_function,
154  parameters_input->two_point_num_flux_type);
155  }
156  else {
157  // SA negative does not exist for nstate!=(dim+3)
158  manufactured_solution_function = nullptr;
159  return nullptr;
160  }
161  }
162  else {
163  std::cout << "Can't create ReynoldsAveragedNavierStokesBase, invalid RANSModelType type: " << rans_model_type << std::endl;
164  assert(0==1 && "Can't create ReynoldsAveragedNavierStokesBase, invalid RANSModelType type");
165  return nullptr;
166  }
167  }
168  else {
169  // prevent warnings for dim=3,nstate=4, etc.
170  // to avoid "unused variable" warnings
171  std::cout << "Can't create ModelBase, invalid ModelType type: " << model_type << std::endl;
172  assert(0==1 && "Can't create ModelBase, invalid ModelType type");
173  manufactured_solution_function = nullptr;
174  return nullptr;
175  }
176  }
177  else {
178  return nullptr;
179  }
180 }
181 
182 //----------------------------------------------------------------
183 //----------------------------------------------------------------
184 //----------------------------------------------------------------
185 // Instantiate explicitly
186 template class ModelFactory<PHILIP_DIM, 1, double>;
187 template class ModelFactory<PHILIP_DIM, 2, double>;
188 template class ModelFactory<PHILIP_DIM, 3, double>;
189 template class ModelFactory<PHILIP_DIM, 4, double>;
190 template class ModelFactory<PHILIP_DIM, 5, double>;
191 template class ModelFactory<PHILIP_DIM, 6, double>;
192 template class ModelFactory<PHILIP_DIM, 8, double>;
193 
194 template class ModelFactory<PHILIP_DIM, 1, FadType>;
195 template class ModelFactory<PHILIP_DIM, 2, FadType>;
196 template class ModelFactory<PHILIP_DIM, 3, FadType>;
197 template class ModelFactory<PHILIP_DIM, 4, FadType>;
198 template class ModelFactory<PHILIP_DIM, 5, FadType>;
199 template class ModelFactory<PHILIP_DIM, 6, FadType>;
200 template class ModelFactory<PHILIP_DIM, 8, FadType>;
201 
202 template class ModelFactory<PHILIP_DIM, 1, RadType>;
203 template class ModelFactory<PHILIP_DIM, 2, RadType>;
204 template class ModelFactory<PHILIP_DIM, 3, RadType>;
205 template class ModelFactory<PHILIP_DIM, 4, RadType>;
206 template class ModelFactory<PHILIP_DIM, 5, RadType>;
207 template class ModelFactory<PHILIP_DIM, 6, RadType>;
208 template class ModelFactory<PHILIP_DIM, 8, RadType>;
209 
210 template class ModelFactory<PHILIP_DIM, 1, FadFadType>;
211 template class ModelFactory<PHILIP_DIM, 2, FadFadType>;
212 template class ModelFactory<PHILIP_DIM, 3, FadFadType>;
213 template class ModelFactory<PHILIP_DIM, 4, FadFadType>;
214 template class ModelFactory<PHILIP_DIM, 5, FadFadType>;
215 template class ModelFactory<PHILIP_DIM, 6, FadFadType>;
216 template class ModelFactory<PHILIP_DIM, 8, FadFadType>;
217 
218 template class ModelFactory<PHILIP_DIM, 1, RadFadType>;
219 template class ModelFactory<PHILIP_DIM, 2, RadFadType>;
220 template class ModelFactory<PHILIP_DIM, 3, RadFadType>;
221 template class ModelFactory<PHILIP_DIM, 4, RadFadType>;
222 template class ModelFactory<PHILIP_DIM, 5, RadFadType>;
223 template class ModelFactory<PHILIP_DIM, 6, RadFadType>;
224 template class ModelFactory<PHILIP_DIM, 8, RadFadType>;
225 
226 } // Physics namespace
227 } // PHiLiP namespace
228 
PHiLiP::Parameters::AllParameters::pde_type
PartialDifferentialEquation pde_type
Store the PDE type to be solved.
Definition: all_parameters.h:236
PHiLiP::ManufacturedSolutionFactory::create_ManufacturedSolution
static std::shared_ptr< ManufacturedSolutionFunction< dim, real > > create_ManufacturedSolution(Parameters::AllParameters const *const param, int nstate)
Construct Manufactured solution object from global parameter file.
Definition: manufactured_solution.cpp:1200
PHiLiP::Parameters::AllParameters::PartialDifferentialEquation
PartialDifferentialEquation
Possible Partial Differential Equations to solve.
Definition: all_parameters.h:222
PHiLiP
Files for the baseline physics.
Definition: ADTypes.hpp:10
PHiLiP::Parameters::AllParameters::euler_param
EulerParam euler_param
Contains parameters for the Euler equations non-dimensionalization.
Definition: all_parameters.h:46
PHiLiP::Parameters::AllParameters::ModelType
ModelType
Types of models available.
Definition: all_parameters.h:239
PHiLiP::Parameters::AllParameters
Main parameter class that contains the various other sub-parameter classes.
Definition: all_parameters.h:33
PHiLiP::Parameters::PhysicsModelParam::SGS_model_type
SubGridScaleModel SGS_model_type
Store the SubGridScale (SGS) model type.
Definition: parameters_physics_model.h:25
PHiLiP::Parameters::EulerParam::ref_length
double ref_length
Reference length.
Definition: parameters_euler.h:12
PHiLiP::Physics::ModelFactory::create_Model
static std::shared_ptr< ModelBase< dim, nstate, real > > create_Model(const Parameters::AllParameters *const parameters_input)
Factory to return the correct model given input parameters.
Definition: model_factory.cpp:20
PHiLiP::Parameters::PhysicsModelParam::ReynoldsAveragedNavierStokesModel
ReynoldsAveragedNavierStokesModel
Types of Reynolds-averaged Navier-Stokes (RANS) models that can be used.
Definition: parameters_physics_model.h:28
PHiLiP::Parameters::PhysicsModelParam::RANS_model_type
ReynoldsAveragedNavierStokesModel RANS_model_type
Store the Reynolds-averaged Navier-Stokes (RANS) model type.
Definition: parameters_physics_model.h:33
PHiLiP::Physics::ModelFactory
Create specified model as ModelBase object.
Definition: model_factory.h:13
PHiLiP::Parameters::PhysicsModelParam::SubGridScaleModel
SubGridScaleModel
Types of sub-grid scale (SGS) models that can be used.
Definition: parameters_physics_model.h:19
PHiLiP::Parameters::AllParameters::model_type
ModelType model_type
Store the model type.
Definition: all_parameters.h:244
PHiLiP::Parameters::AllParameters::physics_model_param
PhysicsModelParam physics_model_param
Contains parameters for Physics Model.
Definition: all_parameters.h:56