Branch data Line data Source code
1 : : // *****************************************************************************
2 : : /*!
3 : : \file src/PDE/ConfigureMultiMat.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 multi-material compressible
9 : : flow PDE
10 : : \details Register and compile configuration for compressible multi-material
11 : : flow PDE.
12 : : */
13 : : // *****************************************************************************
14 : :
15 : : #include <set>
16 : : #include <map>
17 : : #include <vector>
18 : : #include <string>
19 : :
20 : : #include <brigand/algorithms/for_each.hpp>
21 : :
22 : : #include "Tags.hpp"
23 : : #include "CartesianProduct.hpp"
24 : : #include "PDEFactory.hpp"
25 : : #include "Inciter/Options/PDE.hpp"
26 : : #include "ContainerUtil.hpp"
27 : : #include "ConfigureMultiMat.hpp"
28 : : #include "MultiMat/Physics/DG.hpp"
29 : : #include "MultiMat/DGMultiMat.hpp"
30 : : #include "MultiMat/Problem.hpp"
31 : : #include "InfoMesh.hpp"
32 : : #include "Inciter/Options/Material.hpp"
33 : :
34 : : namespace inciter {
35 : :
36 : : void
37 : 1565 : registerMultiMat( DGFactory& df, std::set< ctr::PDEType >& dgt )
38 : : // *****************************************************************************
39 : : // Register multi-material compressible flow PDE into PDE factory
40 : : //! \param[in,out] df Discontinuous Galerkin PDE factory to register to
41 : : //! \param[in,out] dgt Counters for equation types registered into DG factory
42 : : // *****************************************************************************
43 : : {
44 : : // Construct vector of vectors for all possible policies
45 : : using DGMultiMatPolicies =
46 : : tk::cartesian_product< dg::MultiMatPhysics, MultiMatProblems >;
47 : : // Register PDEs for all combinations of policies
48 : : brigand::for_each< DGMultiMatPolicies >(
49 [ + - ]: 1565 : registerDG< dg::MultiMat >( df, dgt, ctr::PDEType::MULTIMAT ) );
50 : 1565 : }
51 : :
52 : : std::vector< std::pair< std::string, std::string > >
53 : 12 : infoMultiMat( std::map< ctr::PDEType, tk::ctr::ncomp_t >& cnt )
54 : : // *****************************************************************************
55 : : // Return information on the compressible flow system of PDEs
56 : : //! \param[inout] cnt std::map of counters for all PDE types
57 : : //! \return vector of string pairs describing the PDE configuration
58 : : // *****************************************************************************
59 : : {
60 : : using eq = tag::multimat;
61 : : using tk::parameter;
62 : : using tk::parameters;
63 : :
64 [ + - ]: 12 : auto c = ++cnt[ ctr::PDEType::MULTIMAT ]; // count eqs
65 : 12 : --c; // used to index vectors starting with 0
66 : :
67 : 12 : std::vector< std::pair< std::string, std::string > > nfo;
68 : :
69 [ + - ][ + - ]: 12 : nfo.emplace_back( ctr::PDE().name( ctr::PDEType::MULTIMAT ), "" );
[ + - ]
70 : :
71 [ + - ]: 36 : nfo.emplace_back( "dependent variable", std::string( 1,
72 [ + - ]: 24 : g_inputdeck.get< tag::param, eq, tag::depvar >()[c] ) );
73 : :
74 [ + - ]: 12 : infoMesh< eq >( c, nfo );
75 : :
76 [ + - ]: 24 : nfo.emplace_back( "physics", ctr::Physics().name(
77 [ + - ][ + - ]: 12 : g_inputdeck.get< tag::param, eq, tag::physics >()[c] ) );
78 : :
79 [ + - ]: 24 : nfo.emplace_back( "problem", ctr::Problem().name(
80 [ + - ][ + - ]: 12 : g_inputdeck.get< tag::param, eq, tag::problem >()[c] ) );
81 : :
82 [ + - ]: 24 : nfo.emplace_back( "flux", ctr::Flux().name(
83 [ + - ][ + - ]: 12 : g_inputdeck.get< tag::param, eq, tag::flux >().at(c) ) );
[ + - ]
84 : :
85 : 12 : auto nmat = g_inputdeck.get< tag::param, eq, tag::nmat >()[c];
86 [ + - ][ + - ]: 12 : nfo.emplace_back( "number of materials", std::to_string( nmat ) );
87 : :
88 : 12 : auto prelax = g_inputdeck.get< tag::param, eq, tag::prelax >()[c];
89 [ + - ][ + - ]: 12 : nfo.emplace_back( "finite pressure relaxation", std::to_string( prelax ) );
90 : :
91 [ + + ]: 12 : if (prelax)
92 : : {
93 : : auto prelax_ts =
94 : 3 : g_inputdeck.get< tag::param, eq, tag::prelax_timescale >()[c];
95 : : nfo.emplace_back( "pressure relaxation time-scale",
96 [ + - ][ + - ]: 3 : std::to_string( prelax_ts ) );
97 : : }
98 : :
99 : 12 : auto intsharp = g_inputdeck.get< tag::param, eq, tag::intsharp >()[c];
100 [ + - ][ + - ]: 12 : nfo.emplace_back( "interface sharpening", std::to_string( intsharp ) );
101 : :
102 [ + + ]: 12 : if (intsharp)
103 : : {
104 : : auto intsharp_param =
105 : 2 : g_inputdeck.get< tag::param, eq, tag::intsharp_param >()[c];
106 : : nfo.emplace_back( "interface sharpening parameter",
107 [ + - ][ + - ]: 2 : std::to_string( intsharp_param ) );
108 : : }
109 : :
110 : 12 : auto ncomp = g_inputdeck.get< tag::component >().get< eq >()[c];
111 [ + - ][ + - ]: 12 : nfo.emplace_back( "number of components", std::to_string( ncomp ) );
112 : :
113 [ + - ]: 24 : nfo.emplace_back( "start offset in unknowns array", std::to_string(
114 [ + - ]: 24 : g_inputdeck.get< tag::component >().offset< eq >(c) ) );
115 : :
116 : : // Material property output
117 : 12 : const auto& matprop = g_inputdeck.get< tag::param, eq, tag::material >()[c];
118 [ + + ]: 24 : for (const auto& mtype : matprop) {
119 : 12 : const auto& m_id = mtype.get< tag::id >();
120 [ + - ]: 24 : ctr::Material opt;
121 [ + - ]: 12 : nfo.emplace_back( opt.name( mtype.get< tag::eos >() ),
122 [ + - ][ + - ]: 24 : std::to_string(m_id.size()) );
123 : :
124 [ + - ][ + - ]: 12 : nfo.emplace_back( "material id", parameters( m_id ) );
125 : : nfo.emplace_back( "ratio of specific heats",
126 [ + - ][ + - ]: 12 : parameters(mtype.get< tag::gamma >()) );
127 : : nfo.emplace_back( "specific heat at constant volume",
128 [ + - ][ + - ]: 12 : parameters(mtype.get< tag::cv >()) );
129 : : nfo.emplace_back( "material stiffness",
130 [ + - ][ + - ]: 12 : parameters(mtype.get< tag::pstiff >()) );
131 : :
132 : : // Viscosity is optional: vector may be empty
133 : 12 : const auto& mu = mtype.get< tag::mu >();
134 [ - + ]: 12 : if (!mu.empty())
135 [ - - ][ - - ]: 0 : nfo.emplace_back( "dynamic viscosity", parameters( mu ) );
136 : :
137 : : // Heat conductivity is optional: vector may be empty
138 : 12 : const auto& k = mtype.get< tag::k >();
139 [ - + ]: 12 : if (!k.empty())
140 [ - - ][ - - ]: 0 : nfo.emplace_back( "heat conductivity", parameters( k ) );
141 : : }
142 : :
143 : : // ICs and IC-boxes
144 : :
145 : 12 : const auto& ic = g_inputdeck.get< tag::param, eq, tag::ic >();
146 : :
147 : 12 : const auto& bgmatidic = ic.get< tag::materialid >();
148 [ - + ][ - - ]: 12 : if (bgmatidic.size() > c && !bgmatidic[c].empty())
[ - + ]
149 : : nfo.emplace_back( "IC background material id",
150 [ - - ][ - - ]: 0 : parameter( bgmatidic[c][0] ) );
151 : 12 : const auto& bgdensityic = ic.get< tag::density >();
152 [ - + ][ - - ]: 12 : if (bgdensityic.size() > c && !bgdensityic[c].empty())
[ - + ]
153 : : nfo.emplace_back( "IC background density",
154 [ - - ][ - - ]: 0 : parameter( bgdensityic[c][0] ) );
155 : 12 : const auto& bgvelocityic = ic.get< tag::velocity >();
156 [ - + ][ - - ]: 12 : if (bgvelocityic.size() > c && !bgvelocityic[c].empty())
[ - + ]
157 : : nfo.emplace_back( "IC background velocity",
158 [ - - ][ - - ]: 0 : parameters( bgvelocityic[c] ) );
159 : 12 : const auto& bgpressureic = ic.get< tag::pressure >();
160 [ - + ][ - - ]: 12 : if (bgpressureic.size() > c && !bgpressureic[c].empty())
[ - + ]
161 : : nfo.emplace_back( "IC background pressure",
162 [ - - ][ - - ]: 0 : parameter( bgpressureic[c][0] ) );
163 : 12 : const auto& bgenergyic = ic.get< tag::energy >();
164 [ - + ][ - - ]: 12 : if (bgenergyic.size() > c && !bgenergyic[c].empty())
[ - + ]
165 : : nfo.emplace_back( "IC background energy",
166 [ - - ][ - - ]: 0 : parameter( bgenergyic[c][0] ) );
167 : 12 : const auto& bgtemperatureic = ic.get< tag::temperature >();
168 [ - + ][ - - ]: 12 : if (bgtemperatureic.size() > c && !bgtemperatureic[c].empty())
[ - + ]
169 : : nfo.emplace_back( "IC background temperature",
170 [ - - ][ - - ]: 0 : parameter( bgtemperatureic[c][0] ) );
171 : :
172 : 12 : const auto& icbox = ic.get< tag::box >();
173 [ + - ]: 12 : if (icbox.size() > c) {
174 : 12 : std::size_t bcnt = 0;
175 [ - + ]: 12 : for (const auto& b : icbox[c]) { // for all boxes configured for this eq
176 : : std::vector< tk::real > box
177 : 0 : { b.get< tag::xmin >(), b.get< tag::xmax >(),
178 : 0 : b.get< tag::ymin >(), b.get< tag::ymax >(),
179 [ - - ]: 0 : b.get< tag::zmin >(), b.get< tag::zmax >() };
180 : :
181 [ - - ][ - - ]: 0 : std::string boxname = "IC box " + parameter(bcnt);
182 [ - - ][ - - ]: 0 : nfo.emplace_back( boxname, parameters( box ) );
183 : :
184 [ - - ]: 0 : nfo.emplace_back( boxname + " material id",
185 [ - - ][ - - ]: 0 : parameter( b.get< tag::materialid >() ) );
186 [ - - ]: 0 : nfo.emplace_back( boxname + " density",
187 [ - - ][ - - ]: 0 : parameter( b.get< tag::density >() ) );
188 [ - - ]: 0 : nfo.emplace_back( boxname + " velocity",
189 [ - - ][ - - ]: 0 : parameters( b.get< tag::velocity >() ) );
190 [ - - ]: 0 : nfo.emplace_back( boxname + " pressure",
191 [ - - ][ - - ]: 0 : parameter( b.get< tag::pressure >() ) );
192 [ - - ]: 0 : nfo.emplace_back( boxname + " internal energy per unit mass",
193 [ - - ][ - - ]: 0 : parameter( b.get< tag::energy >() ) );
194 [ - - ]: 0 : nfo.emplace_back( boxname + " mass",
195 [ - - ][ - - ]: 0 : parameter( b.get< tag::mass >() ) );
196 [ - - ]: 0 : nfo.emplace_back( boxname + " internal energy per unit volume",
197 [ - - ][ - - ]: 0 : parameter( b.get< tag::energy_content >() ) );
198 [ - - ]: 0 : nfo.emplace_back( boxname + " temperature",
199 [ - - ][ - - ]: 0 : parameter( b.get< tag::temperature >() ) );
200 : :
201 : 0 : ++bcnt;
202 : : }
203 : : }
204 : :
205 : 12 : return nfo;
206 : : }
207 : :
208 : : void
209 : 490 : assignMultiMatGetVars( const std::string& name, tk::GetVarFn& f )
210 : : // *****************************************************************************
211 : : // Assign functions that compute physics variables from the numerical solution
212 : : // for MultiMat
213 : : //! \param[in] name Name of variable whose tk::GetVarFn is to be assigned
214 : : //! \param[in,out] f Function assigned
215 : : // *****************************************************************************
216 : : {
217 : : using namespace kw;
218 : : using namespace multimat;
219 : :
220 [ + - ]: 490 : assign< outvar_density >( name, bulkDensityOutVar, f );
221 [ + - ]: 490 : assign< outvar_pressure >( name, bulkPressureOutVar, f );
222 : : assign< outvar_specific_total_energy >
223 [ + - ]: 490 : ( name, bulkSpecificTotalEnergyOutVar, f );
224 [ + - ]: 490 : assign< outvar_xvelocity >( name, velocityOutVar<0>, f );
225 [ + - ]: 490 : assign< outvar_yvelocity >( name, velocityOutVar<1>, f );
226 [ + - ]: 490 : assign< outvar_zvelocity >( name, velocityOutVar<2>, f );
227 [ + - ]: 490 : assign< outvar_material_indicator >( name, matIndicatorOutVar, f );
228 : 490 : }
229 : :
230 : : } // inciter::
|
