Branch data Line data Source code
1 : : // *****************************************************************************
2 : : /*!
3 : : \file src/PDE/ConfigureCompFlow.cpp
4 : : \copyright 2012-2015 J. Bakosi,
5 : : 2016-2018 Los Alamos National Security, LLC.,
6 : : 2019-2021 Triad National Security, LLC.
7 : : All rights reserved. See the LICENSE file for details.
8 : : \brief Register and compile configuration for compressible flow PDE
9 : : \details Register and compile configuration for compressible flow PDE.
10 : : */
11 : : // *****************************************************************************
12 : :
13 : : #include <set>
14 : : #include <map>
15 : : #include <vector>
16 : : #include <string>
17 : : #include <limits>
18 : :
19 : : #include <brigand/algorithms/for_each.hpp>
20 : :
21 : : #include "Tags.hpp"
22 : : #include "CartesianProduct.hpp"
23 : : #include "PDEFactory.hpp"
24 : : #include "Inciter/Options/PDE.hpp"
25 : : #include "ContainerUtil.hpp"
26 : : #include "ConfigureCompFlow.hpp"
27 : : #include "CompFlow/Physics/CG.hpp"
28 : : #include "CompFlow/Physics/DG.hpp"
29 : : #include "CompFlow/CGCompFlow.hpp"
30 : : #include "CompFlow/DGCompFlow.hpp"
31 : : #include "CompFlow/Problem.hpp"
32 : : #include "InfoMesh.hpp"
33 : :
34 : : namespace inciter {
35 : :
36 : : void
37 : 1565 : registerCompFlow( CGFactory& cf,
38 : : DGFactory& df,
39 : : std::set< ctr::PDEType >& cgt,
40 : : std::set< ctr::PDEType >& dgt )
41 : : // *****************************************************************************
42 : : // Register compressible flow PDE into PDE factory
43 : : //! \param[in,out] cf Continuous Galerkin PDE factory to register to
44 : : //! \param[in,out] df Discontinuous Galerkin PDE factory to register to
45 : : //! \param[in,out] cgt Counters for equation types registered into CG factory
46 : : //! \param[in,out] dgt Counters for equation types registered into DG factory
47 : : // *****************************************************************************
48 : : {
49 : : // Construct vector of vectors for all possible policies
50 : : using CGCompFlowPolicies =
51 : : tk::cartesian_product< cg::CompFlowPhysics, CompFlowProblems >;
52 : : // Register PDEs for all combinations of policies
53 : : brigand::for_each< CGCompFlowPolicies >(
54 : 1565 : registerCG< cg::CompFlow >( cf, cgt, ctr::PDEType::COMPFLOW ) );
55 : :
56 : : // Construct vector of vectors for all possible policies
57 : : using DGCompFlowPolicies =
58 : : tk::cartesian_product< dg::CompFlowPhysics, CompFlowProblems >;
59 : : // Register PDEs for all combinations of policies
60 : : brigand::for_each< DGCompFlowPolicies >(
61 : 1565 : registerDG< dg::CompFlow >( df, dgt, ctr::PDEType::COMPFLOW ) );
62 : 1565 : }
63 : :
64 : : std::vector< std::pair< std::string, std::string > >
65 : 95 : infoCompFlow( std::map< ctr::PDEType, tk::ctr::ncomp_t >& cnt )
66 : : // *****************************************************************************
67 : : // Return information on the compressible flow system of PDEs
68 : : //! \param[inout] cnt std::map of counters for all PDE types
69 : : //! \return vector of string pairs describing the PDE configuration
70 : : // *****************************************************************************
71 : : {
72 : : using eq = tag::compflow;
73 : : using tk::parameter;
74 : : using tk::parameters;
75 : :
76 [ + - ]: 95 : auto c = ++cnt[ ctr::PDEType::COMPFLOW ]; // count eqs
77 : : --c; // used to index vectors starting with 0
78 : :
79 : : std::vector< std::pair< std::string, std::string > > nfo;
80 : :
81 [ + - ][ + - ]: 190 : nfo.emplace_back( ctr::PDE().name( ctr::PDEType::COMPFLOW ), "" );
82 : :
83 [ + - ]: 95 : nfo.emplace_back( "dependent variable", std::string( 1,
84 [ + - ][ + - ]: 95 : g_inputdeck.get< tag::param, eq, tag::depvar >()[c] ) );
85 : :
86 [ + - ]: 95 : infoMesh< eq >( c, nfo );
87 : :
88 [ + - ]: 95 : nfo.emplace_back( "physics", ctr::Physics().name(
89 [ + - ]: 190 : g_inputdeck.get< tag::param, eq, tag::physics >()[c] ) );
90 : :
91 [ + - ]: 95 : nfo.emplace_back( "problem", ctr::Problem().name(
92 [ + - ]: 190 : g_inputdeck.get< tag::param, eq, tag::problem >()[c] ) );
93 : :
94 [ + - ]: 95 : auto ncomp = g_inputdeck.get< tag::component >().get< eq >()[c];
95 [ + - ][ + - ]: 95 : nfo.emplace_back( "number of components", parameter( ncomp ) );
96 : :
97 : 95 : const auto scheme = g_inputdeck.get< tag::discr, tag::scheme >();
98 [ + + ]: 95 : if (scheme != ctr::SchemeType::DiagCG && scheme != ctr::SchemeType::ALECG)
99 [ + - ]: 70 : nfo.emplace_back( "flux", ctr::Flux().name(
100 [ + - ]: 70 : g_inputdeck.get< tag::param, eq, tag::flux >().at(c) ) );
101 : :
102 : 190 : nfo.emplace_back( "start offset in unknowns array", parameter(
103 [ + - ][ + - ]: 95 : g_inputdeck.get< tag::component >().offset< eq >(c) ) );
104 : :
105 : : // Material property output
106 [ + - ]: 95 : const auto& matprop = g_inputdeck.get< tag::param, eq, tag::material >()[c][0];
107 : : const auto& m_id = matprop.get< tag::id >();
108 [ + - ]: 95 : ctr::Material mopt;
109 : 95 : nfo.emplace_back( mopt.name( matprop.get< tag::eos >() ),
110 [ + - ][ + - ]: 285 : std::to_string(m_id.size()) );
[ + - ]
111 : :
112 : : nfo.emplace_back( "ratio of specific heats",
113 [ + - ][ + - ]: 190 : parameters(matprop.get< tag::gamma >()) );
[ + - ]
114 : : const auto& cv = matprop.get< tag::cv >();
115 [ + - ]: 95 : if (!cv.empty())
116 : : nfo.emplace_back( "specific heat at constant volume",
117 [ + - ][ + - ]: 190 : parameters(cv) );
118 : : const auto& pstiff = matprop.get< tag::pstiff >();
119 [ + - ]: 95 : if (!pstiff.empty())
120 : : nfo.emplace_back( "material stiffness",
121 [ + - ][ + - ]: 190 : parameters(pstiff) );
122 : :
123 : : // Viscosity is optional: vector may be empty
124 : : const auto& mu = matprop.get< tag::mu >();
125 [ - + ]: 95 : if (!mu.empty())
126 [ - - ][ - - ]: 0 : nfo.emplace_back( "dynamic viscosity", parameters( mu ) );
127 : :
128 : : // Heat conductivity is optional: vector may be empty
129 : : const auto& k = matprop.get< tag::k >();
130 [ - + ]: 95 : if (!k.empty())
131 [ - - ][ - - ]: 0 : nfo.emplace_back( "heat conductivity", parameters( k ) );
132 : :
133 : : const auto& npar = g_inputdeck.get< tag::param, eq, tag::npar >();
134 [ - + ]: 95 : if (!npar.empty())
135 [ - - ][ - - ]: 0 : nfo.emplace_back( "number of tracker particles", parameters( npar ) );
136 : :
137 : : const auto& alpha = g_inputdeck.get< tag::param, eq, tag::alpha >();
138 [ + + ][ + - ]: 145 : if (!alpha.empty()) nfo.emplace_back( "coeff alpha", parameters( alpha ) );
[ + - ]
139 : :
140 : : const auto& beta =
141 : : g_inputdeck.get< tag::param, eq, tag::beta >();
142 [ + + ]: 95 : if (!beta.empty())
143 [ + - ][ + - ]: 68 : nfo.emplace_back( "coeff beta", parameters( beta ) );
144 : :
145 : : const auto& bx = g_inputdeck.get< tag::param, eq, tag::betax >();
146 [ + + ][ + - ]: 111 : if (!bx.empty()) nfo.emplace_back( "coeff betax", parameters( bx ) );
[ + - ]
147 : :
148 : : const auto& by = g_inputdeck.get< tag::param, eq, tag::betay >();
149 [ + + ][ + - ]: 111 : if (!by.empty()) nfo.emplace_back( "coeff betay", parameters( by ) );
[ + - ]
150 : :
151 : : const auto& bz = g_inputdeck.get< tag::param, eq, tag::betaz >();
152 [ + + ][ + - ]: 111 : if (!bz.empty()) nfo.emplace_back( "coeff betaz", parameters( bz ) );
[ + - ]
153 : :
154 : : const auto& r0 = g_inputdeck.get< tag::param, eq, tag::r0 >();
155 [ + + ][ + - ]: 111 : if (!r0.empty()) nfo.emplace_back( "coeff r0", parameters( r0 ) );
[ + - ]
156 : :
157 : : const auto& ce = g_inputdeck.get< tag::param, eq, tag::ce >();
158 [ + + ][ + - ]: 107 : if (!ce.empty()) nfo.emplace_back( "coeff ce", parameters( ce ) );
[ + - ]
159 : :
160 : : const auto& kappa = g_inputdeck.get< tag::param, eq, tag::kappa >();
161 [ + + ][ + - ]: 111 : if (!kappa.empty()) nfo.emplace_back( "coeff k", parameters( kappa ) );
[ + - ]
162 : :
163 : : const auto& p0 = g_inputdeck.get< tag::param, eq, tag::p0 >();
164 [ + + ][ + - ]: 133 : if (!p0.empty()) nfo.emplace_back( "coeff p0", parameters( p0 ) );
[ + - ]
165 : :
166 : : // ICs
167 : :
168 : : const auto& ic = g_inputdeck.get< tag::param, eq, tag::ic >();
169 : :
170 : : const auto& bgdensityic = ic.get< tag::density >();
171 [ + + ][ + - ]: 95 : if (bgdensityic.size() > c && !bgdensityic[c].empty())
172 : : nfo.emplace_back( "IC background density",
173 [ + - ][ + - ]: 14 : parameter( bgdensityic[c][0] ) );
174 : : const auto& bgvelocityic = ic.get< tag::velocity >();
175 [ + + ][ + - ]: 95 : if (bgvelocityic.size() > c && !bgvelocityic[c].empty())
176 : : nfo.emplace_back( "IC background velocity",
177 [ + - ][ + - ]: 14 : parameters( bgvelocityic[c] ) );
178 : : const auto& bgpressureic = ic.get< tag::pressure >();
179 [ + + ][ + - ]: 95 : if (bgpressureic.size() > c && !bgpressureic[c].empty())
180 : : nfo.emplace_back( "IC background pressure",
181 [ + - ][ + - ]: 14 : parameter( bgpressureic[c][0] ) );
182 : : const auto& bgenergyic = ic.get< tag::energy >();
183 [ - + ][ - - ]: 95 : if (bgenergyic.size() > c && !bgenergyic[c].empty())
184 : : nfo.emplace_back( "IC background energy",
185 [ - - ][ - - ]: 0 : parameter( bgenergyic[c][0] ) );
186 : : const auto& bgtemperatureic = ic.get< tag::temperature >();
187 [ - + ][ - - ]: 95 : if (bgtemperatureic.size() > c && !bgtemperatureic[c].empty())
188 : : nfo.emplace_back( "IC background temperature",
189 [ - - ][ - - ]: 0 : parameter( bgtemperatureic[c][0] ) );
190 : :
191 : : const auto& icbox = ic.get< tag::box >();
192 [ + - ]: 95 : if (icbox.size() > c) {
193 : 95 : std::size_t bcnt = 0;
194 [ + + ]: 98 : for (const auto& b : icbox[c]) { // for all boxes configured for this eq
195 : : std::vector< tk::real > box
196 : 3 : { b.get< tag::xmin >(), b.get< tag::xmax >(),
197 : 3 : b.get< tag::ymin >(), b.get< tag::ymax >(),
198 [ + - ]: 3 : b.get< tag::zmin >(), b.get< tag::zmax >() };
199 : :
200 [ + - ][ + - ]: 3 : std::string boxname = "IC box " + parameter(bcnt);
[ - - ]
201 [ + - ][ + - ]: 6 : nfo.emplace_back( boxname, parameters( box ) );
[ + - ]
202 : :
203 [ + - ][ - + ]: 6 : nfo.emplace_back( boxname + " density",
[ - - ]
204 [ + - ][ + - ]: 9 : parameter( b.get< tag::density >() ) );
[ + - ]
205 [ + - ][ - + ]: 6 : nfo.emplace_back( boxname + " velocity",
[ - - ]
206 [ + - ][ + - ]: 9 : parameters( b.get< tag::velocity >() ) );
[ + - ]
207 [ + - ][ - + ]: 6 : nfo.emplace_back( boxname + " pressure",
[ - - ]
208 [ + - ][ + - ]: 9 : parameter( b.get< tag::pressure >() ) );
[ + - ]
209 [ + - ][ - + ]: 6 : nfo.emplace_back( boxname + " internal energy per unit mass",
[ - - ]
210 [ + - ][ + - ]: 9 : parameter( b.get< tag::energy >() ) );
[ + - ]
211 [ + - ][ - + ]: 6 : nfo.emplace_back( boxname + " mass",
[ - - ]
212 [ + - ][ + - ]: 9 : parameter( b.get< tag::mass >() ) );
[ + - ]
213 [ + - ][ - + ]: 6 : nfo.emplace_back( boxname + " internal energy per unit volume",
[ - - ]
214 [ + - ][ + - ]: 9 : parameter( b.get< tag::energy_content >() ) );
[ + - ]
215 [ + - ][ - + ]: 6 : nfo.emplace_back( boxname + " temperature",
[ - - ]
216 [ + - ][ + - ]: 6 : parameter( b.get< tag::temperature >() ) );
[ - - ]
217 : :
218 : : const auto& initiate = b.get< tag::initiate >();
219 : : const auto& inittype = initiate.get< tag::init >();
220 [ + - ]: 3 : auto opt = ctr::Initiate();
221 [ + - ][ + - ]: 9 : nfo.emplace_back( boxname + ' ' + opt.group(), opt.name(inittype) );
[ + - ][ - + ]
[ - - ]
222 [ + + ]: 3 : if (inittype == ctr::InitiateType::LINEAR) {
223 [ + - ][ - + ]: 2 : nfo.emplace_back( boxname + " initiate linear point(s)",
[ - - ]
224 [ + - ][ + - ]: 3 : parameters( initiate.get< tag::point >() ) );
[ + - ]
225 [ + - ][ - + ]: 2 : nfo.emplace_back( boxname + " initiate linear radius",
[ - - ]
226 [ + - ][ + - ]: 3 : parameter( initiate.get< tag::radius >() ) );
[ + - ]
227 [ + - ][ - + ]: 2 : nfo.emplace_back( boxname + " initiate linear velocity",
[ - - ]
228 [ + - ][ + - ]: 3 : parameter( initiate.get< tag::velocity >() ) );
229 : : }
230 : 3 : ++bcnt;
231 : : }
232 : : }
233 : :
234 : : // BCs
235 : :
236 : : const auto& stag = g_inputdeck.get< tag::param, eq, tag::stag >();
237 : : const auto& spoint = stag.get< tag::point >();
238 [ + + ]: 95 : if (spoint.size() > c)
239 [ + - ][ + - ]: 6 : nfo.emplace_back( "Stagnation point(s)", parameters( spoint[c] ) );
240 : : const auto& sradius = stag.get< tag::radius >();
241 [ + + ]: 95 : if (sradius.size() > c)
242 [ + - ][ + - ]: 6 : nfo.emplace_back( "Stagnation point(s) radii", parameters( sradius[c] ) );
243 : :
244 : : const auto& skip = g_inputdeck.get< tag::param, eq, tag::skip >();
245 : : const auto& kpoint = skip.get< tag::point >();
246 [ - + ]: 95 : if (kpoint.size() > c)
247 [ - - ][ - - ]: 0 : nfo.emplace_back( "Skip point(s)", parameters( kpoint[c] ) );
248 : : const auto& kradius = skip.get< tag::radius >();
249 [ - + ]: 95 : if (kradius.size() > c)
250 [ - - ][ - - ]: 0 : nfo.emplace_back( "Skip point(s) radii", parameters( kradius[c] ) );
251 : :
252 : : const auto& fs =
253 : : g_inputdeck.get< tag::param, eq, tag::bc, tag::bcfarfield >();
254 [ + + ]: 95 : if (fs.size() > c) {
255 [ + - ][ + - ]: 6 : nfo.emplace_back( "Farfield BC sideset(s)", parameters( fs[c] ) );
256 : : const auto& fr =
257 : : g_inputdeck.get< tag::param, eq, tag::farfield_density >();
258 [ + - ]: 6 : if (fr.size() > c)
259 [ + - ][ + - ]: 12 : nfo.emplace_back( "Farfield BC density", std::to_string(fr[c]) );
260 : : const auto& fu =
261 : : g_inputdeck.get< tag::param, eq, tag::farfield_velocity >();
262 [ + - ]: 6 : if (fu.size() > c)
263 [ + - ][ + - ]: 12 : nfo.emplace_back( "Farfield BC velocity", parameters( fu[c] ) );
264 : : const auto& fp =
265 : : g_inputdeck.get< tag::param, eq, tag::farfield_pressure >();
266 [ + - ]: 6 : if (fp.size() > c)
267 [ + - ][ + - ]: 12 : nfo.emplace_back( "Farfield BC pressure", std::to_string(fp[c]) );
268 : : }
269 : :
270 : : const auto& sym =
271 : : g_inputdeck.get< tag::param, eq, tag::bc, tag::bcsym >();
272 [ + + ]: 95 : if (sym.size() > c) {
273 [ + - ][ + - ]: 41 : nfo.emplace_back( "Symmetry BC sideset(s)", parameters( sym[c] ) );
274 : :
275 : : const auto& sponge = g_inputdeck.get< tag::param, eq, tag::sponge >();
276 : : const auto& ss = sponge.get< tag::sideset >();
277 [ + + ]: 41 : if (ss.size() > c)
278 [ + - ][ + - ]: 4 : nfo.emplace_back( "Sponge sideset(s)", parameters( ss[c] ) );
279 : : const auto& spvel = sponge.get< tag::velocity >();
280 [ + + ]: 41 : if (spvel.size() > c)
281 [ + - ][ + - ]: 2 : nfo.emplace_back( "Sponge velocity parameters", parameters( spvel[c] ) );
282 : : const auto& sppre = sponge.get< tag::pressure >();
283 [ + + ]: 41 : if (sppre.size() > c)
284 [ + - ][ + - ]: 2 : nfo.emplace_back( "Sponge pressure parameters", parameters( sppre[c] ) );
285 : : }
286 : :
287 : : const auto& dir =
288 : : g_inputdeck.get< tag::param, eq, tag::bc, tag::bcdir >();
289 [ + + ]: 95 : if (dir.size() > c)
290 [ + - ][ + - ]: 124 : nfo.emplace_back( "Dirichlet BC sideset(s)", parameters( dir[c] ) );
291 : :
292 : : const auto& timedep = g_inputdeck.get< tag::param, eq, tag::bctimedep >();
293 [ + - ]: 95 : if (timedep.size() > c) {
294 [ + + ]: 96 : for (const auto& bndry : timedep[c]) {
295 : : nfo.emplace_back( "Time dependent BC sideset(s)",
296 [ + - ][ + - ]: 2 : parameters(bndry.get< tag::sideset >()) );
297 : : }
298 : : }
299 : :
300 : : // FCT
301 : :
302 : : auto bool_to_string = [](bool B) -> std::string {
303 [ + - ]: 28 : return B ? "true" : "false";
304 : : };
305 : :
306 : 95 : const auto fct = g_inputdeck.get< tag::discr, tag::fct >();
307 [ + + ]: 95 : if (scheme == ctr::SchemeType::DiagCG && fct) {
308 : :
309 : : const auto& sys = g_inputdeck.get< tag::param, eq, tag::sysfct >();
310 [ + - ]: 28 : if (sys.size() > c) {
311 [ + + ][ + - ]: 56 : nfo.emplace_back( "FCT system character", bool_to_string( sys[c] ) );
312 : :
313 [ + + ]: 28 : if (sys[c]) { // if system FCT is enabled for this system
314 : : const auto& sv = g_inputdeck.get< tag::param, eq, tag::sysfctvar >();
315 [ + - ]: 4 : if (sv.size() > c) {
316 [ + - ][ + - ]: 8 : nfo.emplace_back( "System-FCT variables", parameters( sv[c] ) );
317 : : }
318 : : }
319 : : }
320 : :
321 : : }
322 : :
323 : 95 : return nfo;
324 : : }
325 : :
326 : : void
327 [ + - ]: 3170 : assignCompFlowGetVars( const std::string& name, tk::GetVarFn& f )
328 : : // *****************************************************************************
329 : : // Assign functions that compute physics variables from the numerical solution
330 : : // for CompFlow
331 : : //! \param[in] name Name of variable whose tk::GetVarFn is to be assigned
332 : : //! \param[in,out] f Function assigned
333 : : // *****************************************************************************
334 : : {
335 : : using namespace kw;
336 : : using namespace compflow;
337 : :
338 [ + - ][ + - ]: 6340 : assign< outvar_density >( name, densityOutVar, f );
339 [ + - ][ + - ]: 6340 : assign< outvar_xvelocity >( name, velocityOutVar<0>, f );
340 [ + - ][ + - ]: 6340 : assign< outvar_yvelocity >( name, velocityOutVar<1>, f );
341 [ + - ][ + - ]: 6340 : assign< outvar_zvelocity >( name, velocityOutVar<2>, f );
342 [ + - ][ + - ]: 6340 : assign< outvar_specific_total_energy >( name, specificTotalEnergyOutVar, f );
343 : : assign< outvar_volumetric_total_energy >
344 [ + - ][ + - ]: 6340 : ( name, volumetricTotalEnergyOutVar, f );
345 [ + - ][ + - ]: 6340 : assign< outvar_xmomentum >( name, momentumOutVar<0>, f );
346 [ + - ][ + - ]: 6340 : assign< outvar_ymomentum >( name, momentumOutVar<1>, f );
347 [ + - ][ + - ]: 6340 : assign< outvar_zmomentum >( name, momentumOutVar<2>, f );
348 [ + - ]: 3170 : assign< outvar_pressure >( name, pressureOutVar, f );
349 : 3170 : }
350 : :
351 : : } // inciter::
|
