TrioCFD 1.9.8
TrioCFD documentation
Loading...
Searching...
No Matches
Iterateur_VDF_Face.tpp
1/****************************************************************************
2* Copyright (c) 2026, CEA
3* All rights reserved.
4*
5* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
6* 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
7* 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
8* 3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
9*
10* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
11* IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
12* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
13*
14*****************************************************************************/
15
16#ifndef Iterateur_VDF_Face_TPP_included
17#define Iterateur_VDF_Face_TPP_included
18
19#include <Champ_Uniforme.h>
20#include <communications.h>
21#include <Pb_Multiphase.h>
22#include <TRUSTSingle.h>
23#include <Option_VDF.h>
24
25template<class _TYPE_>
26void Iterateur_VDF_Face<_TYPE_>::ajouter_blocs(matrices_t mats, DoubleTab& secmem, const tabs_t& semi_impl) const
27{
28 ((_TYPE_&) flux_evaluateur).mettre_a_jour();
29 assert(op_base->equation().inconnue().valeurs().nb_dim() < 3);
30 const int ncomp = op_base->equation().inconnue().valeurs().line_size();
31 DoubleTab& tab_flux_bords = op_base->flux_bords();
32 tab_flux_bords.resize(le_dom->nb_faces_bord(), dimension);
33 tab_flux_bords = 0.;
34
35 if (ncomp == 1)
36 {
37 ajouter_blocs_aretes_bords<SingleDouble>(ncomp, mats, secmem, semi_impl);
38 ajouter_blocs_aretes_coins<SingleDouble>(ncomp, mats, secmem, semi_impl);
39 ajouter_blocs_aretes_internes<SingleDouble>(ncomp, mats, secmem, semi_impl);
40 ajouter_blocs_aretes_mixtes<SingleDouble>(ncomp, mats, secmem, semi_impl);
41 ajouter_blocs_fa7_sortie_libre<SingleDouble>(ncomp, mats, secmem, semi_impl);
42 ajouter_blocs_fa7_elem<SingleDouble>(ncomp, mats, secmem, semi_impl);
43 }
44 else
45 {
46 ajouter_blocs_aretes_bords<ArrOfDouble>(ncomp, mats, secmem, semi_impl);
47 ajouter_blocs_aretes_coins<ArrOfDouble>(ncomp, mats, secmem, semi_impl);
48 ajouter_blocs_aretes_internes<ArrOfDouble>(ncomp, mats, secmem, semi_impl);
49 ajouter_blocs_aretes_mixtes<ArrOfDouble>(ncomp, mats, secmem, semi_impl);
50 ajouter_blocs_fa7_sortie_libre<ArrOfDouble>(ncomp, mats, secmem, semi_impl);
51 ajouter_blocs_fa7_elem<ArrOfDouble>(ncomp, mats, secmem, semi_impl);
52 }
53
54 if (!incompressible_ )
55 {
56 assert (is_pb_multi && is_conv_op_);
57 if (ncomp == 1)
58 ajouter_pour_compressible<SingleDouble>(ncomp, mats, secmem, semi_impl);
59 else
60 ajouter_pour_compressible<ArrOfDouble>(ncomp, mats, secmem, semi_impl);
61 }
62
63 // On multiplie les flux au bord par rho en hydraulique (sert uniquement a la sortie)
64 if (!is_pb_multi) multiply_by_rho_if_hydraulique(tab_flux_bords);
65}
66
67/* ================== *
68 * ====== BORDS =====
69 * ================== */
70template<class _TYPE_> template<typename Type_Double>
71void Iterateur_VDF_Face<_TYPE_>::ajouter_blocs_aretes_bords(const int ncomp, const matrices_t& mats, DoubleTab& secmem, const tabs_t& semi_impl) const
72{
73 if (!_TYPE_::CALC_ARR_BORD) return; /* do nothing */
74
75 for (int n_arete = premiere_arete_bord; n_arete < derniere_arete_bord; n_arete++)
76 {
77 const int n_type = type_arete_bord(n_arete - premiere_arete_bord);
78 switch(n_type)
79 {
80 case TypeAreteBordVDF::PAROI_PAROI:
81 ajouter_blocs_aretes_bords_<_TYPE_::CALC_ARR_PAR, Type_Flux_Arete::PAROI, Type_Double>(n_arete, ncomp, mats, secmem, semi_impl);
82 break;
83 case TypeAreteBordVDF::PAROI_FLUIDE:
84 ajouter_blocs_aretes_bords_<_TYPE_::CALC_ARR_PAR_FL, Type_Flux_Arete::PAROI_FLUIDE, Type_Double>(n_arete, ncomp, mats, secmem, semi_impl);
85 break;
86 case TypeAreteBordVDF::FLUIDE_FLUIDE:
87 ajouter_blocs_aretes_bords_<_TYPE_::CALC_ARR_FL, Type_Flux_Arete::FLUIDE, Type_Double>(n_arete, ncomp, mats, secmem, semi_impl);
88 break;
89 case TypeAreteBordVDF::PAROI_NAVIER:
90 ajouter_blocs_aretes_bords_<_TYPE_::CALC_ARR_NAVIER_PAR, Type_Flux_Arete::NAVIER_PAROI, Type_Double>(n_arete, ncomp, mats, secmem, semi_impl);
91 break;
92 case TypeAreteBordVDF::FLUIDE_NAVIER:
93 ajouter_blocs_aretes_bords_<_TYPE_::CALC_ARR_NAVIER_FL, Type_Flux_Arete::NAVIER_FLUIDE, Type_Double>(n_arete, ncomp, mats, secmem, semi_impl);
94 break;
95 case TypeAreteBordVDF::NAVIER_NAVIER:
96 ajouter_blocs_aretes_bords_<_TYPE_::CALC_ARR_NAVIER, Type_Flux_Arete::NAVIER, Type_Double>(n_arete, ncomp, mats, secmem, semi_impl);
97 break;
98 case TypeAreteBordVDF::PERIO_PERIO:
99 ajouter_blocs_aretes_bords_<_TYPE_::CALC_ARR_PERIO, Type_Flux_Arete::PERIODICITE, Type_Double>(n_arete, ncomp, mats, secmem, semi_impl);
100 break;
101 default:
102 Cerr << "On a rencontre un type d'arete non prevu : [ num arete : " << n_arete << " ], [ type : " << n_type << " ]" << finl;
103 Process::exit();
104 }
105 }
106}
107
108template <class _TYPE_> template <bool should_calc_flux, Type_Flux_Arete Arete_Type, typename Type_Double>
109std::enable_if_t< Arete_Type == Type_Flux_Arete::PAROI || Arete_Type == Type_Flux_Arete::NAVIER || Arete_Type == Type_Flux_Arete::NAVIER_PAROI, void>
110Iterateur_VDF_Face<_TYPE_>::ajouter_blocs_aretes_bords_(const int n_arete, const int ncomp, const matrices_t& mats, DoubleTab& secmem, const tabs_t& semi_impl) const
111{
112 if (should_calc_flux)
113 {
114 constexpr bool is_PAROI = (Arete_Type == Type_Flux_Arete::PAROI);
115 Type_Double flux(ncomp), aii1_2(ncomp), aii3_4(ncomp), ajj1_2(ncomp);
116 const int n = le_dom->nb_faces_bord(), fac1 = Qdm(n_arete, 0), fac2 = Qdm(n_arete, 1), fac3 = Qdm(n_arete, 2), signe = Qdm(n_arete, 3);
117 DoubleTab& tab_flux_bords = op_base->flux_bords();
118 const DoubleTab& inco = semi_impl.count(nom_ch_inco_) ? semi_impl.at(nom_ch_inco_) : le_champ_convecte_ou_inc->valeurs();
119
120 const DoubleTab* a_r = (!is_pb_multi || !is_conv_op_) ? nullptr : semi_impl.count("alpha_rho") ? &semi_impl.at("alpha_rho") :
121 &ref_cast(Pb_Multiphase,op_base->equation().probleme()).equation_masse().champ_conserve().valeurs();
122
123 // second membre
124 flux_evaluateur.template flux_arete < Arete_Type > (inco, a_r, fac1, fac2, fac3, signe, flux);
125 for (int k = 0; k < ncomp; k++)
126 {
127 secmem(fac3, k) += signe * flux[k];
128 if (is_PAROI)
129 {
130 if (fac1 < n) tab_flux_bords(fac1, orientation(fac3)) -= 0.5 * signe * flux[k];
131 if (fac2 < n) tab_flux_bords(fac2, orientation(fac3)) -= 0.5 * signe * flux[k];
132 }
133 }
134
135 // derivees : champ convecte
136 Matrice_Morse *matrice = (is_pb_multi && is_conv_op_) ? (mats.count(nom_ch_inco_) && !semi_impl.count(nom_ch_inco_) ? mats.at(nom_ch_inco_) : nullptr) :
137 (mats.count(nom_ch_inco_) ? mats.at(nom_ch_inco_) : nullptr);
138 if (matrice)
139 {
140 flux_evaluateur.template coeffs_arete < Arete_Type > (a_r, fac1, fac2, fac3, signe, aii1_2, aii3_4, ajj1_2);
141 for (int i = 0; i < ncomp; i++)
142 fill_coeff_matrice_morse < Type_Double > (fac3, i, ncomp, signe, aii3_4, *matrice);
143 }
144 }
145}
146
147template <class _TYPE_> template <bool should_calc_flux, Type_Flux_Arete Arete_Type, typename Type_Double>
148std::enable_if_t<Arete_Type == Type_Flux_Arete::FLUIDE || Arete_Type == Type_Flux_Arete::PAROI_FLUIDE || Arete_Type == Type_Flux_Arete::NAVIER_FLUIDE, void>
149Iterateur_VDF_Face<_TYPE_>::ajouter_blocs_aretes_bords_(const int n_arete, const int ncomp, const matrices_t& mats, DoubleTab& secmem, const tabs_t& semi_impl) const
150{
151 if (should_calc_flux)
152 {
153 constexpr bool is_FLUIDE = (Arete_Type == Type_Flux_Arete::FLUIDE), is_PAROI_FL = (Arete_Type == Type_Flux_Arete::PAROI_FLUIDE);
154 Type_Double flux3(ncomp), flux1_2(ncomp), aii1_2(ncomp), aii3_4(ncomp), ajj1_2(ncomp);
155 const int n = le_dom->nb_faces_bord(), fac1 = Qdm(n_arete, 0), fac2 = Qdm(n_arete, 1), fac3 = Qdm(n_arete, 2), signe = Qdm(n_arete, 3);
156 DoubleTab& tab_flux_bords = op_base->flux_bords();
157 const DoubleTab& inco = semi_impl.count(nom_ch_inco_) ? semi_impl.at(nom_ch_inco_) : le_champ_convecte_ou_inc->valeurs();
158
159 const DoubleTab* a_r = (!is_pb_multi || !is_conv_op_) ? nullptr : semi_impl.count("alpha_rho") ? &semi_impl.at("alpha_rho") :
160 &ref_cast(Pb_Multiphase,op_base->equation().probleme()).equation_masse().champ_conserve().valeurs();
161
162 // second membre
163 flux_evaluateur.template flux_arete < Arete_Type > (inco, a_r, fac1, fac2, fac3, signe, flux3, flux1_2);
164 for (int k = 0; k < ncomp; k++)
165 secmem(fac3, k) += signe * flux3[k];
166
167 fill_resu_tab < Type_Double > (fac1, fac2, ncomp, flux1_2, secmem);
168
169 if (is_FLUIDE || is_PAROI_FL)
170 {
171 if (fac1 < n)
172 for (int k = 0; k < ncomp; k++) tab_flux_bords(fac1, orientation(fac3)) -= 0.5 * signe * flux3[k];
173
174 if (fac2 < n)
175 for (int k = 0; k < ncomp; k++) tab_flux_bords(fac2, orientation(fac3)) -= 0.5 * signe * flux3[k];
176 }
177
178 // derivees : champ convecte
179 Matrice_Morse *matrice = (is_pb_multi && is_conv_op_) ? (mats.count(nom_ch_inco_) && !semi_impl.count(nom_ch_inco_) ? mats.at(nom_ch_inco_) : nullptr) :
180 (mats.count(nom_ch_inco_) ? mats.at(nom_ch_inco_) : nullptr);
181 if (matrice)
182 {
183 flux_evaluateur.template coeffs_arete < Arete_Type > (a_r, fac1, fac2, fac3, signe, aii1_2, aii3_4, ajj1_2);
184 for (int i = 0; i < ncomp; i++)
185 {
186 fill_coeff_matrice_morse < Type_Double > (fac3, i, ncomp, signe, aii3_4, *matrice);
187 fill_coeff_matrice_morse < Type_Double > (fac1, fac2, i, ncomp, aii1_2, ajj1_2, *matrice);
188 }
189 }
190 }
191}
192
193template <class _TYPE_> template <bool should_calc_flux, Type_Flux_Arete Arete_Type, typename Type_Double>
194std::enable_if_t<Arete_Type == Type_Flux_Arete::PERIODICITE, void>
195Iterateur_VDF_Face<_TYPE_>::ajouter_blocs_aretes_bords_(const int n_arete, const int ncomp, const matrices_t& mats, DoubleTab& secmem, const tabs_t& semi_impl) const
196{
197 if (should_calc_flux)
198 {
199 Type_Double flux3_4(ncomp), flux1_2(ncomp), aii(ncomp), ajj(ncomp);
200 const int fac1 = Qdm(n_arete, 0), fac2 = Qdm(n_arete, 1), fac3 = Qdm(n_arete, 2), fac4 = Qdm(n_arete, 3);
201 const DoubleTab& inco = semi_impl.count(nom_ch_inco_) ? semi_impl.at(nom_ch_inco_) : le_champ_convecte_ou_inc->valeurs();
202
203
204
205 // second membre
206 flux_evaluateur.template flux_arete < Arete_Type > (inco, nullptr, fac1, fac2, fac3, fac4, flux3_4, flux1_2);
207 for (int k = 0; k < ncomp; k++)
208 {
209 secmem(fac3, k) += 0.5 * flux3_4[k];
210 secmem(fac4, k) -= 0.5 * flux3_4[k];
211 }
212
213 fill_resu_tab < Type_Double > (fac1, fac2, ncomp, flux1_2, secmem);
214
215 // derivees : champ convecte
216 Matrice_Morse *matrice = (is_pb_multi && is_conv_op_) ? (mats.count(nom_ch_inco_) && !semi_impl.count(nom_ch_inco_) ? mats.at(nom_ch_inco_) : nullptr) :
217 (mats.count(nom_ch_inco_) ? mats.at(nom_ch_inco_) : nullptr);
218 if (matrice)
219 {
220 flux_evaluateur.template coeffs_arete < Arete_Type > (nullptr, fac3, fac4, fac1, fac2, aii, ajj);
221 for (int i = 0; i < ncomp; i++)
222 fill_coeff_matrice_morse(fac1, fac2, i, ncomp, aii, ajj, *matrice);
223
224 flux_evaluateur.template coeffs_arete < Arete_Type > (nullptr, fac1, fac2, fac3, fac4, aii, ajj);
225 for (int i = 0; i < ncomp; i++)
226 {
227 aii[i] *= 0.5;
228 ajj[i] *= 0.5;
229 fill_coeff_matrice_morse < Type_Double > (fac3, fac4, i, ncomp, aii, ajj, *matrice);
230 }
231 }
232 }
233}
234
235/* ================== *
236 * ====== COINS =====
237 * ================== */
238template<class _TYPE_> template <typename Type_Double>
239void Iterateur_VDF_Face<_TYPE_>::ajouter_blocs_aretes_coins(const int ncomp, matrices_t mats, DoubleTab& secmem, const tabs_t& semi_impl) const
240{
241 for (int n_arete = premiere_arete_coin; n_arete < derniere_arete_coin; n_arete++)
242 {
243 const int n_type = type_arete_coin(n_arete - premiere_arete_coin);
244 switch(n_type)
245 {
246 case TypeAreteCoinVDF::PAROI_FLUIDE:
247 ajouter_blocs_aretes_coins_<_TYPE_::CALC_ARR_PAR, Type_Flux_Arete::PAROI, TypeAreteCoinVDF::PAROI_FLUIDE, Type_Double>(n_arete, ncomp, mats, secmem, semi_impl);
248 break;
249 case TypeAreteCoinVDF::FLUIDE_PAROI:
250 ajouter_blocs_aretes_coins_<_TYPE_::CALC_ARR_PAR, Type_Flux_Arete::PAROI, TypeAreteCoinVDF::FLUIDE_PAROI, Type_Double>(n_arete, ncomp, mats, secmem, semi_impl);
251 break;
252 case TypeAreteCoinVDF::PERIO_PAROI:
253 ajouter_blocs_aretes_coins_<_TYPE_::CALC_ARR_PAR, Type_Flux_Arete::PAROI, TypeAreteCoinVDF::PERIO_PAROI, Type_Double>(n_arete, ncomp, mats, secmem, semi_impl);
254 break;
255 case TypeAreteCoinVDF::FLUIDE_FLUIDE:
256 ajouter_blocs_aretes_coins_<_TYPE_::CALC_ARR_COIN_FL, Type_Flux_Arete::COIN_FLUIDE, Type_Double>(n_arete, ncomp, mats, secmem, semi_impl);
257 break;
258 case TypeAreteCoinVDF::PERIO_PERIO:
259 ajouter_blocs_aretes_coins_<_TYPE_::CALC_ARR_PERIO, Type_Flux_Arete::PERIODICITE, Type_Double>(n_arete, ncomp, mats, secmem, semi_impl);
260 break;
261 default:
262 break;
263 }
264 }
265}
266
267template <class _TYPE_> template <bool should_calc_flux, Type_Flux_Arete Arete_Type, TypeAreteCoinVDF::type_arete Arete_Type_Coin, typename Type_Double>
268std::enable_if_t< Arete_Type == Type_Flux_Arete::PAROI, void>
269Iterateur_VDF_Face<_TYPE_>::ajouter_blocs_aretes_coins_(const int n_arete, const int ncomp, matrices_t mats, DoubleTab& secmem, const tabs_t& semi_impl) const
270{
271 if (should_calc_flux)
272 {
273 constexpr bool is_PERIO_PAROI = (Arete_Type_Coin == TypeAreteCoinVDF::PERIO_PAROI);
274 Type_Double flux(ncomp), aii1_2(ncomp), aii3_4(ncomp), ajj1_2(ncomp);
275 const int fac1 = Qdm(n_arete, 0), fac2 = Qdm(n_arete, 1), fac3 = Qdm(n_arete, 2), signe = Qdm(n_arete, 3);
276 DoubleTab& tab_flux_bords = op_base->flux_bords();
277 const DoubleTab& inco = semi_impl.count(nom_ch_inco_) ? semi_impl.at(nom_ch_inco_) : le_champ_convecte_ou_inc->valeurs();
278
279 const DoubleTab* a_r = (!is_pb_multi || !is_conv_op_) ? nullptr : semi_impl.count("alpha_rho") ? &semi_impl.at("alpha_rho") :
280 &ref_cast(Pb_Multiphase,op_base->equation().probleme()).equation_masse().champ_conserve().valeurs();
281
282 // second membre
283 flux_evaluateur.template flux_arete < Arete_Type > (inco, a_r, fac1, fac2, fac3, signe, flux);
284 for (int k = 0; k < ncomp; k++)
285 {
286 secmem(fac3, k) += signe * flux[k];
287 if (is_PERIO_PAROI) /* on met 0.25 sur les deux faces (car on ajoutera deux fois la contrib) */
288 {
289 tab_flux_bords(fac1, orientation(fac3)) -= 0.25 * signe * flux[k];
290 tab_flux_bords(fac2, orientation(fac3)) -= 0.25 * signe * flux[k];
291 }
292 else
293 tab_flux_bords(fac1, orientation(fac3)) -= 0.5 * signe * flux[k];
294 }
295
296 // derivees : champ convecte
297 Matrice_Morse *matrice = (is_pb_multi && is_conv_op_) ? (mats.count(nom_ch_inco_) && !semi_impl.count(nom_ch_inco_) ? mats.at(nom_ch_inco_) : nullptr) :
298 (mats.count(nom_ch_inco_) ? mats.at(nom_ch_inco_) : nullptr);
299 if (matrice)
300 {
301 flux_evaluateur.template coeffs_arete < Arete_Type > (a_r, fac1, fac2, fac3, signe, aii1_2, aii3_4, ajj1_2);
302 for (int i = 0; i < ncomp; i++)
303 fill_coeff_matrice_morse(fac3, i, ncomp, signe, aii3_4, *matrice);
304 }
305 }
306}
307
308template <class _TYPE_> template <bool should_calc_flux, Type_Flux_Arete Arete_Type, typename Type_Double>
309std::enable_if_t<Arete_Type == Type_Flux_Arete::COIN_FLUIDE, void>
310Iterateur_VDF_Face<_TYPE_>::ajouter_blocs_aretes_coins_(const int n_arete, const int ncomp, matrices_t mats, DoubleTab& secmem, const tabs_t& semi_impl) const
311{
312 if (should_calc_flux)
313 {
314 Type_Double flux3(ncomp), flux1_2(ncomp), aii1_2(ncomp), aii3_4(ncomp), ajj1_2(ncomp);
315 const int n = le_dom->nb_faces_bord(), fac1 = Qdm(n_arete, 0), fac2 = Qdm(n_arete, 1), fac3 = Qdm(n_arete, 2), signe = Qdm(n_arete, 3);
316 DoubleTab& tab_flux_bords = op_base->flux_bords();
317 const DoubleTab& inco = semi_impl.count(nom_ch_inco_) ? semi_impl.at(nom_ch_inco_) : le_champ_convecte_ou_inc->valeurs();
318
319 const DoubleTab* a_r = (!is_pb_multi || !is_conv_op_) ? nullptr : semi_impl.count("alpha_rho") ? &semi_impl.at("alpha_rho") :
320 &ref_cast(Pb_Multiphase,op_base->equation().probleme()).equation_masse().champ_conserve().valeurs();
321
322 // second membre
323 flux_evaluateur.template flux_arete < Arete_Type > (inco, a_r, fac1, fac2, fac3, signe, flux3, flux1_2);
324 for (int k = 0; k < ncomp; k++)
325 {
326 secmem(fac3, k) += signe * flux3[k];
327 secmem(fac1, k) += flux1_2[k];
328 if (fac1 < n) tab_flux_bords(fac1, orientation(fac3)) -= 0.5 * signe * flux3[k];
329 }
330
331 // derivees : champ convecte
332 Matrice_Morse *matrice = (is_pb_multi && is_conv_op_) ? (mats.count(nom_ch_inco_) && !semi_impl.count(nom_ch_inco_) ? mats.at(nom_ch_inco_) : nullptr) :
333 (mats.count(nom_ch_inco_) ? mats.at(nom_ch_inco_) : nullptr);
334 if (matrice)
335 {
336 flux_evaluateur.template coeffs_arete < Arete_Type > (a_r, fac1, fac2, fac3, signe, aii1_2, aii3_4, ajj1_2);
337
338 for (int i = 0; i < ncomp; i++)
339 {
340 fill_coeff_matrice_morse(fac3, i, ncomp, signe, aii3_4, *matrice);
341 fill_coeff_matrice_morse < Type_Double > (fac1, i, ncomp, 1, aii1_2, *matrice);
342 }
343 }
344 }
345}
346
347template <class _TYPE_> template <bool should_calc_flux, Type_Flux_Arete Arete_Type, typename Type_Double>
348std::enable_if_t<Arete_Type == Type_Flux_Arete::PERIODICITE, void>
349Iterateur_VDF_Face<_TYPE_>::ajouter_blocs_aretes_coins_(const int n_arete, const int ncomp, matrices_t mats, DoubleTab& secmem, const tabs_t& semi_impl) const
350{
351 if (should_calc_flux)
352 {
353 Type_Double flux3_4(ncomp), flux1_2(ncomp), aii(ncomp), ajj(ncomp);
354 const int fac1 = Qdm(n_arete, 0), fac2 = Qdm(n_arete, 1), fac3 = Qdm(n_arete, 2), fac4 = Qdm(n_arete, 3);
355 const DoubleTab& inco = semi_impl.count(nom_ch_inco_) ? semi_impl.at(nom_ch_inco_) : le_champ_convecte_ou_inc->valeurs();
356
357 // second membre
358 flux_evaluateur.template flux_arete < Arete_Type > (inco, nullptr, fac1, fac2, fac3, fac4, flux3_4, flux1_2);
359 for (int k = 0; k < ncomp; k++)
360 {
361 secmem(fac3, k) += 0.5 * flux3_4[k];
362 secmem(fac4, k) -= 0.5 * flux3_4[k];
363 secmem(fac1, k) += 0.5 * flux1_2[k];
364 secmem(fac2, k) -= 0.5 * flux1_2[k];
365 }
366
367 // derivees : champ convecte
368 Matrice_Morse *matrice = (is_pb_multi && is_conv_op_) ? (mats.count(nom_ch_inco_) && !semi_impl.count(nom_ch_inco_) ? mats.at(nom_ch_inco_) : nullptr) :
369 (mats.count(nom_ch_inco_) ? mats.at(nom_ch_inco_) : nullptr);
370 if (matrice)
371 {
372 flux_evaluateur.template coeffs_arete < Arete_Type > (nullptr, fac3, fac4, fac1, fac2, aii, ajj);
373 for (int i = 0; i < ncomp; i++)
374 fill_coeff_matrice_morse < Type_Double > (fac1, fac2, i, ncomp, aii, ajj, *matrice);
375
376 flux_evaluateur.template coeffs_arete < Arete_Type > (nullptr, fac1, fac2, fac3, fac4, aii, ajj);
377 for (int i = 0; i < ncomp; i++)
378 fill_coeff_matrice_morse < Type_Double > (fac3, fac4, i, ncomp, aii, ajj, *matrice);
379 }
380 }
381}
382
383/* =============================== *
384 * ====== INTERNES & MIXTES =====
385 * =============================== */
386template<class _TYPE_> template <typename Type_Double>
387void Iterateur_VDF_Face<_TYPE_>::ajouter_blocs_aretes_internes(const int ncomp, matrices_t mats, DoubleTab& secmem, const tabs_t& semi_impl) const
388{
389 if(!_TYPE_::CALC_ARR_INT) return; /* do nothing */
390
391 ajouter_blocs_aretes_generique_<true, Type_Flux_Arete::INTERNE, Type_Double>(premiere_arete_interne, derniere_arete_interne, ncomp, mats, secmem, semi_impl);
392}
393
394template<class _TYPE_> template <typename Type_Double>
395void Iterateur_VDF_Face<_TYPE_>::ajouter_blocs_aretes_mixtes(const int ncomp, matrices_t mats, DoubleTab& secmem, const tabs_t& semi_impl) const
396{
397 if(!_TYPE_::CALC_ARR_MIXTE || Option_VDF::DEACTIVATE_ARETE_MIXTE) return; /* do nothing */
398
399 ajouter_blocs_aretes_generique_<true, Type_Flux_Arete::MIXTE, Type_Double>(premiere_arete_mixte, derniere_arete_mixte, ncomp, mats, secmem, semi_impl);
400}
401
402template <class _TYPE_> template <bool should_calc_flux, Type_Flux_Arete Arete_Type, typename Type_Double>
403std::enable_if_t<Arete_Type == Type_Flux_Arete::INTERNE || Arete_Type == Type_Flux_Arete::MIXTE, void>
404Iterateur_VDF_Face<_TYPE_>::ajouter_blocs_aretes_generique_(const int debut, const int fin, const int ncomp, matrices_t mats, DoubleTab& secmem, const tabs_t& semi_impl) const
405{
406 // XXX : tab_flux_bords rempli seulement si MIXTE ... ie pas INTERNE !
407 if (should_calc_flux)
408 {
409 constexpr bool is_MIXTE = (Arete_Type == Type_Flux_Arete::MIXTE);
410 Type_Double flux(ncomp), aii(ncomp), ajj(ncomp);
411 DoubleTab& tab_flux_bords = op_base->flux_bords();
412 const DoubleTab& inco = semi_impl.count(nom_ch_inco_) ? semi_impl.at(nom_ch_inco_) : le_champ_convecte_ou_inc->valeurs();
413
414 const DoubleTab* a_r = (!is_pb_multi || !is_conv_op_) ? nullptr : semi_impl.count("alpha_rho") ? &semi_impl.at("alpha_rho") :
415 &ref_cast(Pb_Multiphase,op_base->equation().probleme()).equation_masse().champ_conserve().valeurs();
416
417 // second membre
418 for (int n_arete = debut; n_arete < fin; n_arete++)
419 {
420 flux = 0.;
421 const int fac1 = Qdm(n_arete, 0), fac2 = Qdm(n_arete, 1), fac3 = Qdm(n_arete, 2), fac4 = Qdm(n_arete, 3);
422 const int n = le_dom->nb_faces_bord(), n2 = le_dom->nb_faces_tot(); /* GF pour assurer bilan seq = para */
423 flux_evaluateur.template flux_arete < Arete_Type > (inco, a_r, fac1, fac2, fac3, fac4, flux);
424 fill_resu_tab < Type_Double > (fac3, fac4, ncomp, flux, secmem);
425
426 if (is_MIXTE)
427 {
428 if (fac4 < n2)
429 {
430 if (fac1 < n)
431 for (int k = 0; k < ncomp; k++) tab_flux_bords(fac1, orientation(fac3)) -= flux[k];
432
433 if (fac2 < n)
434 for (int k = 0; k < ncomp; k++) tab_flux_bords(fac2, orientation(fac4)) -= flux[k];
435 }
436 if (fac3 < n2)
437 {
438 if (fac1 < n)
439 for (int k = 0; k < ncomp; k++) tab_flux_bords(fac1, orientation(fac3)) += flux[k];
440
441 if (fac2 < n)
442 for (int k = 0; k < ncomp; k++) tab_flux_bords(fac2, orientation(fac4)) += flux[k];
443 }
444 }
445
446 flux_evaluateur.template flux_arete < Arete_Type > (inco, a_r, fac3, fac4, fac1, fac2, flux);
447 fill_resu_tab < Type_Double > (fac1, fac2, ncomp, flux, secmem);
448 if (is_MIXTE)
449 {
450 if (fac2 < n2)
451 {
452 if (fac3 < n)
453 for (int k = 0; k < ncomp; k++) tab_flux_bords(fac3, orientation(fac1)) -= flux[k];
454
455 if (fac4 < n)
456 for (int k = 0; k < ncomp; k++) tab_flux_bords(fac4, orientation(fac2)) -= flux[k];
457 }
458 if (fac1 < n2)
459 {
460 if (fac3 < n)
461 for (int k = 0; k < ncomp; k++) tab_flux_bords(fac3, orientation(fac1)) += flux[k];
462
463 if (fac4 < n)
464 for (int k = 0; k < ncomp; k++) tab_flux_bords(fac4, orientation(fac2)) += flux[k];
465 }
466 }
467 }
468
469 // derivees : champ convecte
470 Matrice_Morse *matrice = (is_pb_multi && is_conv_op_) ? (mats.count(nom_ch_inco_) && !semi_impl.count(nom_ch_inco_) ? mats.at(nom_ch_inco_) : nullptr) : (mats.count(nom_ch_inco_) ? mats.at(nom_ch_inco_) : nullptr);
471 if (matrice)
472 for (int n_arete = debut; n_arete < fin; n_arete++)
473 {
474 aii = 0., ajj = 0.;
475 const int fac1 = Qdm(n_arete, 0), fac2 = Qdm(n_arete, 1), fac3 = Qdm(n_arete, 2), fac4 = Qdm(n_arete, 3);
476
477 flux_evaluateur.template coeffs_arete < Arete_Type > (a_r, fac3, fac4, fac1, fac2, aii, ajj);
478 for (int i = 0; i < ncomp; i++)
479 fill_coeff_matrice_morse < Type_Double > (fac1, fac2, i, ncomp, aii, ajj, *matrice);
480
481 flux_evaluateur.template coeffs_arete < Arete_Type > (a_r, fac1, fac2, fac3, fac4, aii, ajj);
482 for (int i = 0; i < ncomp; i++)
483 fill_coeff_matrice_morse < Type_Double > (fac3, fac4, i, ncomp, aii, ajj, *matrice);
484 }
485 }
486}
487
488/* ============================= *
489 * ====== FA7 SORTIE LIBRE =====
490 * ============================= */
491template<class _TYPE_> template <typename Type_Double>
492void Iterateur_VDF_Face<_TYPE_>::ajouter_blocs_fa7_sortie_libre(const int ncomp, matrices_t mats, DoubleTab& secmem, const tabs_t& semi_impl) const
493{
494 for (int num_cl = 0; num_cl < le_dom->nb_front_Cl(); num_cl++)
495 {
496 const Cond_lim& la_cl = la_zcl->les_conditions_limites(num_cl);
497 switch(type_cl(la_cl))
498 {
499 case sortie_libre:
500 ajouter_blocs_fa7_sortie_libre_<_TYPE_::CALC_FA7_SORTIE_LIB, Type_Flux_Fa7::SORTIE_LIBRE, Type_Double>(num_cl, ncomp, mats, secmem, semi_impl);
501 break;
502 case navier: /* fall through */
503 case entree_fluide:
504 case paroi_fixe:
505 case paroi_defilante:
506 case paroi_adiabatique:
507 case paroi:
508 case echange_externe_impose:
509 case echange_global_impose:
510 case periodique:
511 break;
512 default:
513 Cerr << "On ne reconnait pas la condition limite : " << la_cl.valeur();
514 Process::exit();
515 }
516 }
517}
518
519template <class _TYPE_> template <bool should_calc_flux, Type_Flux_Fa7 Fa7_Type, typename Type_Double>
520void Iterateur_VDF_Face<_TYPE_>::ajouter_blocs_fa7_sortie_libre_(const int num_cl, const int ncomp , matrices_t mats, DoubleTab& secmem, const tabs_t& semi_impl) const
521{
522 // TODO : FIXME : tab_flux_bords pas rempli ...
523 if (should_calc_flux)
524 {
525 Type_Double flux(ncomp), aii(ncomp), ajj(ncomp);
526 const DoubleTab& inco = semi_impl.count(nom_ch_inco_) ? semi_impl.at(nom_ch_inco_) : le_champ_convecte_ou_inc->valeurs();
527 const Cond_lim& la_cl = la_zcl->les_conditions_limites(num_cl);
528 const Front_VF& frontiere_dis = ref_cast(Front_VF, la_cl->frontiere_dis());
529 const int ndeb = frontiere_dis.num_premiere_face(), nfin = ndeb + frontiere_dis.nb_faces();
530
531 const DoubleTab* a_r = (!is_pb_multi || !is_conv_op_) ? nullptr : semi_impl.count("alpha_rho") ? &semi_impl.at("alpha_rho") :
532 &ref_cast(Pb_Multiphase,op_base->equation().probleme()).equation_masse().champ_conserve().valeurs();
533
534 // second membre
535 for (int face = ndeb; face < nfin; face++)
536 {
537 flux_evaluateur.template flux_fa7 < Fa7_Type > (inco, a_r, face, (const Neumann_sortie_libre&) la_cl.valeur(), ndeb, flux);
538 if ((elem(face, 0)) > -1)
539 for (int k = 0; k < ncomp; k++) secmem(face, k) += flux[k];
540
541 if ((elem(face, 1)) > -1)
542 for (int k = 0; k < ncomp; k++) secmem(face, k) -= flux[k];
543 }
544
545 // derivees : champ convecte
546 Matrice_Morse *matrice = (is_pb_multi && is_conv_op_) ? (mats.count(nom_ch_inco_) && !semi_impl.count(nom_ch_inco_) ? mats.at(nom_ch_inco_) : nullptr) :
547 (mats.count(nom_ch_inco_) ? mats.at(nom_ch_inco_) : nullptr);
548 if (matrice)
549 for (int face = ndeb; face < nfin; face++)
550 {
551 flux_evaluateur.template coeffs_fa7 < Fa7_Type > (a_r, face, (const Neumann_sortie_libre&) la_cl.valeur(), aii, ajj);
552 if ((elem(face, 0)) > -1)
553 for (int i = 0; i < ncomp; i++) fill_coeff_matrice_morse < Type_Double > (face, i, ncomp, 1, aii, *matrice);
554
555 if ((elem(face, 1)) > -1)
556 for (int i = 0; i < ncomp; i++) fill_coeff_matrice_morse < Type_Double > (face, i, ncomp, 1, ajj, *matrice);
557 }
558 }
559}
560
561/* ===================== *
562 * ====== FA7 ELEM =====
563 * ===================== */
564template<class _TYPE_> template <typename Type_Double>
565void Iterateur_VDF_Face<_TYPE_>::ajouter_blocs_fa7_elem(const int ncomp, matrices_t mats, DoubleTab& secmem, const tabs_t& semi_impl) const
566{
567 DoubleTab& tab_flux_bords = op_base->flux_bords();
568 const DoubleTab& inco = semi_impl.count(nom_ch_inco_) ? semi_impl.at(nom_ch_inco_) : le_champ_convecte_ou_inc->valeurs();
569 Type_Double flux(ncomp), aii(ncomp), ajj(ncomp);
570 const int n_fc_bd = le_dom->nb_faces_bord();
571
572 const DoubleTab* a_r = (!is_pb_multi || !is_conv_op_) ? nullptr : semi_impl.count("alpha_rho") ? &semi_impl.at("alpha_rho") :
573 &ref_cast(Pb_Multiphase,op_base->equation().probleme()).equation_masse().champ_conserve().valeurs();
574// const IntTab& f_e = le_dom->face_voisins();
575 // second membre
576 for (int num_elem = 0; num_elem < nb_elem; num_elem++)
577 for (int fa7 = 0; fa7 < dimension; fa7++)
578 {
579 int fac1 = elem_faces(num_elem, fa7), fac2 = elem_faces(num_elem, fa7 + dimension);
580 flux_evaluateur.template flux_fa7 < Type_Flux_Fa7::ELEM > (inco, a_r, num_elem, fac1, fac2, flux);
581
582 fill_resu_tab < Type_Double > (fac1, fac2, ncomp, flux, secmem);
583
584 if (fac1 < n_fc_bd)
585 for (int k = 0; k < ncomp; k++) tab_flux_bords(fac1, orientation(fac1)) += flux[k];
586
587 if (fac2 < n_fc_bd)
588 for (int k = 0; k < ncomp; k++) tab_flux_bords(fac2, orientation(fac2)) -= flux[k];
589 }
590
591 // derivees : champ convecte
592 Matrice_Morse *matrice = (is_pb_multi && is_conv_op_) ? (mats.count(nom_ch_inco_) && !semi_impl.count(nom_ch_inco_) ? mats.at(nom_ch_inco_) : nullptr) :
593 (mats.count(nom_ch_inco_) ? mats.at(nom_ch_inco_) : nullptr);
594 if (matrice)
595 {
596 for (int num_elem = 0; num_elem < nb_elem; num_elem++)
597 for (int fa7 = 0; fa7 < dimension; fa7++)
598 {
599 const int fac1 = elem_faces(num_elem, fa7), fac2 = elem_faces(num_elem, fa7 + dimension);
600 flux_evaluateur.template coeffs_fa7 < Type_Flux_Fa7::ELEM > (a_r, num_elem, fac1, fac2, aii, ajj);
601 for (int i = 0; i < ncomp; i++)
602 fill_coeff_matrice_morse < Type_Double > (fac1, fac2, i, ncomp, aii, ajj, *matrice);
603 }
604 }
605
606 // On corrige si cl periodique ...
607 corriger_fa7_elem_periodicite<Type_Double>(ncomp, mats, secmem, semi_impl);
608}
609
610template<class _TYPE_> template<typename Type_Double>
611void Iterateur_VDF_Face<_TYPE_>::corriger_fa7_elem_periodicite(const int ncomp, matrices_t mats, DoubleTab& secmem, const tabs_t& semi_impl) const
612{
613 Type_Double flux(ncomp), aii(ncomp), ajj(ncomp);
614 const DoubleTab& inco = semi_impl.count(nom_ch_inco_) ? semi_impl.at(nom_ch_inco_) : le_champ_convecte_ou_inc->valeurs();
615 Matrice_Morse *matrice = (is_pb_multi && is_conv_op_) ? (mats.count(nom_ch_inco_) && !semi_impl.count(nom_ch_inco_) ? mats.at(nom_ch_inco_) : nullptr) : (mats.count(nom_ch_inco_) ? mats.at(nom_ch_inco_) : nullptr);
616
617 for (int num_cl = 0; num_cl < le_dom->nb_front_Cl(); num_cl++)
618 {
619 const Cond_lim& la_cl = la_zcl->les_conditions_limites(num_cl);
620 if (sub_type(Periodique, la_cl.valeur()))
621 {
622 const Periodique& la_cl_perio = ref_cast(Periodique, la_cl.valeur());
623 const Front_VF& le_bord = ref_cast(Front_VF, la_cl_perio.frontiere_dis());
624 int num_elem, signe, fac1, fac2, ndeb = le_bord.num_premiere_face(), nfin = ndeb + le_bord.nb_faces();
625
626 // second membre
627 for (int face = ndeb; face < nfin; face++)
628 {
629 flux = 0.;
630 corriger_fa7_elem_periodicite__(face, num_elem, signe, fac1, fac2);
631
632 flux_evaluateur.template flux_fa7 < Type_Flux_Fa7::ELEM > (inco, nullptr, num_elem, fac1, fac2, flux);
633 for (int k = 0; k < ncomp; k++) secmem(face, k) += signe * flux[k];
634 }
635
636 // derivees : champ convecte
637 if (matrice)
638 for (int face = ndeb; face < nfin; face++)
639 {
640 aii = 0., ajj = 0.;
641 corriger_fa7_elem_periodicite__(face, num_elem, signe, fac1, fac2);
642
643 flux_evaluateur.template coeffs_fa7 < Type_Flux_Fa7::ELEM > (nullptr, num_elem, fac1, fac2, aii, ajj);
644 const auto& tab1 = (*matrice).get_set_tab1();
645 const auto& tab2 = (*matrice).get_set_tab2();
646 auto& coeff = (*matrice).get_set_coeff();
647 if (signe > 0) /* on a oublie a droite la contribution de la gauche */
648 {
649 for (int i = 0; i < ncomp; i++)
650 for (auto k = tab1[face * ncomp + i] - 1; k < tab1[face * ncomp + 1 + i] - 1; k++)
651 if (tab2[k] - 1 == face * ncomp + i) coeff[k] += aii[i];
652
653 for (int i = 0; i < ncomp; i++)
654 for (auto k = tab1[face * ncomp + i] - 1; k < tab1[face * ncomp + 1 + i] - 1; k++)
655 if (tab2[k] - 1 == fac2 * ncomp + i) coeff[k] -= ajj[i];
656 }
657 else /* on a oublie a gauche la contribution de la droite */
658 {
659 for (int i = 0; i < ncomp; i++)
660 for (auto k = tab1[face * ncomp + i] - 1; k < tab1[face * ncomp + 1 + i] - 1; k++)
661 if (tab2[k] - 1 == fac1 * ncomp + i) coeff[k] -= aii[i];
662
663 for (int i = 0; i < ncomp; i++)
664 for (auto k = tab1[face * ncomp + i] - 1; k < tab1[face * ncomp + 1 + i] - 1; k++)
665 if (tab2[k] - 1 == face * ncomp + i) coeff[k] += ajj[i];
666 }
667 }
668 }
669 }
670}
671
672template<class _TYPE_>
673void Iterateur_VDF_Face<_TYPE_>::corriger_fa7_elem_periodicite__(const int face, int& num_elem, int& signe, int& fac1, int& fac2) const
674{
675 const int elem1 = elem(face, 0), elem2 = elem(face, 1), ori = orientation(face);
676 if ((face == elem_faces(elem1, ori)) || (face == elem_faces(elem1, ori + dimension)))
677 {
678 num_elem = elem2;
679 signe = 1;
680 }
681 else
682 {
683 num_elem = elem1;
684 signe = -1;
685 }
686 fac1 = elem_faces(num_elem, ori), fac2 = elem_faces(num_elem, ori + dimension);
687}
688
689/* ========================= *
690 * ====== Compressible =====
691 * ========================= */
692
693template<class _TYPE_> template<typename Type_Double>
694void Iterateur_VDF_Face<_TYPE_>::ajouter_pour_compressible(const int ncomp, matrices_t mats, DoubleTab& secmem, const tabs_t& semi_impl) const
695{
696 // on a secmem calcule comme : div(alpha rho v x v)
697 const DoubleTab& vit = le_champ_convecte_ou_inc->valeurs();
698
699 // etape 1 : calcule de la terme div(alpha rho v)
700 DoubleTrav unite(secmem), resu(secmem);
701 unite = 1.;
702 resu = 0.;
703
704 tabs_t tabsT = {{le_champ_convecte_ou_inc->le_nom().getString(), unite}};
705
706 if (semi_impl.count("alpha_rho") ) tabsT.insert({"alpha_rho", semi_impl.at("alpha_rho")});
707
708 ajouter_blocs_aretes_bords<Type_Double>(ncomp, mats, resu, tabsT);
709 ajouter_blocs_aretes_coins<Type_Double>(ncomp, mats, resu, tabsT);
710 ajouter_blocs_aretes_internes<Type_Double>(ncomp, mats, resu, tabsT);
711 ajouter_blocs_aretes_mixtes<Type_Double>(ncomp, mats, resu, tabsT);
712 ajouter_blocs_fa7_sortie_libre<Type_Double>(ncomp, mats, resu, tabsT);
713 ajouter_blocs_fa7_elem<Type_Double>(ncomp, mats, resu, tabsT);
714
715 // etape 2 : on multiplie par v pour avoir : v . div(alpha rho v)
716 resu *= vit;
717
718 // etape 3 : finalement, alpha rho v grad v = div(alpha rho v x v) - v . div(alpha rho v)
719 secmem -= resu;
720}
721
722// ===================================================================================================
723
724template<class _TYPE_> template<typename Type_Double>
725inline void Iterateur_VDF_Face<_TYPE_>::fill_resu_tab(const int fac1, const int fac2, const int ncomp, const Type_Double& flux, DoubleTab& resu) const
726{
727 for (int k = 0; k < ncomp; k++)
728 {
729 resu(fac1, k) += flux[k];
730 resu(fac2, k) -= flux[k];
731 }
732}
733
734template<class _TYPE_> template<typename Type_Double>
735void Iterateur_VDF_Face<_TYPE_>::fill_coeff_matrice_morse(const int face, const int i, const int ncomp, const int signe, const Type_Double& A, Matrice_Morse& matrice) const
736{
737 const auto& tab1 = matrice.get_set_tab1();
738 const auto& tab2 = matrice.get_set_tab2();
739 auto& coeff = matrice.get_set_coeff();
740 for (auto k = tab1[face * ncomp + i] - 1; k < tab1[face * ncomp + 1 + i] - 1; k++)
741 if (tab2[k] - 1 == face * ncomp + i) coeff[k] += signe * A[i]; // equivalent a matrice(face,face) += signe*A(i)
742}
743
744template<class _TYPE_> template<typename Type_Double>
745void Iterateur_VDF_Face<_TYPE_>::fill_coeff_matrice_morse(const int fac1, const int fac2, const int i, const int ncomp, const Type_Double& A, const Type_Double& B, Matrice_Morse& matrice) const
746{
747 const auto& tab1 = matrice.get_set_tab1();
748 const auto& tab2 = matrice.get_set_tab2();
749 auto& coeff = matrice.get_set_coeff();
750 for (auto k = tab1[fac1 * ncomp + i] - 1; k < tab1[fac1 * ncomp + 1 + i] - 1; k++)
751 {
752 if (tab2[k] - 1 == fac1 * ncomp + i) coeff[k] += A[i]; // equivalent a matrice(fac1,fac1) += A(i)
753 if (tab2[k] - 1 == fac2 * ncomp + i) coeff[k] -= B[i]; // equivalent a matrice(fac1,fac2) -= B(i)
754 }
755 for (auto k = tab1[fac2 * ncomp + i] - 1; k < tab1[fac2 * ncomp + 1 + i] - 1; k++)
756 {
757 if (tab2[k] - 1 == fac1 * ncomp + i) coeff[k] -= A[i]; // equivalent a matrice(fac2,fac1) -= A(i)
758 if (tab2[k] - 1 == fac2 * ncomp + i) coeff[k] += B[i]; // equivalent a matrice(fac2,fac2) += B(i)
759 }
760}
761
762#include <Iterateur_VDF_Face_bis.tpp>
763
764#endif /* Iterateur_VDF_Face_TPP_included */
Cond_lim_base::frontiere_dis
virtual Frontiere_dis_base & frontiere_dis()
Renvoie la frontiere discretisee a laquelle les conditions aux limites s'appliquent.
Definition Cond_lim_base.h:101
Cond_lim
classe Cond_lim Classe generique servant a representer n'importe quelle classe
Definition Cond_lim.h:31
Front_VF
class Front_VF
Definition Front_VF.h:36
Front_VF::nb_faces
int nb_faces() const
Definition Front_VF.h:53
Front_VF::num_premiere_face
int num_premiere_face() const
Definition Front_VF.h:63
Iterateur_VDF_Face::ajouter_blocs
void ajouter_blocs(matrices_t mats, DoubleTab &secmem, const tabs_t &semi_impl) const override
Definition Iterateur_VDF_Face.tpp:26
Iterateur_VDF_Face::flux_evaluateur
_TYPE_ flux_evaluateur
Definition Iterateur_VDF_Face.h:49
Iterateur_VDF_base::is_conv_op_
bool is_conv_op_
Definition Iterateur_VDF_base.h:129
Iterateur_VDF_base::is_pb_multi
bool is_pb_multi
Definition Iterateur_VDF_base.h:129
Iterateur_VDF_base::incompressible_
int incompressible_
Definition Iterateur_VDF_base.h:130
Matrice_Morse
Classe Matrice_Morse Represente une matrice M (creuse), non necessairement carree.
Definition Matrice_Morse.h:50
Matrice_Morse::get_set_tab2
auto & get_set_tab2()
Definition Matrice_Morse.h:103
Matrice_Morse::get_set_coeff
auto & get_set_coeff()
Definition Matrice_Morse.h:108
Matrice_Morse::get_set_tab1
auto & get_set_tab1()
Definition Matrice_Morse.h:98
Neumann_sortie_libre
classe Neumann_sortie_libre Cette classe represente une frontiere ouverte sans vitesse imposee
Definition Neumann_sortie_libre.h:34
Objet_U::dimension
static int dimension
Definition Objet_U.h:99
Option_VDF::DEACTIVATE_ARETE_MIXTE
static bool DEACTIVATE_ARETE_MIXTE
Definition Option_VDF.h:32
Pb_Multiphase
classe Pb_Multiphase Cette classe represente un probleme de thermohydraulique multiphase de type "3*N...
Definition Pb_Multiphase.h:46
Periodique
classe Periodique Cette classe represente une condition aux limites periodique.
Definition Periodique.h:31
Process::exit
static void exit(int exit_code=-1)
Routine de sortie de TRUST dans une region Kokkos.
Definition Process.cpp:455
TRUSTTab::resize
void resize(_SIZE_ n, RESIZE_OPTIONS opt=RESIZE_OPTIONS::COPY_INIT)
Definition TRUSTTab.tpp:469