Branch data Line data Source code
1 : : // *****************************************************************************
2 : : /*!
3 : : \file src/PDE/ConfigureTransport.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 on the transport PDE
9 : : \details Register and compile configuration on the transport PDE.
10 : : */
11 : : // *****************************************************************************
12 : :
13 : : #include <set>
14 : : #include <map>
15 : : #include <vector>
16 : : #include <string>
17 : :
18 : : #include <brigand/algorithms/for_each.hpp>
19 : :
20 : : #include "Tags.hpp"
21 : : #include "CartesianProduct.hpp"
22 : : #include "PDEFactory.hpp"
23 : : #include "Inciter/Options/PDE.hpp"
24 : : #include "ContainerUtil.hpp"
25 : : #include "ConfigureTransport.hpp"
26 : : #include "Transport/Physics/CG.hpp"
27 : : #include "Transport/Physics/DG.hpp"
28 : : #include "Transport/CGTransport.hpp"
29 : : #include "Transport/DGTransport.hpp"
30 : : #include "Transport/Problem.hpp"
31 : : #include "InfoMesh.hpp"
32 : :
33 : : namespace inciter {
34 : :
35 : : void
36 : 1565 : registerTransport( CGFactory& cf,
37 : : DGFactory& df,
38 : : std::set< ctr::PDEType >& cgt,
39 : : std::set< ctr::PDEType >& dgt )
40 : : // *****************************************************************************
41 : : // Register transport PDE into PDE factory
42 : : //! \param[in,out] cf Continuous Galerkin PDE factory to register to
43 : : //! \param[in,out] df Discontinuous Galerkin PDE factory to register to
44 : : //! \param[in,out] cgt Counters for equation types registered into CG factory
45 : : //! \param[in,out] dgt Counters for equation types registered into DG factory
46 : : // *****************************************************************************
47 : : {
48 : : // Construct vector of vectors for all possible policies
49 : : using CGTransportPolicies =
50 : : tk::cartesian_product< cg::TransportPhysics, TransportProblems >;
51 : : // Register PDEs for all combinations of policies
52 : : brigand::for_each< CGTransportPolicies >(
53 : 1565 : registerCG< cg::Transport >( cf, cgt, ctr::PDEType::TRANSPORT ) );
54 : :
55 : : // Construct vector of vectors for all possible policies
56 : : using DGTransportPolicies =
57 : : tk::cartesian_product< dg::TransportPhysics, TransportProblems >;
58 : : // Register PDEs for all combinations of policies
59 : : brigand::for_each< DGTransportPolicies >(
60 : : registerDG< dg::Transport >( df, dgt, ctr::PDEType::TRANSPORT ) );
61 : 1565 : }
62 : :
63 : : std::vector< std::pair< std::string, std::string > >
64 : 126 : infoTransport( std::map< ctr::PDEType, tk::ctr::ncomp_t >& cnt )
65 : : // *****************************************************************************
66 : : // Return information on the transport PDE
67 : : //! \param[inout] cnt std::map of counters for all PDE types
68 : : //! \return vector of string pairs describing the PDE configuration
69 : : // *****************************************************************************
70 : : {
71 : : using tag::param;
72 : : using tk::parameters;
73 : : using eq = tag::transport;
74 : :
75 [ + - ]: 126 : auto c = ++cnt[ ctr::PDEType::TRANSPORT ]; // count eqs
76 : : --c; // used to index vectors starting with 0
77 : :
78 : : std::vector< std::pair< std::string, std::string > > nfo;
79 : :
80 [ + - ][ + - ]: 252 : nfo.emplace_back( ctr::PDE().name( ctr::PDEType::TRANSPORT ), "" );
81 : :
82 [ + - ]: 126 : nfo.emplace_back( "dependent variable", std::string( 1,
83 [ + - ][ + - ]: 126 : g_inputdeck.get< param, eq, tag::depvar >()[c] ) );
84 : :
85 [ + - ]: 126 : infoMesh< eq >( c, nfo );
86 : :
87 [ + - ]: 252 : nfo.emplace_back( "problem", ctr::Problem().name(
88 [ + - ]: 252 : g_inputdeck.get< param, eq, tag::problem >()[c] ) );
89 : :
90 : 126 : nfo.emplace_back( "start offset in unknowns array", std::to_string(
91 [ + - ]: 126 : g_inputdeck.get< tag::component >().offset< eq >(c) ) );
92 : :
93 [ + - ]: 126 : auto intsharp = g_inputdeck.get< tag::param, eq, tag::intsharp >()[c];
94 [ + - ]: 126 : nfo.emplace_back( "interface sharpening", std::to_string( intsharp ) );
95 : :
96 [ - + ]: 126 : if (intsharp)
97 : : {
98 : : auto intsharp_param =
99 [ - - ]: 0 : g_inputdeck.get< tag::param, eq, tag::intsharp_param >()[c];
100 : : nfo.emplace_back( "interface sharpening parameter",
101 [ - - ]: 0 : std::to_string( intsharp_param ) );
102 : : }
103 : :
104 [ + - ]: 126 : auto ncomp = g_inputdeck.get< tag::component >().get< eq >()[c];
105 [ + - ]: 126 : nfo.emplace_back( "number of components", std::to_string( ncomp ) );
106 : :
107 : : const auto& diff = g_inputdeck.get< param, eq, tag::diffusivity >();
108 [ + + ]: 126 : if (diff.size() > c)
109 [ + - ][ + - ]: 14 : nfo.emplace_back( "coeff diffusivity [" + std::to_string( ncomp ) + "]",
[ - + ][ - + ]
[ - + ][ - - ]
[ - - ][ - - ]
110 [ + - ][ + - ]: 21 : parameters( diff[c] ) );
111 : :
112 : : const auto& u0 = g_inputdeck.get< param, eq, tag::u0 >();
113 [ + + ]: 126 : if (u0.size() > c)
114 [ + - ][ + - ]: 14 : nfo.emplace_back( "coeff u0 [" + std::to_string( ncomp ) + "]",
[ - + ][ - + ]
[ - + ][ - - ]
[ - - ][ - - ]
115 [ + - ][ + - ]: 21 : parameters( u0[c] ) );
116 : :
117 : : const auto& lambda = g_inputdeck.get< param, eq, tag::lambda >();
118 [ + + ]: 126 : if (lambda.size() > c)
119 [ + - ][ + - ]: 14 : nfo.emplace_back( "coeff lambda [" + std::to_string( ncomp ) + "]",
[ - + ][ - + ]
[ - + ][ - - ]
[ - - ][ - - ]
120 [ + - ][ + - ]: 21 : parameters( lambda[c] ) );
121 : :
122 : : const auto& bcdir = g_inputdeck.get< param, eq, tag::bc, tag::bcdir >();
123 [ + + ]: 126 : if (bcdir.size() > c)
124 [ + - ][ + - ]: 72 : nfo.emplace_back( "Dirichlet boundary [" + std::to_string( ncomp ) + "]",
[ - + ][ - + ]
[ - + ][ - - ]
[ - - ][ - - ]
125 [ + - ][ + - ]: 108 : parameters( bcdir[c] ) );
126 : :
127 : : const auto& bcsym = g_inputdeck.get< param, eq, tag::bc, tag::bcsym >();
128 [ + + ]: 126 : if (bcsym.size() > c)
129 [ + - ][ + - ]: 8 : nfo.emplace_back( "Symmetry boundary [" + std::to_string( ncomp ) + "]",
[ - + ][ - + ]
[ - + ][ - - ]
[ - - ][ - - ]
130 [ + - ][ + - ]: 12 : parameters( bcsym[c] ) );
131 : :
132 : : const auto& bcinlet =
133 : : g_inputdeck.get< param, eq, tag::bc, tag::bcinlet >();
134 [ + + ]: 126 : if (bcinlet.size() > c)
135 [ + - ][ + - ]: 40 : nfo.emplace_back( "Inlet boundary [" + std::to_string( ncomp ) + "]",
[ - + ][ - + ]
[ - + ][ - - ]
[ - - ][ - - ]
136 [ + - ][ + - ]: 60 : parameters( bcinlet[c] ) );
137 : :
138 : : const auto& bcoutlet =
139 : : g_inputdeck.get< param, eq, tag::bc, tag::bcoutlet >();
140 [ + + ]: 126 : if (bcoutlet.size() > c)
141 [ + - ][ + - ]: 56 : nfo.emplace_back( "Outlet boundary [" + std::to_string( ncomp ) + "]",
[ - + ][ - + ]
[ - + ][ - - ]
[ - - ][ - - ]
142 [ + - ][ + - ]: 84 : parameters( bcoutlet[c] ) );
143 : :
144 : : const auto& bcextrapolate =
145 : : g_inputdeck.get< param, eq, tag::bc, tag::bcextrapolate >();
146 [ + + ]: 126 : if (bcextrapolate.size() > c)
147 [ + - ][ + - ]: 56 : nfo.emplace_back( "Symmetry boundary [" + std::to_string( ncomp ) + "]",
[ - + ][ - + ]
[ - + ][ - - ]
[ - - ][ - - ]
148 [ + - ][ + - ]: 84 : parameters( bcextrapolate[c] ) );
149 : :
150 : 126 : return nfo;
151 : : }
152 : :
153 : : void
154 [ + - ]: 602 : assignTransportGetVars( const std::string& name, tk::GetVarFn& f )
155 : : // *****************************************************************************
156 : : // Assign functions that compute physics variables from the numerical solution
157 : : // for Transport
158 : : //! \param[in] name Name of variable whose tk::GetVarFn is to be assigned
159 : : //! \param[in,out] f Function assigned
160 : : // *****************************************************************************
161 : : {
162 : : using namespace kw;
163 : : using namespace transport;
164 : :
165 [ + - ]: 602 : assign< outvar_material_indicator >( name, matIndicatorOutVar, f );
166 : 602 : }
167 : :
168 : : } // inciter::
|
