VertexCFD  0.0-dev
VertexCFD_TurbulenceBoundaryState_Factory.hpp
1 #ifndef VERTEXCFD_TURBULENCEBOUNDARYSTATE_FACTORY_HPP
2 #define VERTEXCFD_TURBULENCEBOUNDARYSTATE_FACTORY_HPP
3 
4 #include "closure_models/VertexCFD_Closure_ElementLength.hpp"
5 #include "closure_models/VertexCFD_Closure_MeasureElementLength.hpp"
6 #include "closure_models/VertexCFD_Closure_MetricTensorElementLength.hpp"
7 #include "closure_models/VertexCFD_Closure_SingularValueElementLength.hpp"
8 #include "closure_models/VertexCFD_Closure_WallDistance.hpp"
9 
10 #include "boundary_conditions/VertexCFD_BoundaryState_VariableExtrapolate.hpp"
11 #include "boundary_conditions/VertexCFD_BoundaryState_VariableFixed.hpp"
12 
13 #include "turbulence_models/boundary_conditions/VertexCFD_BoundaryState_TurbulenceInletOutlet.hpp"
14 #include "turbulence_models/boundary_conditions/VertexCFD_BoundaryState_TurbulenceKEpsilonWallFunction.hpp"
15 #include "turbulence_models/boundary_conditions/VertexCFD_BoundaryState_TurbulenceKOmegaWallResolved.hpp"
16 #include "turbulence_models/boundary_conditions/VertexCFD_BoundaryState_TurbulenceSymmetry.hpp"
17 #include "turbulence_models/closure_models/VertexCFD_Closure_IncompressibleKEpsilonDiffusivityCoefficient.hpp"
18 #include "turbulence_models/closure_models/VertexCFD_Closure_IncompressibleKEpsilonEddyViscosity.hpp"
19 #include "turbulence_models/closure_models/VertexCFD_Closure_IncompressibleKOmegaDiffusivityCoefficient.hpp"
20 #include "turbulence_models/closure_models/VertexCFD_Closure_IncompressibleKOmegaEddyViscosity.hpp"
21 #include "turbulence_models/closure_models/VertexCFD_Closure_IncompressibleKTauDiffusivityCoefficient.hpp"
22 #include "turbulence_models/closure_models/VertexCFD_Closure_IncompressibleKTauEddyViscosity.hpp"
23 #include "turbulence_models/closure_models/VertexCFD_Closure_IncompressibleRealizableKEpsilonEddyViscosity.hpp"
24 #include "turbulence_models/closure_models/VertexCFD_Closure_IncompressibleSSTDiffusivityCoefficient.hpp"
25 #include "turbulence_models/closure_models/VertexCFD_Closure_IncompressibleSSTEddyViscosity.hpp"
26 #include "turbulence_models/closure_models/VertexCFD_Closure_IncompressibleSpalartAllmarasDiffusivityCoefficient.hpp"
27 #include "turbulence_models/closure_models/VertexCFD_Closure_IncompressibleSpalartAllmarasEddyViscosity.hpp"
28 #include "turbulence_models/closure_models/VertexCFD_Closure_IncompressibleWALEEddyViscosity.hpp"
29 
30 #include <Panzer_Evaluator_WithBaseImpl.hpp>
31 
32 #include <Teuchos_ParameterList.hpp>
33 #include <Teuchos_RCP.hpp>
34 
35 namespace VertexCFD
36 {
37 namespace BoundaryCondition
38 {
39 //---------------------------------------------------------------------------//
40 template<class EvalType, class Traits, int NumSpaceDim>
41 class TurbulenceBoundaryStateFactory
42 {
43  public:
44  static std::vector<Teuchos::RCP<PHX::Evaluator<Traits>>>
45  create(const panzer::IntegrationRule& ir,
46  const Teuchos::ParameterList& bc_params,
47  const Teuchos::ParameterList& user_params,
48  const std::string _turbulence_model_name)
49  {
50  // Evaluator vector to return
51  std::vector<Teuchos::RCP<PHX::Evaluator<panzer::Traits>>> evaluators;
52 
53  // Adding diffusivity coefficient closure model and initializing
54  // `turb_field_names_vct` for each equation of the turbulence model
55  std::vector<std::string> turb_field_names_vct;
56  if (_turbulence_model_name != "No Turbulence Model")
57  {
58  // Spalart-Allmaras model family
59  if (std::string::npos
60  != _turbulence_model_name.find("Spalart-Allmaras"))
61  {
62  // Variable name
63  turb_field_names_vct.push_back("spalart_allmaras_variable");
64 
65  // Diffusive coefficient
66  const auto diffusive_coeff_op = Teuchos::rcp(
67  new ClosureModel::IncompressibleSpalartAllmarasDiffusivityCoefficient<
68  EvalType,
69  panzer::Traits>(ir));
70  evaluators.push_back(diffusive_coeff_op);
71 
72  // Turbulent eddy viscosity
73  const auto eddy_visc_op = Teuchos::rcp(
74  new ClosureModel::IncompressibleSpalartAllmarasEddyViscosity<
75  EvalType,
76  panzer::Traits>(ir));
77  evaluators.push_back(eddy_visc_op);
78  }
79  // K-Epsilon model family
80  else if (std::string::npos
81  != _turbulence_model_name.find("K-Epsilon"))
82  {
83  // K-Epsilon turbulence variable names
84  turb_field_names_vct.push_back("turb_kinetic_energy");
85  turb_field_names_vct.push_back("turb_dissipation_rate");
86 
87  // Realizable K-Epsilon closure models
88  if (std::string::npos
89  != _turbulence_model_name.find("Realizable K-Epsilon"))
90  {
91  // Diffusive coefficient with non-standard coefficients
92  const auto diffusive_coeff_op = Teuchos::rcp(
93  new ClosureModel::IncompressibleKEpsilonDiffusivityCoefficient<
94  EvalType,
95  panzer::Traits>(ir, 1.0, 1.2, "BOUNDARY_"));
96  evaluators.push_back(diffusive_coeff_op);
97 
98  // Turbulent eddy viscosity
99  const auto eddy_visc_op = Teuchos::rcp(
100  new ClosureModel::IncompressibleRealizableKEpsilonEddyViscosity<
101  EvalType,
102  panzer::Traits,
103  NumSpaceDim>(ir));
104  evaluators.push_back(eddy_visc_op);
105  }
106  // Standard K-Epsilon closure models
107  else
108  {
109  // Diffusive coefficient
110  const auto diffusive_coeff_op = Teuchos::rcp(
111  new ClosureModel::IncompressibleKEpsilonDiffusivityCoefficient<
112  EvalType,
113  panzer::Traits>(ir, 1.0, 1.3, "BOUNDARY_"));
114  evaluators.push_back(diffusive_coeff_op);
115 
116  // Turbulent eddy viscosity
117  const auto eddy_visc_op = Teuchos::rcp(
118  new ClosureModel::IncompressibleKEpsilonEddyViscosity<
119  EvalType,
120  panzer::Traits>(ir));
121  evaluators.push_back(eddy_visc_op);
122  }
123  }
124  // K-Omega model family
125  else if (std::string::npos
126  != _turbulence_model_name.find("K-Omega"))
127  {
128  // K-Omega turbulence variable names
129  turb_field_names_vct.push_back("turb_kinetic_energy");
130  turb_field_names_vct.push_back(
131  "turb_specific_dissipation_rate");
132 
133  // K-Omega closure models
134  const auto eval_coeff = Teuchos::rcp(
135  new ClosureModel::IncompressibleKOmegaDiffusivityCoefficient<
136  EvalType,
137  panzer::Traits>(ir, user_params));
138  evaluators.push_back(eval_coeff);
139 
140  const auto eval_eddy = Teuchos::rcp(
141  new ClosureModel::IncompressibleKOmegaEddyViscosity<
142  EvalType,
143  panzer::Traits,
144  NumSpaceDim>(ir, user_params));
145  evaluators.push_back(eval_eddy);
146  }
147  else if (std::string::npos != _turbulence_model_name.find("SST"))
148  {
149  // SST turbulence variable names
150  turb_field_names_vct.push_back("turb_kinetic_energy");
151  turb_field_names_vct.push_back(
152  "turb_specific_dissipation_rate");
153 
154  if (bc_params.get<std::string>("Type") == "No-Slip")
155  {
156  // SST eddy viscosity closure
157  const auto eval_eddy = Teuchos::rcp(
158  new ClosureModel::IncompressibleSSTEddyViscosity<
159  EvalType,
160  panzer::Traits,
161  NumSpaceDim>(ir, user_params, true));
162  evaluators.push_back(eval_eddy);
163  }
164  else
165  {
166  // Wall distance closure
167  const auto dist = Teuchos::rcp(
168  new ClosureModel::WallDistance<EvalType,
169  panzer::Traits,
170  NumSpaceDim>(
171  ir,
172  user_params.get<
173  Teuchos::RCP<Mesh::Topology::SidesetGeometry>>(
174  "Sideset Geometry")));
175  evaluators.push_back(dist);
176  // SST eddy viscosity closure
177  const auto eval_eddy = Teuchos::rcp(
178  new ClosureModel::IncompressibleSSTEddyViscosity<
179  EvalType,
180  panzer::Traits,
181  NumSpaceDim>(ir, user_params));
182  evaluators.push_back(eval_eddy);
183  }
184 
185  // SST diffusivity closure
186  const auto eval_coeff = Teuchos::rcp(
187  new ClosureModel::IncompressibleSSTDiffusivityCoefficient<
188  EvalType,
189  panzer::Traits>(ir, user_params));
190  evaluators.push_back(eval_coeff);
191  }
192  // K-Tau model family
193  else if (std::string::npos != _turbulence_model_name.find("K-Tau"))
194  {
195  // K-Tau turbulence variable names
196  turb_field_names_vct.push_back("turb_kinetic_energy");
197  turb_field_names_vct.push_back(
198  "turb_specific_dissipation_rate");
199 
200  // K-Tau closure models
201  const auto eval_coeff = Teuchos::rcp(
202  new ClosureModel::IncompressibleKTauDiffusivityCoefficient<
203  EvalType,
204  panzer::Traits>(ir, user_params));
205  evaluators.push_back(eval_coeff);
206 
207  const auto eval_eddy = Teuchos::rcp(
208  new ClosureModel::IncompressibleKTauEddyViscosity<
209  EvalType,
210  panzer::Traits,
211  NumSpaceDim>(ir));
212  evaluators.push_back(eval_eddy);
213  }
214  // WALE algebraic LES model
215  else if (std::string::npos != _turbulence_model_name.find("WALE"))
216  {
217  // Sub-grid eddy viscosity
218  const auto eddy_visc_op = Teuchos::rcp(
219  new ClosureModel::IncompressibleWALEEddyViscosity<
220  EvalType,
221  panzer::Traits,
222  NumSpaceDim>(ir, user_params));
223  evaluators.push_back(eddy_visc_op);
224 
225  // Delta (element length) closure model
226  const std::string delta_prefix = "les_";
227  const auto turb_params
228  = user_params.isSublist("Turbulence Parameters")
229  ? user_params.sublist("Turbulence Parameters")
230  : Teuchos::ParameterList();
231  const std::string delta_type
232  = turb_params.isType<std::string>("LES Element Length")
233  ? turb_params.get<std::string>("LES Element Length")
234  : "ElementLength";
235 
236  if (delta_type == "ElementLength")
237  {
238  auto eval_delta = Teuchos::rcp(
239  new ClosureModel::ElementLength<EvalType, panzer::Traits>(
240  ir, delta_prefix));
241 
242  evaluators.push_back(eval_delta);
243  }
244  else if (delta_type == "MeasureElementLength")
245  {
246  auto eval_delta = Teuchos::rcp(
247  new ClosureModel::MeasureElementLength<EvalType,
248  panzer::Traits>(
249  ir, delta_prefix));
250 
251  evaluators.push_back(eval_delta);
252  }
253  else if (delta_type == "MetricTensorElementLength")
254  {
255  auto eval_delta = Teuchos::rcp(
256  new ClosureModel::
257  MetricTensorElementLength<EvalType, panzer::Traits>(
258  ir, delta_prefix));
259 
260  evaluators.push_back(eval_delta);
261  }
262  else if (delta_type == "SingularValueElementLength")
263  {
264  const auto method = turb_params.get<std::string>(
265  "Element Length Method");
266 
267  auto eval_delta = Teuchos::rcp(
268  new ClosureModel::SingularValueElementLength<
269  EvalType,
270  panzer::Traits>(ir, method, delta_prefix));
271 
272  evaluators.push_back(eval_delta);
273  }
274  else
275  {
276  std::string msg = "Unknown Delta Closure Model:\n";
277 
278  msg += delta_type;
279  msg += "\n";
280  msg += "Please choose from:\n";
281  msg += "ElementLength\n";
282  msg += "MeasureElementLength\n";
283  msg += "MetricTensorElementLength\n";
284  msg += "SingularValueElementLength\n";
285 
286  throw std::runtime_error(msg);
287  }
288  }
289  }
290 
291  // Loop over boundary conditions found in input file for each
292  // turbulence model
293  bool found_model = false;
294  if (bc_params.isType<std::string>("Type")
295  && (turb_field_names_vct.size() > 0))
296  {
297  const auto bc_type = bc_params.get<std::string>("Type");
298  if (bc_type == "Fixed")
299  {
300  // Fixed boundary condition
301  for (auto& variable_name : turb_field_names_vct)
302  {
303  const auto state
304  = Teuchos::rcp(new VariableFixed<EvalType, Traits>(
305  ir, bc_params, variable_name));
306  evaluators.push_back(state);
307  }
308  found_model = true;
309  }
310 
311  else if (bc_type == "Extrapolate")
312  {
313  // Extrapolate boundary condition
314  for (auto& variable_name : turb_field_names_vct)
315  {
316  const auto state = Teuchos::rcp(
317  new VariableExtrapolate<EvalType, Traits>(
318  ir, variable_name));
319  evaluators.push_back(state);
320  }
321  found_model = true;
322  }
323 
324  else if (bc_type == "InletOutlet")
325  {
326  // Inlet/outlet boundary condition
327  for (auto& variable_name : turb_field_names_vct)
328  {
329  const auto state = Teuchos::rcp(
330  new TurbulenceInletOutlet<EvalType, Traits, NumSpaceDim>(
331  ir, bc_params, variable_name));
332  evaluators.push_back(state);
333  }
334  found_model = true;
335  }
336 
337  else if (bc_type == "Symmetry")
338  {
339  // Symmetry boundary condition
340  for (auto& variable_name : turb_field_names_vct)
341  {
342  const auto state = Teuchos::rcp(
343  new TurbulenceSymmetry<EvalType, Traits>(
344  ir, variable_name));
345  evaluators.push_back(state);
346  }
347  found_model = true;
348  }
349 
350  else if (bc_type == "K-Epsilon Wall Function")
351  {
352  // Wall functions for use with high Re K-Epsilon models
353  const auto state = Teuchos::rcp(
354  new TurbulenceKEpsilonWallFunction<EvalType, Traits, NumSpaceDim>(
355  ir, bc_params));
356  evaluators.push_back(state);
357 
358  found_model = true;
359  }
360 
361  else if (bc_type == "K-Omega Wall-Resolved")
362  {
363  const auto state = Teuchos::rcp(
364  new TurbulenceKOmegaWallResolved<EvalType, Traits>(
365  ir, bc_params));
366  evaluators.push_back(state);
367 
368  found_model = true;
369  }
370 
371  // Error message if model not found
372  if (!found_model)
373  {
374  std::string msg = "\n\nBoundary state " + bc_type
375  + " failed to build.\n";
376  msg += "The boundary conditions implemented in VERTEX-CFD\n";
377  msg += "for the turbulence model equations are:\n";
378  msg += "Extrapolate,\n";
379  msg += "Fixed,\n";
380  msg += "InletOutlet,\n";
381  msg += "K-Epsilon Wall Function,\n";
382  msg += "K-Omega Wall-Resolved,\n";
383  msg += "Symmetry\n";
384  msg += "\n";
385  throw std::runtime_error(msg);
386  }
387  }
388 
389  // Return vector of evaluators
390  return evaluators;
391  }
392 };
393 
394 //---------------------------------------------------------------------------//
395 
396 } // end namespace BoundaryCondition
397 } // end namespace VertexCFD
398 
399 #endif // end VERTEXCFD_TURBULENCEBOUNDARYSTATE_FACTORY_HPP
VertexCFD::ClosureModel::IncompressibleSpalartAllmarasEddyViscosity
Definition: VertexCFD_Closure_IncompressibleSpalartAllmarasEddyViscosity.hpp:27
VertexCFD
Definition: tstMethodManufacturedSolutionBC.cpp:23
VertexCFD::ClosureModel::IncompressibleKTauEddyViscosity
Definition: VertexCFD_Closure_IncompressibleKTauEddyViscosity.hpp:25
VertexCFD::ClosureModel::IncompressibleSpalartAllmarasDiffusivityCoefficient
Definition: VertexCFD_Closure_IncompressibleSpalartAllmarasDiffusivityCoefficient.hpp:27
VertexCFD::BoundaryCondition::TurbulenceBoundaryStateFactory
Definition: VertexCFD_TurbulenceBoundaryState_Factory.hpp:42
VertexCFD::BoundaryCondition::TurbulenceKEpsilonWallFunction
Definition: VertexCFD_BoundaryState_TurbulenceKEpsilonWallFunction.hpp:26
VertexCFD::ClosureModel::IncompressibleSSTEddyViscosity
Definition: VertexCFD_Closure_IncompressibleSSTEddyViscosity.hpp:25
VertexCFD::ClosureModel::IncompressibleWALEEddyViscosity
Definition: VertexCFD_Closure_IncompressibleWALEEddyViscosity.hpp:25
VertexCFD::ClosureModel::IncompressibleKEpsilonDiffusivityCoefficient
Definition: VertexCFD_Closure_IncompressibleKEpsilonDiffusivityCoefficient.hpp:25
VertexCFD::BoundaryCondition::TurbulenceInletOutlet
Definition: VertexCFD_BoundaryState_TurbulenceInletOutlet.hpp:22
VertexCFD::ClosureModel::IncompressibleKOmegaEddyViscosity
Definition: VertexCFD_Closure_IncompressibleKOmegaEddyViscosity.hpp:25
VertexCFD::BoundaryCondition::TurbulenceSymmetry
Definition: VertexCFD_BoundaryState_TurbulenceSymmetry.hpp:22
VertexCFD::ClosureModel::MeasureElementLength
Definition: VertexCFD_Closure_MeasureElementLength.hpp:22
VertexCFD::BoundaryCondition::VariableFixed
Definition: VertexCFD_BoundaryState_VariableFixed.hpp:22
VertexCFD::ClosureModel::IncompressibleKOmegaDiffusivityCoefficient
Definition: VertexCFD_Closure_IncompressibleKOmegaDiffusivityCoefficient.hpp:25
VertexCFD::ClosureModel::IncompressibleKEpsilonEddyViscosity
Definition: VertexCFD_Closure_IncompressibleKEpsilonEddyViscosity.hpp:25
VertexCFD::BoundaryCondition::VariableExtrapolate
Definition: VertexCFD_BoundaryState_VariableExtrapolate.hpp:22
VertexCFD::ClosureModel::IncompressibleKTauDiffusivityCoefficient
Definition: VertexCFD_Closure_IncompressibleKTauDiffusivityCoefficient.hpp:25
VertexCFD::ClosureModel::SingularValueElementLength
Definition: VertexCFD_Closure_SingularValueElementLength.hpp:23
VertexCFD::ClosureModel::IncompressibleRealizableKEpsilonEddyViscosity
Definition: VertexCFD_Closure_IncompressibleRealizableKEpsilonEddyViscosity.hpp:25
VertexCFD::ClosureModel::IncompressibleSSTDiffusivityCoefficient
Definition: VertexCFD_Closure_IncompressibleSSTDiffusivityCoefficient.hpp:25
VertexCFD::BoundaryCondition::TurbulenceKOmegaWallResolved
Definition: VertexCFD_BoundaryState_TurbulenceKOmegaWallResolved.hpp:23
VertexCFD::ClosureModel::ElementLength
Definition: VertexCFD_Closure_ElementLength.hpp:24
VertexCFD::ClosureModel::WallDistance
Definition: VertexCFD_Closure_WallDistance.hpp:26
Generated by doxygen 1.8.20