Line data Source code
1 : //* This file is part of the MOOSE framework
2 : //* https://mooseframework.inl.gov
3 : //*
4 : //* All rights reserved, see COPYRIGHT for full restrictions
5 : //* https://github.com/idaholab/moose/blob/master/COPYRIGHT
6 : //*
7 : //* Licensed under LGPL 2.1, please see LICENSE for details
8 : //* https://www.gnu.org/licenses/lgpl-2.1.html
9 :
10 : #include "PNSFVSolidHeatTransferPhysics.h"
11 : #include "WCNSFVCoupledAdvectionPhysicsHelper.h"
12 : #include "WCNSFVFlowPhysics.h"
13 : #include "WCNSFVFluidHeatTransferPhysics.h"
14 : #include "NSFVBase.h"
15 :
16 : registerPhysicsBaseTasks("NavierStokesApp", PNSFVSolidHeatTransferPhysics);
17 : registerMooseAction("NavierStokesApp", PNSFVSolidHeatTransferPhysics, "add_variable");
18 : registerMooseAction("NavierStokesApp", PNSFVSolidHeatTransferPhysics, "add_ic");
19 : registerMooseAction("NavierStokesApp", PNSFVSolidHeatTransferPhysics, "add_fv_kernel");
20 : registerMooseAction("NavierStokesApp", PNSFVSolidHeatTransferPhysics, "add_fv_bc");
21 : registerMooseAction("NavierStokesApp", PNSFVSolidHeatTransferPhysics, "add_material");
22 : registerMooseAction("NavierStokesApp", PNSFVSolidHeatTransferPhysics, "add_preconditioning");
23 :
24 : InputParameters
25 66 : PNSFVSolidHeatTransferPhysics::validParams()
26 : {
27 66 : InputParameters params = HeatConductionFV::validParams();
28 66 : params.addClassDescription("Define the Navier Stokes porous media solid energy equation");
29 :
30 : // These boundary conditions parameters are not implemented yet
31 66 : params.suppressParameter<std::vector<BoundaryName>>("fixed_convection_boundaries");
32 66 : params.suppressParameter<std::vector<MooseFunctorName>>("fixed_convection_T_fluid");
33 66 : params.suppressParameter<std::vector<MooseFunctorName>>("fixed_convection_htc");
34 :
35 : // Swap out some parameters, base class is not specific to porous media
36 : // Variables
37 132 : params.renameParam("temperature_name",
38 : "solid_temperature_variable",
39 : "Name of the solid phase temperature variable");
40 132 : params.set<VariableName>("solid_temperature_variable") = NS::T_solid;
41 132 : params.addParam<NonlinearVariableName>(
42 : "fluid_temperature_variable", NS::T_fluid, "Name of the fluid temperature variable");
43 132 : MooseEnum face_interpol_types("average skewness-corrected", "average");
44 132 : params.addParam<MooseEnum>(
45 : "solid_temperature_face_interpolation",
46 : face_interpol_types,
47 : "The numerical scheme to interpolate the temperature/energy to the "
48 : "face for conduction (separate from the advected quantity interpolation).");
49 132 : params.addParam<bool>(
50 : "solid_temperature_two_term_bc_expansion",
51 132 : true,
52 : "If a two-term Taylor expansion is needed for the determination of the boundary values"
53 : "of the temperature/energy.");
54 :
55 : // Porous media parameters
56 : // TODO: ensure consistency with fluid energy physics
57 66 : params.transferParam<MooseFunctorName>(NSFVBase::validParams(), "porosity");
58 :
59 : // Material properties
60 66 : params.suppressParameter<MaterialPropertyName>("specific_heat");
61 132 : params.addParam<MooseFunctorName>("cp_solid", NS::cp + "_solid", "Specific heat functor");
62 66 : params.suppressParameter<MaterialPropertyName>("density");
63 132 : params.addParam<MooseFunctorName>("rho_solid", NS::density + "_solid", "Density functor");
64 132 : params.addParam<std::vector<std::vector<SubdomainName>>>(
65 : "thermal_conductivity_blocks", "Blocks which each thermal conductivity is defined");
66 66 : params.suppressParameter<MooseFunctorName>("thermal_conductivity_functor");
67 132 : params.addRequiredParam<std::vector<MooseFunctorName>>(
68 : "thermal_conductivity_solid",
69 : "Thermal conductivity, which may have different names depending on the subdomain");
70 :
71 : // Ambient convection with the liquid phase parameters
72 132 : params.addParam<std::vector<std::vector<SubdomainName>>>(
73 : "ambient_convection_blocks", {}, "The blocks where the ambient convection is present.");
74 132 : params.addParam<std::vector<MooseFunctorName>>(
75 : "ambient_convection_alpha",
76 : {},
77 : "The heat exchange coefficients for each block in 'ambient_convection_blocks'.");
78 264 : params.addParam<std::vector<MooseFunctorName>>(
79 : "ambient_convection_temperature",
80 : {NS::T_fluid},
81 : "The fluid temperature for each block in 'ambient_convection_blocks'.");
82 :
83 : // Heat source in solid porous medium parameters
84 66 : params.addParam<std::vector<SubdomainName>>("external_heat_source_blocks",
85 66 : std::vector<SubdomainName>(),
86 : "The blocks where the heat source is present.");
87 132 : params.addParam<MooseFunctorName>(
88 : "external_heat_source",
89 : "The name of a functor which contains the external heat source for the energy equation.");
90 132 : params.addParam<Real>(
91 132 : "external_heat_source_coeff", 1.0, "Multiplier for the coupled heat source term.");
92 132 : params.addParam<bool>("use_external_enthalpy_material",
93 132 : false,
94 : "To indicate if the enthalpy material is set up outside of the action.");
95 :
96 66 : params.suppressParameter<VariableName>("heat_source_var");
97 66 : params.suppressParameter<std::vector<SubdomainName>>("heat_source_blocks");
98 :
99 : // Numerical scheme
100 132 : params.addParam<unsigned short>(
101 132 : "ghost_layers", 2, "Number of layers of elements to ghost near process domain boundaries");
102 : // Preconditioning has not been derived for NSFV + porous heat transfer at this point
103 132 : MooseEnum pc_options("default none", "none");
104 66 : params.set<MooseEnum>("preconditioning") = pc_options;
105 66 : params.suppressParameter<MooseEnum>("preconditioning");
106 :
107 : // Parameter groups
108 132 : params.addParamNamesToGroup("rho_solid cp_solid thermal_conductivity_solid "
109 : "thermal_conductivity_blocks use_external_enthalpy_material",
110 : "Material properties");
111 132 : params.addParamNamesToGroup("ambient_convection_alpha ambient_convection_blocks "
112 : "ambient_convection_temperature",
113 : "Ambient convection");
114 132 : params.addParamNamesToGroup(
115 : "external_heat_source_blocks external_heat_source external_heat_source_coeff",
116 : "Solid porous medium heat source");
117 132 : params.addParamNamesToGroup(
118 : "solid_temperature_face_interpolation solid_temperature_two_term_bc_expansion",
119 : "Numerical scheme");
120 132 : params.addParamNamesToGroup("ghost_layers", "Advanced");
121 :
122 66 : return params;
123 66 : }
124 :
125 66 : PNSFVSolidHeatTransferPhysics::PNSFVSolidHeatTransferPhysics(const InputParameters & parameters)
126 : : HeatConductionFV(parameters),
127 66 : _solid_temperature_name(getParam<VariableName>("solid_temperature_variable")),
128 132 : _fluid_temperature_name(getParam<NonlinearVariableName>("fluid_temperature_variable")),
129 : _porosity_name(getParam<MooseFunctorName>(NS::porosity)),
130 66 : _density_name(getParam<MooseFunctorName>("rho_solid")),
131 66 : _specific_heat_name(getParam<MooseFunctorName>("cp_solid")),
132 104 : _thermal_conductivity_blocks(
133 66 : parameters.isParamValid("thermal_conductivity_blocks")
134 66 : ? getParam<std::vector<std::vector<SubdomainName>>>("thermal_conductivity_blocks")
135 : : std::vector<std::vector<SubdomainName>>()),
136 132 : _thermal_conductivity_name(
137 : getParam<std::vector<MooseFunctorName>>("thermal_conductivity_solid")),
138 132 : _ambient_convection_blocks(
139 : getParam<std::vector<std::vector<SubdomainName>>>("ambient_convection_blocks")),
140 132 : _ambient_convection_alpha(getParam<std::vector<MooseFunctorName>>("ambient_convection_alpha")),
141 264 : _ambient_temperature(getParam<std::vector<MooseFunctorName>>("ambient_convection_temperature"))
142 : {
143 66 : saveSolverVariableName(_solid_temperature_name);
144 :
145 : // Parameter checks
146 132 : if (getParam<std::vector<MooseFunctorName>>("ambient_convection_temperature").size() != 1)
147 0 : checkVectorParamsSameLengthIfSet<MooseFunctorName, MooseFunctorName>(
148 : "ambient_convection_alpha", "ambient_convection_temperature");
149 132 : checkSecondParamSetOnlyIfFirstOneSet("external_heat_source", "external_heat_source_coeff");
150 66 : if (_solid_temperature_name == _fluid_temperature_name)
151 0 : paramError("solid_temperature_variable",
152 : "Solid and fluid cannot share the same temperature variable");
153 : // More parameter checks in ambient convection creation
154 66 : }
155 :
156 : void
157 66 : PNSFVSolidHeatTransferPhysics::addSolverVariables()
158 : {
159 : // Dont add if the user already defined the variable
160 132 : if (variableExists(_solid_temperature_name,
161 : /*error_if_aux=*/true))
162 0 : checkBlockRestrictionIdentical(_solid_temperature_name,
163 0 : getProblem().getVariable(0, _solid_temperature_name).blocks());
164 : else
165 : {
166 66 : auto params = getFactory().getValidParams("INSFVEnergyVariable");
167 66 : assignBlocks(params, _blocks);
168 132 : params.set<SolverSystemName>("solver_sys") = getSolverSystem(_solid_temperature_name);
169 198 : params.set<std::vector<Real>>("scaling") = {getParam<Real>("temperature_scaling")};
170 132 : params.set<MooseEnum>("face_interp_method") =
171 132 : getParam<MooseEnum>("solid_temperature_face_interpolation");
172 66 : params.set<bool>("two_term_boundary_expansion") =
173 198 : getParam<bool>("solid_temperature_two_term_bc_expansion");
174 66 : getProblem().addVariable("INSFVEnergyVariable", _solid_temperature_name, params);
175 66 : }
176 66 : }
177 :
178 : void
179 66 : PNSFVSolidHeatTransferPhysics::addFVKernels()
180 : {
181 : // Check this physics against others
182 66 : checkFluidAndSolidHeatTransferPhysicsParameters();
183 :
184 66 : if (isTransient())
185 9 : addPINSSolidEnergyTimeKernels();
186 :
187 66 : addPINSSolidEnergyHeatConductionKernels();
188 132 : if (getParam<std::vector<MooseFunctorName>>("ambient_convection_alpha").size())
189 47 : addPINSSolidEnergyAmbientConvection();
190 132 : if (isParamValid("external_heat_source"))
191 57 : addPINSSolidEnergyExternalHeatSource();
192 66 : }
193 :
194 : void
195 9 : PNSFVSolidHeatTransferPhysics::addPINSSolidEnergyTimeKernels()
196 : {
197 : const auto kernel_type = "PINSFVEnergyTimeDerivative";
198 18 : const auto kernel_name = prefix() + "pins_solid_energy_time";
199 :
200 9 : InputParameters params = getFactory().getValidParams(kernel_type);
201 9 : assignBlocks(params, _blocks);
202 9 : params.set<NonlinearVariableName>("variable") = _solid_temperature_name;
203 9 : params.set<MooseFunctorName>(NS::density) = _density_name;
204 :
205 : // The '_solid' suffix has been declared when creating the INSFVEnthalpyMaterial
206 : // only for thermal functor material properties
207 : // Using this derivative we can model non-constant specific heat
208 27 : if (getProblem().hasFunctor(NS::time_deriv(NS::specific_enthalpy) + "_solid",
209 : /*thread_id=*/0))
210 18 : params.set<MooseFunctorName>(NS::time_deriv(NS::specific_enthalpy)) =
211 9 : NS::time_deriv(NS::specific_enthalpy) + "_solid";
212 : else
213 0 : params.set<MooseFunctorName>(NS::cp) = _specific_heat_name;
214 :
215 9 : params.set<MooseFunctorName>(NS::porosity) = _porosity_name;
216 : // If modeling a variable density
217 18 : if (getProblem().hasFunctor(NS::time_deriv(_density_name),
218 : /*thread_id=*/0))
219 : {
220 0 : params.set<MooseFunctorName>(NS::time_deriv(NS::density)) = NS::time_deriv(_density_name);
221 0 : params.set<MooseFunctorName>(NS::specific_enthalpy) = NS::specific_enthalpy + "_solid";
222 : }
223 9 : params.set<bool>("is_solid") = true;
224 :
225 9 : getProblem().addFVKernel(kernel_type, kernel_name, params);
226 18 : }
227 :
228 : void
229 66 : PNSFVSolidHeatTransferPhysics::addPINSSolidEnergyHeatConductionKernels()
230 : {
231 66 : const auto vector_conductivity = processThermalConductivity();
232 :
233 : const auto kernel_type =
234 66 : vector_conductivity ? "PINSFVEnergyAnisotropicDiffusion" : "PINSFVEnergyDiffusion";
235 :
236 66 : InputParameters params = getFactory().getValidParams(kernel_type);
237 66 : params.set<NonlinearVariableName>("variable") = _solid_temperature_name;
238 66 : params.set<MooseFunctorName>(NS::porosity) = _porosity_name;
239 :
240 : // Set block restrictions
241 : const bool combined = _thermal_conductivity_blocks.size() > 1;
242 : std::vector<SubdomainName> thermal_conductivity_blocks;
243 123 : for (const auto & block_group : _thermal_conductivity_blocks)
244 57 : thermal_conductivity_blocks.insert(thermal_conductivity_blocks.end(),
245 : std::make_move_iterator(block_group.begin()),
246 : std::make_move_iterator(block_group.end()));
247 : const auto block_names =
248 66 : _thermal_conductivity_blocks.size() ? thermal_conductivity_blocks : _blocks;
249 66 : assignBlocks(params, block_names);
250 :
251 : // Set thermal conductivity
252 132 : const auto conductivity_name = vector_conductivity ? NS::kappa : NS::k;
253 66 : if (combined)
254 57 : params.set<MooseFunctorName>(conductivity_name) = prefix() + "combined_thermal_conductivity";
255 : else
256 47 : params.set<MooseFunctorName>(conductivity_name) = _thermal_conductivity_name[0];
257 :
258 264 : getProblem().addFVKernel(kernel_type, prefix() + "pins_energy_diffusion", params);
259 66 : }
260 :
261 : void
262 47 : PNSFVSolidHeatTransferPhysics::addPINSSolidEnergyAmbientConvection()
263 : {
264 : const auto num_convection_blocks = _ambient_convection_blocks.size();
265 : const auto num_used_blocks = num_convection_blocks ? num_convection_blocks : 1;
266 :
267 : // Check parameter. Late check in case the block was added by a Component
268 47 : if (num_used_blocks != _ambient_convection_alpha.size())
269 0 : paramError("ambient_convection_alpha",
270 0 : "Number of ambient convection heat transfer coefficients (" +
271 0 : std::to_string(_ambient_convection_alpha.size()) +
272 : ") should match the number of "
273 0 : "blocks (" +
274 0 : std::to_string(num_convection_blocks) + ") each HTC is defined on.");
275 :
276 : const auto kernel_type = "PINSFVEnergyAmbientConvection";
277 47 : InputParameters params = getFactory().getValidParams(kernel_type);
278 94 : params.set<NonlinearVariableName>("variable") = _solid_temperature_name;
279 47 : params.set<MooseFunctorName>(NS::T_solid) = _solid_temperature_name;
280 47 : params.set<bool>("is_solid") = true;
281 :
282 94 : for (const auto block_i : make_range(num_used_blocks))
283 : {
284 47 : std::string block_name = "";
285 47 : if (num_convection_blocks)
286 : {
287 19 : params.set<std::vector<SubdomainName>>("block") = _ambient_convection_blocks[block_i];
288 38 : block_name = Moose::stringify(_ambient_convection_blocks[block_i]);
289 : }
290 : else
291 : {
292 28 : assignBlocks(params, _blocks);
293 56 : block_name = std::to_string(block_i);
294 : }
295 :
296 94 : params.set<MooseFunctorName>("h_solid_fluid") = _ambient_convection_alpha[block_i];
297 47 : if (_ambient_temperature.size() > 1)
298 0 : params.set<MooseFunctorName>(NS::T_fluid) = _ambient_temperature[block_i];
299 : else
300 47 : params.set<MooseFunctorName>(NS::T_fluid) = _ambient_temperature[0];
301 :
302 188 : getProblem().addFVKernel(kernel_type, prefix() + "ambient_convection_" + block_name, params);
303 : }
304 47 : }
305 :
306 : void
307 57 : PNSFVSolidHeatTransferPhysics::addPINSSolidEnergyExternalHeatSource()
308 : {
309 57 : const std::string kernel_type = "FVCoupledForce";
310 57 : InputParameters params = getFactory().getValidParams(kernel_type);
311 57 : params.set<NonlinearVariableName>("variable") = _solid_temperature_name;
312 114 : const auto & source_blocks = getParam<std::vector<SubdomainName>>("external_heat_source_blocks");
313 57 : if (source_blocks.size())
314 19 : assignBlocks(params, source_blocks);
315 : else
316 38 : assignBlocks(params, _blocks);
317 171 : params.set<MooseFunctorName>("v") = getParam<MooseFunctorName>("external_heat_source");
318 114 : params.set<Real>("coef") = getParam<Real>("external_heat_source_coeff");
319 :
320 114 : getProblem().addFVKernel(kernel_type, prefix() + "external_heat_source", params);
321 114 : }
322 :
323 : bool
324 85 : PNSFVSolidHeatTransferPhysics::processThermalConductivity()
325 : {
326 170 : if (isParamValid("thermal_conductivity_blocks"))
327 76 : checkBlockwiseConsistency<MooseFunctorName>("thermal_conductivity_blocks",
328 : {"thermal_conductivity_solid"});
329 : bool have_scalar = false;
330 : bool have_vector = false;
331 :
332 246 : for (const auto i : index_range(_thermal_conductivity_name))
333 : {
334 : // First, check if the name is just a number (only in case of isotropic conduction)
335 161 : if (MooseUtils::parsesToReal(_thermal_conductivity_name[i]))
336 : have_scalar = true;
337 : // Now we determine what kind of functor we are dealing with
338 : else
339 : {
340 38 : if (getProblem().hasFunctorWithType<ADReal>(_thermal_conductivity_name[i],
341 : /*thread_id=*/0))
342 : have_scalar = true;
343 : else
344 : {
345 0 : if (getProblem().hasFunctorWithType<ADRealVectorValue>(_thermal_conductivity_name[i],
346 : /*thread_id=*/0))
347 : have_vector = true;
348 : else
349 0 : paramError("thermal_conductivity_solid",
350 : "We only allow functor of type (AD)Real or (AD)RealVectorValue for thermal "
351 0 : "conductivity! Functor '" +
352 : _thermal_conductivity_name[i] + "' is not of the requested type.");
353 : }
354 : }
355 : }
356 :
357 85 : if (have_vector == have_scalar)
358 0 : paramError("thermal_conductivity_solid",
359 : "The entries on thermal conductivity shall either be scalars or vectors, mixing "
360 : "them is not supported!");
361 85 : return have_vector;
362 : }
363 :
364 : void
365 66 : PNSFVSolidHeatTransferPhysics::addMaterials()
366 : {
367 132 : if (!getParam<bool>("use_external_enthalpy_material"))
368 : {
369 47 : InputParameters params = getFactory().getValidParams("INSFVEnthalpyFunctorMaterial");
370 47 : assignBlocks(params, _blocks);
371 :
372 47 : params.set<MooseFunctorName>(NS::density) = _density_name;
373 47 : params.set<MooseFunctorName>(NS::cp) = _specific_heat_name;
374 94 : params.set<MooseFunctorName>("temperature") = _solid_temperature_name;
375 94 : params.set<MaterialPropertyName>("declare_suffix") = "solid";
376 :
377 94 : getProblem().addMaterial(
378 47 : "INSFVEnthalpyFunctorMaterial", prefix() + "ins_enthalpy_material", params);
379 47 : }
380 :
381 : // Combine the functors (combining scalars and vectors is not currently supported)
382 66 : if (_thermal_conductivity_name.size() > 1)
383 : {
384 19 : const auto vector_conductivity = processThermalConductivity();
385 19 : const auto combiner_functor = vector_conductivity ? "PiecewiseByBlockVectorFunctorMaterial"
386 : : "PiecewiseByBlockFunctorMaterial";
387 19 : InputParameters params = getFactory().getValidParams(combiner_functor);
388 76 : params.set<MooseFunctorName>("prop_name") = prefix() + "combined_thermal_conductivity";
389 : std::vector<SubdomainName> blocks_list;
390 : std::map<std::string, std::string> blocks_to_functors;
391 76 : for (const auto i : index_range(_thermal_conductivity_name))
392 : {
393 114 : for (const auto & block : _thermal_conductivity_blocks[i])
394 : {
395 57 : blocks_list.push_back(block);
396 57 : blocks_to_functors.insert(
397 114 : std::pair<std::string, std::string>(block, _thermal_conductivity_name[i]));
398 : }
399 : }
400 19 : params.set<std::vector<SubdomainName>>("block") = blocks_list;
401 38 : params.set<std::map<std::string, std::string>>("subdomain_to_prop_value") = blocks_to_functors;
402 76 : getProblem().addMaterial(combiner_functor, prefix() + "thermal_conductivity_combiner", params);
403 19 : }
404 66 : }
405 :
406 : InputParameters
407 198 : PNSFVSolidHeatTransferPhysics::getAdditionalRMParams() const
408 : {
409 396 : unsigned short necessary_layers = getParam<unsigned short>("ghost_layers");
410 594 : if (getParam<MooseEnum>("solid_temperature_face_interpolation") == "skewness-corrected")
411 0 : necessary_layers = std::max(necessary_layers, (unsigned short)3);
412 :
413 : // Just an object that has a ghost_layers parameter and performs geometric, algebraic, and
414 : // coupling ghosting
415 198 : const std::string kernel_type = "INSFVMixingLengthReynoldsStress";
416 198 : InputParameters params = getFactory().getValidParams(kernel_type);
417 198 : params.template set<unsigned short>("ghost_layers") = necessary_layers;
418 :
419 198 : return params;
420 0 : }
421 :
422 : void
423 66 : PNSFVSolidHeatTransferPhysics::checkFluidAndSolidHeatTransferPhysicsParameters() const
424 : {
425 : // Get a pointer to a flow physics and a heat transfer physics on the same blocks, if it exists
426 : const WCNSFVFlowPhysics * flow_physics = nullptr;
427 : const WCNSFVFluidHeatTransferPhysics * fluid_energy_physics = nullptr;
428 66 : const auto all_flow_physics = getCoupledPhysics<const WCNSFVFlowPhysics>(/*allow_fail=*/true);
429 94 : for (const auto physics : all_flow_physics)
430 28 : if (checkBlockRestrictionIdentical(
431 : physics->name(), physics->blocks(), /*error_if_not_identical=*/false))
432 : {
433 28 : if (flow_physics)
434 0 : mooseError("Two Fluid flow physics detected on the same blocks as the solid heat transfer "
435 : "physics");
436 : flow_physics = physics;
437 : }
438 : const auto all_fluid_energy_physics =
439 66 : getCoupledPhysics<const WCNSFVFluidHeatTransferPhysics>(/*allow_fail=*/true);
440 94 : for (const auto physics : all_fluid_energy_physics)
441 28 : if (checkBlockRestrictionIdentical(
442 : physics->name(), physics->blocks(), /*error_if_not_identical=*/false))
443 : {
444 28 : if (fluid_energy_physics)
445 0 : mooseError("Two fluid heat transfer physics detected on the same blocks as the solid heat "
446 : "transfer physics");
447 : fluid_energy_physics = physics;
448 : }
449 :
450 66 : if (!fluid_energy_physics && !flow_physics)
451 : return;
452 :
453 : // Check that the parameters seem reasonable
454 : // Different material properties
455 : // TODO: Does this error on numbers?
456 28 : if (flow_physics && flow_physics->densityName() == _density_name)
457 0 : paramError("rho_solid", "Fluid and solid density should be different");
458 28 : if (fluid_energy_physics && fluid_energy_physics->getSpecificHeatName() == _specific_heat_name)
459 0 : paramError("cp_solid", "Fluid and solid specific heat should be different");
460 :
461 : // Check ambient convection parameters
462 28 : if (fluid_energy_physics)
463 : {
464 : // The blocks should match
465 : // We only use a warning in case the blocks are matching, just specified differently
466 : // in the vector of vectors
467 28 : auto fluid_convection_blocks = fluid_energy_physics->getAmbientConvectionBlocks();
468 28 : std::sort(fluid_convection_blocks.begin(), fluid_convection_blocks.end());
469 28 : std::vector<std::vector<SubdomainName>> copy_solid_blocks = _ambient_convection_blocks;
470 28 : std::sort(copy_solid_blocks.begin(), copy_solid_blocks.end());
471 28 : if (fluid_convection_blocks != _ambient_convection_blocks)
472 0 : paramWarning("Ambient convection blocks in the solid phase :" +
473 0 : Moose::stringify(_ambient_convection_blocks) + " and in the fluid phase " +
474 0 : Moose::stringify(fluid_convection_blocks) + " do not seem to match.");
475 :
476 : // The coefficients should also match
477 28 : auto fluid_convection_coeffs = fluid_energy_physics->getAmbientConvectionHTCs();
478 28 : fluid_convection_blocks = fluid_energy_physics->getAmbientConvectionBlocks();
479 28 : for (const auto i : index_range(fluid_energy_physics->getAmbientConvectionBlocks()))
480 0 : for (const auto j : index_range(_ambient_convection_blocks))
481 0 : if (fluid_convection_blocks[i] == _ambient_convection_blocks[j] &&
482 0 : fluid_convection_coeffs[i] != _ambient_convection_alpha[j])
483 0 : paramWarning("Ambient convection HTCs in the solid phase :" +
484 0 : Moose::stringify(_ambient_convection_alpha) + " and in the fluid phase " +
485 0 : Moose::stringify(fluid_convection_coeffs) + " do not seem to match.");
486 28 : }
487 66 : }
|
