TrioCFD 1.9.8
TrioCFD documentation
Loading...
Searching...
No Matches
Source_Transport_Flux_Chaleur_Turbulente_VDF_Face.cpp
1/****************************************************************************
2* Copyright (c) 2019, 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
17#include <Source_Transport_Flux_Chaleur_Turbulente_VDF_Face.h>
18#include <Modele_turbulence_scal_Fluctuation_Temperature.h>
19#include <Modele_turbulence_hyd_K_Eps_Bas_Reynolds.h>
20#include <Convection_Diffusion_Temperature.h>
21#include <Fluide_base.h>
22#include <Probleme_base.h>
23#include <TRUSTTrav.h>
24#include <Champ_Uniforme.h>
25#include <Domaine_VDF.h>
26#include <Domaine_Cl_VDF.h>
27#include <TRUSTTrav.h>
28
29Implemente_instanciable_sans_constructeur(Source_Transport_Flux_Chaleur_Turbulente_VDF_Face,"Source_Transport_Flux_Chaleur_Turbulente_VDF_Face",Source_base);
30
31//// printOn
32//
33
34Sortie& Source_Transport_Flux_Chaleur_Turbulente_VDF_Face::printOn(Sortie& s ) const
35{
36 return s << que_suis_je() ;
37}
38
39
40//// readOn
41//
42
43Entree& Source_Transport_Flux_Chaleur_Turbulente_VDF_Face::readOn(Entree& is )
44{
45 Motcle accolade_ouverte("{");
46 Motcle accolade_fermee("}");
47 Motcle motlu;
48
49 is >> motlu;
50 if (motlu != accolade_ouverte)
51 {
52 Cerr << "On attendait { pour commencer a lire les constantes de Source_Transport_Flux_Chaleur_Turbulente" << finl;
53 Process::exit();
54 }
55 Cerr << "Lecture des constantes de Source_Transport_Flux_Chaleur_Turbulente" << finl;
56 Motcles les_mots(3);
57 {
58 les_mots[0] = "C1_teta";
59 les_mots[1] = "C2_teta";
60 les_mots[2] = "C3_teta";
61 }
62 is >> motlu;
63 while (motlu != accolade_fermee)
64 {
65 int rang=les_mots.search(motlu);
66 switch(rang)
67 {
68 case 0 :
69 {
70 is >> C1;
71 break;
72 }
73 case 1 :
74 {
75 is >> C2;
76 break;
77 }
78 case 2 :
79 {
80 is >> C3;
81 break;
82 }
83 default :
84 {
85 Cerr << "On ne comprend pas le mot cle : " << motlu << "dans Source_Transport_Flux_Chaleur_Turbulente" << finl;
86 Process::exit();
87 }
88 }
89
90 is >> motlu;
91 }
92
93 return is ;
94}
95
96void Source_Transport_Flux_Chaleur_Turbulente_VDF_Face::associer_pb(const Probleme_base& pb )
97{
98 eq_hydraulique = pb.equation(0);
99 mon_eq_transport_Flux_Chaleur_Turb_ = ref_cast(Transport_Flux_Chaleur_Turbulente,equation());
100 const Convection_Diffusion_Temperature& eqn_th =
101 ref_cast(Convection_Diffusion_Temperature,pb.equation(1));
102 eq_thermique = eqn_th;
103 const Fluide_base& fluide = eq_thermique->fluide();
104 beta_t = fluide.beta_t();
105 gravite_ = fluide.gravite();
106}
107
108void Source_Transport_Flux_Chaleur_Turbulente_VDF_Face::associer_domaines(const Domaine_dis_base& domaine_dis,
109 const Domaine_Cl_dis_base& domaine_Cl_dis)
110{
111 le_dom_VDF = ref_cast(Domaine_VDF, domaine_dis);
112 le_dom_Cl_VDF = ref_cast(Domaine_Cl_VDF, domaine_Cl_dis);
113}
114
115////////////////////////////////////////////////////////////
116//
117// Methode pour determiner la production par le gradient
118// moyen de la temperature
119////////////////////////////////////////////////////////////
120
121DoubleTab& Source_Transport_Flux_Chaleur_Turbulente_VDF_Face::calculer_uiuj(const Domaine_VDF& domaine_VDF, const DoubleTab& vit, const DoubleTab& visco_turb, DoubleTab& uiuj) const
122{
123 uiuj= 0;
124
125 // Calcul des du/dy+dv/dx ...et des gradients par elements
126
127 // const Domaine& le_dom=domaine_VDF.domaine();
128 // int nb_faces_elem = le_dom.nb_faces_elem();
129 int nb_elem = domaine_VDF.nb_elem();
130 int nb_elem_tot = domaine_VDF.nb_elem_tot();
131 int n_deb = domaine_VDF.premiere_arete_interne();
132 int n_fin = domaine_VDF.nb_aretes_internes() + n_deb;
133 // const IntTab& elem_faces = domaine_VDF.elem_faces();
134 const IntTab& face_voisins = domaine_VDF.face_voisins();
135 const IntTab& Qdm = domaine_VDF.Qdm();
136 const IntVect& orientation = domaine_VDF.orientation();
137 IntTrav num(4);
138 double sum,visco_moy,rac_visc;
139 int i, num_elem, n_arete;
140 // int premiere_face_int = domaine_VDF.premiere_face_int();
141
142 DoubleTrav du_dy(nb_elem_tot);
143 DoubleTrav du_dz(nb_elem_tot);
144 DoubleTrav dv_dx(nb_elem_tot);
145 DoubleTrav dv_dz(nb_elem_tot);
146 DoubleTrav dw_dx(nb_elem_tot);
147 DoubleTrav dw_dy(nb_elem_tot);
148
149 if (Objet_U::dimension == 2)
150 {
151
152 DoubleVect coef(2);
153
154 // Boucle sur les aretes internes pour le calcul
155 // des moyennes des derivees croisees
156
157 for (n_arete =n_deb; n_arete<n_fin; n_arete++)
158 {
159
160 for (i=0; i<4; i++)
161 num[i] = Qdm(n_arete,i);
162 visco_moy=0;
163 if (visco_turb(face_voisins(num[0],0))>1.e-10 &&
164 visco_turb(face_voisins(num[0],1))>1.e-10 &&
165 visco_turb(face_voisins(num[1],0))>1.e-10 &&
166 visco_turb(face_voisins(num[1],1))>1.e-10)
167 visco_moy = 0.25 * (visco_turb(face_voisins(num[0],0))
168 + visco_turb(face_voisins(num[0],1))
169 + visco_turb(face_voisins(num[1],0))
170 + visco_turb(face_voisins(num[1],1)));
171 rac_visc=sqrt(visco_moy);
172 coef[0] = rac_visc * (vit(num[1])-vit(num[0]))/domaine_VDF.dist_face(num[0],num[1],0);
173 coef[1] = rac_visc * (vit(num[3])-vit(num[2]))/domaine_VDF.dist_face(num[2],num[3],1);
174 dv_dx(face_voisins(num[0],0)) += coef[0];
175 dv_dx(face_voisins(num[0],1)) += coef[0];
176 dv_dx(face_voisins(num[1],0)) += coef[0];
177 dv_dx(face_voisins(num[1],1)) += coef[0];
178 du_dy(face_voisins(num[2],0)) += coef[1];
179 du_dy(face_voisins(num[2],1)) += coef[1];
180 du_dy(face_voisins(num[3],0)) += coef[1];
181 du_dy(face_voisins(num[3],1)) += coef[1];
182 }
183
184 // Boucle sur les elements
185
186 for (num_elem=0; num_elem<nb_elem; num_elem++)
187 {
188
189 sum = 0.25*(du_dy(num_elem)+dv_dx(num_elem));
190 uiuj(num_elem) += sum;
191 }
192 }
193
194 else if (Objet_U::dimension == 3)
195 {
196
197 DoubleVect coef(3);
198
199 // Boucle sur les aretes internes pour le calcul
200 // des moyennes des derivees croisees
201
202 for (n_arete =n_deb; n_arete<n_fin; n_arete++)
203 {
204
205 for (i=0; i<4; i++)
206 num[i] = Qdm(n_arete,i);
207 visco_moy=0;
208 if (visco_turb(face_voisins(num[0],0))>1.e-10 &&
209 visco_turb(face_voisins(num[0],1))>1.e-10 &&
210 visco_turb(face_voisins(num[1],0))>1.e-10 &&
211 visco_turb(face_voisins(num[1],1))>1.e-10)
212 visco_moy = 0.25 * (visco_turb(face_voisins(num[0],0))
213 + visco_turb(face_voisins(num[0],1))
214 + visco_turb(face_voisins(num[1],0))
215 + visco_turb(face_voisins(num[1],1)));
216 rac_visc=sqrt(visco_moy);
217 if (orientation(num[0]) == 2)
218 {
219
220 if (orientation(num[2]) == 0)
221 {
222 coef[0] = rac_visc * (vit(num[1])-vit(num[0]))/domaine_VDF.dist_face(num[0],num[1],0);
223 coef[1] = rac_visc * (vit(num[3])-vit(num[2]))/domaine_VDF.dist_face(num[2],num[3],2);
224 dw_dx(face_voisins(num[0],0)) += coef[0];
225 dw_dx(face_voisins(num[0],1)) += coef[0];
226 dw_dx(face_voisins(num[1],0)) += coef[0];
227 dw_dx(face_voisins(num[1],1)) += coef[0];
228 du_dz(face_voisins(num[2],0)) += coef[1];
229 du_dz(face_voisins(num[2],1)) += coef[1];
230 du_dz(face_voisins(num[3],0)) += coef[1];
231 du_dz(face_voisins(num[3],1)) += coef[1];
232 }
233 else if (orientation(num[2]) == 1)
234 {
235 coef[0] = rac_visc * (vit(num[1])-vit(num[0]))/domaine_VDF.dist_face(num[0],num[1],1);
236 coef[1] = rac_visc * (vit(num[3])-vit(num[2]))/domaine_VDF.dist_face(num[2],num[3],2);
237 dw_dy(face_voisins(num[0],0)) += coef[0];
238 dw_dy(face_voisins(num[0],1)) += coef[0];
239 dw_dy(face_voisins(num[1],0)) += coef[0];
240 dw_dy(face_voisins(num[1],1)) += coef[0];
241 dv_dz(face_voisins(num[2],0)) += coef[1];
242 dv_dz(face_voisins(num[2],1)) += coef[1];
243 dv_dz(face_voisins(num[3],0)) += coef[1];
244 dv_dz(face_voisins(num[3],1)) += coef[1];
245 }
246 }
247
248 else if (orientation(num[0]) == 1)
249 {
250 coef[0] = rac_visc * (vit(num[1])-vit(num[0]))/domaine_VDF.dist_face(num[0],num[1],0);
251 coef[1] = rac_visc * (vit(num[3])-vit(num[2]))/domaine_VDF.dist_face(num[2],num[3],1);
252 dv_dx(face_voisins(num[0],0)) += coef[0];
253 dv_dx(face_voisins(num[0],1)) += coef[0];
254 dv_dx(face_voisins(num[1],0)) += coef[0];
255 dv_dx(face_voisins(num[1],1)) += coef[0];
256 du_dy(face_voisins(num[2],0)) += coef[1];
257 du_dy(face_voisins(num[2],1)) += coef[1];
258 du_dy(face_voisins(num[3],0)) += coef[1];
259 du_dy(face_voisins(num[3],1)) += coef[1];
260 }
261
262 }
263
264 // Boucle sur les elements
265
266 for (int num_elemb=0; num_elemb<nb_elem; num_elemb++)
267 {
268
269 coef[0] = 0.25*(du_dy(num_elemb)+dv_dx(num_elemb));
270 coef[1] = 0.25*(du_dz(num_elemb)+dw_dx(num_elemb));
271 coef[2] = 0.25*(dw_dy(num_elemb)+dv_dz(num_elemb));
272
273 sum = coef[0]*coef[0] + coef[1]*coef[1] + coef[2]*coef[2];
274 uiuj(num_elemb) += sum;
275 }
276 }
277 return uiuj;
278}
279
280DoubleTab& Source_Transport_Flux_Chaleur_Turbulente_VDF_Face::calculer_Grad_U(const Domaine_VDF& domaine_VDF, const DoubleTab& vit, const DoubleTab& visco_turb, DoubleTab& Grad_U) const
281{
282 Grad_U= 0;
283
284 // Calcul des du/dy+dv/dx ...et des gradients par elements
285
286 // const Domaine& le_dom=domaine_VDF.domaine();
287 // int nb_faces_elem = le_dom.nb_faces_elem();
288 int nb_elem = domaine_VDF.nb_elem();
289 int nb_elem_tot = domaine_VDF.nb_elem_tot();
290 int n_deb = domaine_VDF.premiere_arete_interne();
291 int n_fin = domaine_VDF.nb_aretes_internes() + n_deb;
292 // const IntTab& elem_faces = domaine_VDF.elem_faces();
293 const IntTab& face_voisins = domaine_VDF.face_voisins();
294 const IntTab& Qdm = domaine_VDF.Qdm();
295 const IntVect& orientation = domaine_VDF.orientation();
296 IntTrav num(4);
297 double visco_moy,rac_visc;
298 int i, num_elem, n_arete;
299 // int premiere_face_int = domaine_VDF.premiere_face_int();
300
301 DoubleTrav du_dy(nb_elem_tot);
302 DoubleTrav du_dz(nb_elem_tot);
303 DoubleTrav dv_dx(nb_elem_tot);
304 DoubleTrav dv_dz(nb_elem_tot);
305 DoubleTrav dw_dx(nb_elem_tot);
306 DoubleTrav dw_dy(nb_elem_tot);
307
308 if (Objet_U::dimension == 2)
309 {
310
311 DoubleVect coef(2);
312
313 // Boucle sur les aretes internes pour le calcul
314 // des moyennes des derivees croisees
315
316 for (n_arete =n_deb; n_arete<n_fin; n_arete++)
317 {
318
319 for (i=0; i<4; i++)
320 num[i] = Qdm(n_arete,i);
321 visco_moy=0;
322 if (visco_turb(face_voisins(num[0],0))>1.e-10 &&
323 visco_turb(face_voisins(num[0],1))>1.e-10 &&
324 visco_turb(face_voisins(num[1],0))>1.e-10 &&
325 visco_turb(face_voisins(num[1],1))>1.e-10)
326 visco_moy = 0.25 * (visco_turb(face_voisins(num[0],0))
327 + visco_turb(face_voisins(num[0],1))
328 + visco_turb(face_voisins(num[1],0))
329 + visco_turb(face_voisins(num[1],1)));
330 rac_visc=sqrt(visco_moy);
331 coef[0] = rac_visc * (vit(num[1])-vit(num[0]))/domaine_VDF.dist_face(num[0],num[1],0);
332 coef[1] = rac_visc * (vit(num[3])-vit(num[2]))/domaine_VDF.dist_face(num[2],num[3],1);
333 dv_dx(face_voisins(num[0],0)) += coef[0];
334 dv_dx(face_voisins(num[0],1)) += coef[0];
335 dv_dx(face_voisins(num[1],0)) += coef[0];
336 dv_dx(face_voisins(num[1],1)) += coef[0];
337 du_dy(face_voisins(num[2],0)) += coef[1];
338 du_dy(face_voisins(num[2],1)) += coef[1];
339 du_dy(face_voisins(num[3],0)) += coef[1];
340 du_dy(face_voisins(num[3],1)) += coef[1];
341 }
342
343 // Boucle sur les elements
344
345 for (num_elem=0; num_elem<nb_elem; num_elem++)
346 {
347 Grad_U(num_elem,0,1)= du_dy(num_elem);
348 Grad_U(num_elem,1,0)= dv_dx(num_elem);
349 }
350 }
351
352 else if (Objet_U::dimension == 3)
353 {
354
355 // DoubleTrav du_dy(nb_elem_tot);
356 // DoubleTrav du_dz(nb_elem_tot);
357 // DoubleTrav dv_dx(nb_elem_tot);
358 // DoubleTrav dv_dz(nb_elem_tot);
359 // DoubleTrav dw_dx(nb_elem_tot);
360 // DoubleTrav dw_dy(nb_elem_tot);
361 DoubleVect coef(3);
362
363 // Boucle sur les aretes internes pour le calcul
364 // des moyennes des derivees croisees
365
366 for (n_arete =n_deb; n_arete<n_fin; n_arete++)
367 {
368
369 for (i=0; i<4; i++)
370 num[i] = Qdm(n_arete,i);
371 visco_moy=0;
372 if (visco_turb(face_voisins(num[0],0))>1.e-10 &&
373 visco_turb(face_voisins(num[0],1))>1.e-10 &&
374 visco_turb(face_voisins(num[1],0))>1.e-10 &&
375 visco_turb(face_voisins(num[1],1))>1.e-10)
376 visco_moy = 0.25 * (visco_turb(face_voisins(num[0],0))
377 + visco_turb(face_voisins(num[0],1))
378 + visco_turb(face_voisins(num[1],0))
379 + visco_turb(face_voisins(num[1],1)));
380 rac_visc=sqrt(visco_moy);
381 if (orientation(num[0]) == 2)
382 {
383
384 if (orientation(num[2]) == 0)
385 {
386 coef[0] = rac_visc * (vit(num[1])-vit(num[0]))/domaine_VDF.dist_face(num[0],num[1],0);
387 coef[1] = rac_visc * (vit(num[3])-vit(num[2]))/domaine_VDF.dist_face(num[2],num[3],2);
388 dw_dx(face_voisins(num[0],0)) += coef[0];
389 dw_dx(face_voisins(num[0],1)) += coef[0];
390 dw_dx(face_voisins(num[1],0)) += coef[0];
391 dw_dx(face_voisins(num[1],1)) += coef[0];
392 du_dz(face_voisins(num[2],0)) += coef[1];
393 du_dz(face_voisins(num[2],1)) += coef[1];
394 du_dz(face_voisins(num[3],0)) += coef[1];
395 du_dz(face_voisins(num[3],1)) += coef[1];
396 }
397 else if (orientation(num[2]) == 1)
398 {
399 coef[0] = rac_visc * (vit(num[1])-vit(num[0]))/domaine_VDF.dist_face(num[0],num[1],1);
400 coef[1] = rac_visc * (vit(num[3])-vit(num[2]))/domaine_VDF.dist_face(num[2],num[3],2);
401 dw_dy(face_voisins(num[0],0)) += coef[0];
402 dw_dy(face_voisins(num[0],1)) += coef[0];
403 dw_dy(face_voisins(num[1],0)) += coef[0];
404 dw_dy(face_voisins(num[1],1)) += coef[0];
405 dv_dz(face_voisins(num[2],0)) += coef[1];
406 dv_dz(face_voisins(num[2],1)) += coef[1];
407 dv_dz(face_voisins(num[3],0)) += coef[1];
408 dv_dz(face_voisins(num[3],1)) += coef[1];
409 }
410 }
411
412 else if (orientation(num[0]) == 1)
413 {
414 coef[0] = rac_visc * (vit(num[1])-vit(num[0]))/domaine_VDF.dist_face(num[0],num[1],0);
415 coef[1] = rac_visc * (vit(num[3])-vit(num[2]))/domaine_VDF.dist_face(num[2],num[3],1);
416 dv_dx(face_voisins(num[0],0)) += coef[0];
417 dv_dx(face_voisins(num[0],1)) += coef[0];
418 dv_dx(face_voisins(num[1],0)) += coef[0];
419 dv_dx(face_voisins(num[1],1)) += coef[0];
420 du_dy(face_voisins(num[2],0)) += coef[1];
421 du_dy(face_voisins(num[2],1)) += coef[1];
422 du_dy(face_voisins(num[3],0)) += coef[1];
423 du_dy(face_voisins(num[3],1)) += coef[1];
424 }
425
426 }
427
428 // Boucle sur les elements
429
430 for (int num_elemb=0; num_elemb<nb_elem; num_elemb++)
431 {
432 Grad_U(num_elemb,0,1)= du_dy(num_elemb);
433 Grad_U(num_elemb,1,0)= dv_dx(num_elemb);
434 Grad_U(num_elemb,0,2)= du_dz(num_elemb);
435 Grad_U(num_elemb,1,2)= dv_dz(num_elemb);
436 }
437 }
438 return Grad_U;
439}
440
441
442
443DoubleTab& Source_Transport_Flux_Chaleur_Turbulente_VDF_Face::calculer_gteta2(const Domaine_VDF& domaine_VDF, DoubleTab& gteta2 ,const DoubleTab& fluctu_temp, double beta,const DoubleVect& gravite) const
444{
445 //
446 // gteta2 est discretise au centre des elements
447 //
448
449 int nb_elem = domaine_VDF.nb_elem();
450 //int nb_faces= domaine_VDF.nb_faces();
451 //DoubleTrav u_teta(nb_faces);
452 // const DoubleVect& porosite_face = domaine_VDF.porosite_face();
453 gteta2 = 0;
454
455 // -------> -------->
456 // Calcul de beta.gravite . tetacarre
457
458 //const Domaine& le_dom=domaine_VDF.domaine();
459 //int nb_faces_elem = le_dom.nb_faces_elem();
460
461 //IntTrav numfa(nb_faces_elem);
462 //DoubleVect coef(dimension);
463 // const IntTab& les_elem_faces = domaine_VDF.elem_faces();
464
465 for (int elem=0; elem<nb_elem; elem++)
466 for (int dim=0; dim<dimension; dim++)
467 gteta2(elem,dim) = beta*gravite(dim)*fluctu_temp(elem,0) ;
468 return gteta2;
469}
470DoubleTab& Source_Transport_Flux_Chaleur_Turbulente_VDF_Face::calculer_gteta2(const Domaine_VDF& domaine_VDF,DoubleTab& gteta2 ,const DoubleTab& fluctu_temp,const DoubleTab& beta,const DoubleVect& gravite) const
471{
472 //
473 // gteta2 est discretise au centre des elements
474 //
475
476 int nb_elem = domaine_VDF.nb_elem();
477 //int nb_faces= domaine_VDF.nb_faces();
478 //DoubleTrav u_teta(nb_faces);
479 // const DoubleVect& porosite_face = domaine_VDF.porosite_face();
480 gteta2 = 0;
481
482 // -------> -------->
483 // Calcul de beta.gravite . tetacarre
484
485 //const Domaine& le_dom=domaine_VDF.domaine();
486 //int nb_faces_elem = le_dom.nb_faces_elem();
487
488 //IntTrav numfa(nb_faces_elem);
489 //DoubleVect coef(dimension);
490 // const IntTab& les_elem_faces = domaine_VDF.elem_faces();
491
492 for (int elem=0; elem<nb_elem; elem++)
493 for (int dim=0; dim<dimension; dim++)
494 gteta2(elem,dim) = beta(elem)*gravite(dim)*fluctu_temp(elem,0) ;
495 return gteta2;
496}
497
498
499DoubleTab& Source_Transport_Flux_Chaleur_Turbulente_VDF_Face::ajouter(DoubleTab& resu) const
500{
501 const Domaine_VDF& domaine_VDF = le_dom_VDF.valeur();
502 const Domaine_Cl_VDF& domaine_Cl_VDF = le_dom_Cl_VDF.valeur();
503 const IntTab& face_voisins = domaine_VDF.face_voisins();
504 const IntVect& orientation = domaine_VDF.orientation();
505 const DoubleTab& temper = eq_thermique->inconnue().valeurs();
506 const DoubleTab& vit = eq_hydraulique->inconnue().valeurs();
507 const RefObjU& modele_turbulence_hydr = eq_hydraulique->get_modele(TURBULENCE);
508 const Modele_turbulence_hyd_base& mon_modele = ref_cast(Modele_turbulence_hyd_base,modele_turbulence_hydr.valeur());
509 const DoubleTab& visco_turb = mon_modele.viscosite_turbulente().valeurs();
510 const Modele_turbulence_hyd_K_Eps_Bas_Reynolds& modele_bas_Re = ref_cast(Modele_turbulence_hyd_K_Eps_Bas_Reynolds,mon_modele);
511 const Transport_K_Eps_base& mon_eq_transport_K_Eps_Bas_Re = modele_bas_Re.get_eq_transport();
512 const DoubleTab& K_Eps_Bas_Re = mon_eq_transport_K_Eps_Bas_Re.inconnue().valeurs();
513 const Modele_turbulence_scal_base& le_modele_scalaire = ref_cast(Modele_turbulence_scal_base,eq_thermique->get_modele(TURBULENCE).valeur());
514 const Modele_turbulence_scal_Fluctuation_Temperature& modele_Fluctu_Temp = ref_cast(Modele_turbulence_scal_Fluctuation_Temperature,le_modele_scalaire);
515 const Transport_Fluctuation_Temperature& mon_eq_transport_Fluctu_Temp = modele_Fluctu_Temp.equation_Fluctu();
516 const DoubleTab& Fluctu_Temperature = mon_eq_transport_Fluctu_Temp.inconnue().valeurs();
517 const DoubleTab& Flux_Chaleur_Turb = mon_eq_transport_Flux_Chaleur_Turb_->inconnue().valeurs();
518 const DoubleVect& g = eq_thermique->fluide().gravite().valeurs();
519 const Champ_Don_base& ch_beta = beta_t.valeur();
520 const DoubleTab& tab_beta = ch_beta.valeurs();
521 const DoubleVect& volumes = domaine_VDF.volumes();
522 int nb_elem = domaine_VDF.nb_elem();
523 const DoubleVect& porosite_surf = equation().milieu().porosite_face();
524 const DoubleVect& volumes_entrelaces = domaine_VDF.volumes_entrelaces();
525 int ori,ori1,num_face,elem1,elem2;
526 double vol;
527 int nb_faces = domaine_VDF.nb_faces();
528 DoubleTab Grad_U(nb_elem,dimension,dimension);
529 DoubleTab gteta2(nb_elem,dimension);
530 DoubleTab uiuj(nb_elem);
531
532 if (sub_type(Champ_Uniforme,ch_beta))
533 calculer_gteta2(domaine_VDF,gteta2 ,Fluctu_Temperature,tab_beta(0,0),g);
534 else
535 calculer_gteta2(domaine_VDF, gteta2 ,Fluctu_Temperature,tab_beta,g);
536
537 calculer_uiuj(domaine_VDF,vit,visco_turb,uiuj);
538 calculer_Grad_U(domaine_VDF,vit,visco_turb,Grad_U);
539 for (int n_bord=0; n_bord<domaine_VDF.nb_front_Cl(); n_bord++)
540 {
541 const Cond_lim& la_cl = domaine_Cl_VDF.les_conditions_limites(n_bord);
542
543 const Front_VF& le_bord = ref_cast(Front_VF,la_cl->frontiere_dis());
544 int ndeb = le_bord.num_premiere_face();
545 int nfin = ndeb + le_bord.nb_faces();
546 for (num_face=ndeb; num_face<nfin; num_face++)
547 {
548
549 vol = volumes_entrelaces(num_face)*porosite_surf(num_face);
550 ori = orientation(num_face);
551 ori1 = orientation(num_face+(1+dimension)%dimension);
552 elem1 = face_voisins(num_face,0);
553 if (elem1 != -1)
554 {
555 double contrib = (-1*temper(elem1))/domaine_VDF.dist_norm_bord(num_face)*uiuj(elem1)
556 -(1-C2)*Flux_Chaleur_Turb(num_face)*Grad_U(elem1,ori,ori1)
557 -(1-C3)*gteta2(elem1,ori);
558 if (K_Eps_Bas_Re(elem1,0)>1.e-10)
559 contrib+=-C1*Flux_Chaleur_Turb(num_face)*K_Eps_Bas_Re(elem1,1)/(K_Eps_Bas_Re(elem1,0));
560 resu(num_face)+=contrib*vol;
561 }
562 else
563 {
564 elem2 = face_voisins(num_face,1);
565 double contrib = (-1*temper(elem2))/domaine_VDF.dist_norm_bord(num_face)*uiuj(elem2)
566 -(1-C2)*Flux_Chaleur_Turb(num_face)*Grad_U(elem2,ori,ori1)
567 -(1-C3)*gteta2(elem2,ori);
568 if (K_Eps_Bas_Re(elem2,0)>1.e-10)
569 contrib+=-C1*Flux_Chaleur_Turb(num_face)*K_Eps_Bas_Re(elem2,1)/(K_Eps_Bas_Re(elem2,0));
570 resu(num_face)+=contrib*vol;
571 }
572 }
573 }
574
575 // Traitement des faces internes
576 for (num_face=domaine_VDF.premiere_face_int(); num_face<nb_faces; num_face++)
577 {
578
579 // vol et ori1 faux dans la ancienne version dans la suite
580 // on initialise et on fait planter
581 // vol=-1;ori1=-1;
582 vol = volumes_entrelaces(num_face)*porosite_surf(num_face);
583 // Que vaut ori1 reellement en 3D ????
584 ori1 = orientation(num_face+(1+dimension)%dimension);
585 // On recupere l'orientation de la face n+1
586 // est ce que l'on cherche ????
587
588 Cerr<<"(1+2)%2 " << (int) (1+2)%2<< " (1+3)%3 "<< (int) (1+3)%3<<finl;
589 Cerr<<" Si vous utilisiez "<<que_suis_je()<<" priere de contacter l'assistance TRUST"<<finl;
590 Cerr<<" un gros bug a ete trouve ...."<<finl;
591 assert(0);
592 Process::exit();
593 ori=orientation(num_face);
594 elem1 = face_voisins(num_face,0);
595 elem2 = face_voisins(num_face,1);
596 double a=volumes(elem1)/(volumes(elem1)+volumes(elem2));
597 double b=volumes(elem2)/(volumes(elem1)+volumes(elem2));
598
599 double reyn=a*uiuj(elem1)+b*uiuj(elem2);
600 double A=-1*(temper(elem2)-temper(elem1))/domaine_VDF.dist_norm(num_face)*reyn;
601 double B=0;
602 if (a*K_Eps_Bas_Re(elem1,0)+b*K_Eps_Bas_Re(elem2,0)>1.e-10)
603 B=-C1*Flux_Chaleur_Turb(num_face)*((a*K_Eps_Bas_Re(elem1,1)+b*K_Eps_Bas_Re(elem2,1))
604 /(a*K_Eps_Bas_Re(elem1,0)+b*K_Eps_Bas_Re(elem2,0)));
605 double C=-(1-C2)*Flux_Chaleur_Turb(num_face)*(a*Grad_U(elem1,ori,ori1)+b*Grad_U(elem2,ori,ori1));
606 double D=-(1-C3)*(a*gteta2(elem1,ori)+b*gteta2(elem2,ori));
607 //if (elem1==16 && elem2==17) {
608 // Cerr << "Flux transport:" << finl;
609 // Cerr << "reyn=" << reyn << " total=" << (A+B+C+D)*vol << finl;
610 // Cerr << "A=" << A << " B=" << B << " C=" << C << " D=" << D << finl;
611 //}
612 resu(num_face)+=(A+B+C+D)*vol;
613 }
614 return resu;
615}
616
617DoubleTab& Source_Transport_Flux_Chaleur_Turbulente_VDF_Face::calculer(DoubleTab& resu) const
618{
619 resu = 0;
620 return ajouter(resu);
621}
Champ_Don_base
classe Champ_Don_base classe de base des Champs donnes (non calcules)
Definition Champ_Don_base.h:32
Champ_Don_base::valeurs
DoubleTab & valeurs() override
Surcharge Champ_base::valeurs() Renvoie le tableau des valeurs.
Definition Champ_Don_base.h:49
Champ_Inc_base::valeurs
DoubleTab & valeurs() override
Renvoie le tableau des valeurs du champ au temps courant.
Definition Champ_Inc_base.h:77
Champ_Uniforme
classe Champ_Uniforme Represente un champ constant dans l'espace et dans le temps.
Definition Champ_Uniforme.h:26
Cond_lim
classe Cond_lim Classe generique servant a representer n'importe quelle classe
Definition Cond_lim.h:31
Convection_Diffusion_Temperature
classe Convection_Diffusion_Temperature Cas particulier de Convection_Diffusion_std
Definition Convection_Diffusion_Temperature.h:28
Domaine_Cl_VDF
class Domaine_Cl_VDF
Definition Domaine_Cl_VDF.h:63
Domaine_Cl_dis_base
classe Domaine_Cl_dis_base Les objets Domaine_Cl_dis_base representent les conditions aux limites
Definition Domaine_Cl_dis_base.h:37
Domaine_Cl_dis_base::les_conditions_limites
const Cond_lim & les_conditions_limites(int) const
Renvoie la i-ieme condition aux limites.
Definition Domaine_Cl_dis_base.cpp:386
Domaine_VDF
class Domaine_VDF
Definition Domaine_VDF.h:64
Domaine_VDF::dist_norm
double dist_norm(int num_face) const override
Definition Domaine_VDF.h:342
Domaine_VDF::orientation
int orientation(int) const override
inline DoubleVect& Domaine_VDF::porosite_face() {
Definition Domaine_VDF.h:297
Domaine_VDF::nb_aretes_internes
int nb_aretes_internes() const
Definition Domaine_VDF.h:562
Domaine_VDF::premiere_arete_interne
int premiere_arete_interne() const
Definition Domaine_VDF.h:578
Domaine_VDF::dist_face
double dist_face(int, int, int k) const
Definition Domaine_VDF.h:308
Domaine_VDF::Qdm
int Qdm(int num_arete, int) const
Definition Domaine_VDF.h:231
Domaine_VDF::dist_norm_bord
double dist_norm_bord(int num_face) const override
Definition Domaine_VDF.h:382
Domaine_VF::nb_faces
int nb_faces() const
renvoie le nombre global de faces.
Definition Domaine_VF.h:471
Domaine_VF::volumes_entrelaces
DoubleVect & volumes_entrelaces()
Definition Domaine_VF.h:99
Domaine_VF::volumes
double volumes(int i) const
Definition Domaine_VF.h:113
Domaine_VF::premiere_face_int
int premiere_face_int() const
une face est interne ssi elle separe deux elements.
Definition Domaine_VF.h:463
Domaine_VF::face_voisins
int face_voisins(int num_face, int i) const
renvoie l'element voisin de numface dans la direction i.
Definition Domaine_VF.h:418
Domaine_dis_base
classe Domaine_dis_base Cette classe est la base de la hierarchie des domaines discretisees.
Definition Domaine_dis_base.h:39
Domaine_dis_base::nb_elem_tot
int nb_elem_tot() const
Definition Domaine_dis_base.h:50
Domaine_dis_base::nb_elem
int nb_elem() const
Definition Domaine_dis_base.h:49
Domaine_dis_base::nb_front_Cl
int nb_front_Cl() const
Definition Domaine_dis_base.h:53
Entree
Class defining operators and methods for all reading operation in an input flow (file,...
Definition Entree.h:42
Equation_base::milieu
virtual const Milieu_base & milieu() const =0
Fluide_base
classe Fluide_base Cette classe represente un d'un fluide incompressible ainsi que
Definition Fluide_base.h:38
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
Milieu_base::beta_t
virtual const Champ_Don_base & beta_t() const
Renvoie beta_t du milieu.
Definition Milieu_base.cpp:887
Milieu_base::porosite_face
DoubleVect & porosite_face()
Definition Milieu_base.h:62
Milieu_base::gravite
virtual const Champ_Don_base & gravite() const
Renvoie la gravite du milieu si elle a ete associe provoque une erreur sinon.
Definition Milieu_base.cpp:716
Modele_turbulence_hyd_K_Eps_Bas_Reynolds
class Modele_turbulence_hyd_K_Eps_Bas_Reynolds
Definition Modele_turbulence_hyd_K_Eps_Bas_Reynolds.h:31
Modele_turbulence_hyd_K_Eps_Bas_Reynolds::get_eq_transport
const Transport_K_Eps_Bas_Reynolds & get_eq_transport() const override
Definition Modele_turbulence_hyd_K_Eps_Bas_Reynolds.h:61
Modele_turbulence_hyd_base
Classe Modele_turbulence_hyd_base Cette classe sert de base a la hierarchie des classes.
Definition Modele_turbulence_hyd_base.h:43
Modele_turbulence_hyd_base::viscosite_turbulente
const Champ_Fonc_base & viscosite_turbulente() const
Definition Modele_turbulence_hyd_base.h:46
Modele_turbulence_scal_Fluctuation_Temperature
Definition Modele_turbulence_scal_Fluctuation_Temperature.h:26
Modele_turbulence_scal_Fluctuation_Temperature::equation_Fluctu
Transport_Fluctuation_Temperature & equation_Fluctu()
Definition Modele_turbulence_scal_Fluctuation_Temperature.h:69
Modele_turbulence_scal_base
Classe Modele_turbulence_scal_base Cette classe represente un modele de turbulence pour une equation ...
Definition Modele_turbulence_scal_base.h:40
MorEqn::equation
const Equation_base & equation() const
Renvoie la reference sur l'equation pointe par MorEqn::mon_equation.
Definition MorEqn.h:62
Objet_U::dimension
static int dimension
Definition Objet_U.h:99
Objet_U::que_suis_je
const Nom & que_suis_je() const
renvoie la chaine identifiant la classe.
Definition Objet_U.cpp:104
Objet_U::readOn
virtual Entree & readOn(Entree &)
Lecture d'un Objet_U sur un flot d'entree Methode a surcharger.
Definition Objet_U.cpp:293
Objet_U::printOn
virtual Sortie & printOn(Sortie &) const
Ecriture de l'objet sur un flot de sortie Methode a surcharger.
Definition Objet_U.cpp:282
Probleme_base
classe Probleme_base C'est un Probleme_U qui n'est pas un couplage.
Definition Probleme_base.h:55
Probleme_base::equation
virtual const Equation_base & equation(int) const =0
Process::exit
static void exit(int exit_code=-1)
Routine de sortie de TRUST dans une region Kokkos.
Definition Process.cpp:455
Sortie
Classe de base des flux de sortie.
Definition Sortie.h:52
Source_Transport_Flux_Chaleur_Turbulente_VDF_Face
Definition Source_Transport_Flux_Chaleur_Turbulente_VDF_Face.h:51
Source_Transport_Flux_Chaleur_Turbulente_VDF_Face::C2
double C2
Definition Source_Transport_Flux_Chaleur_Turbulente_VDF_Face.h:71
Source_Transport_Flux_Chaleur_Turbulente_VDF_Face::ajouter
DoubleTab & ajouter(DoubleTab &) const override
Definition Source_Transport_Flux_Chaleur_Turbulente_VDF_Face.cpp:499
Source_Transport_Flux_Chaleur_Turbulente_VDF_Face::C1
double C1
Definition Source_Transport_Flux_Chaleur_Turbulente_VDF_Face.h:71
Source_Transport_Flux_Chaleur_Turbulente_VDF_Face::associer_pb
void associer_pb(const Probleme_base &) override
Definition Source_Transport_Flux_Chaleur_Turbulente_VDF_Face.cpp:96
Source_Transport_Flux_Chaleur_Turbulente_VDF_Face::calculer_gteta2
DoubleTab & calculer_gteta2(const Domaine_VDF &, DoubleTab &, const DoubleTab &, double, const DoubleVect &) const
Definition Source_Transport_Flux_Chaleur_Turbulente_VDF_Face.cpp:443
Source_Transport_Flux_Chaleur_Turbulente_VDF_Face::calculer_uiuj
DoubleTab & calculer_uiuj(const Domaine_VDF &, const DoubleTab &, const DoubleTab &, DoubleTab &) const
Definition Source_Transport_Flux_Chaleur_Turbulente_VDF_Face.cpp:121
Source_Transport_Flux_Chaleur_Turbulente_VDF_Face::associer_domaines
void associer_domaines(const Domaine_dis_base &, const Domaine_Cl_dis_base &) override
Definition Source_Transport_Flux_Chaleur_Turbulente_VDF_Face.cpp:108
Source_Transport_Flux_Chaleur_Turbulente_VDF_Face::C3
double C3
Definition Source_Transport_Flux_Chaleur_Turbulente_VDF_Face.h:71
Source_Transport_Flux_Chaleur_Turbulente_VDF_Face::calculer
DoubleTab & calculer(DoubleTab &) const override
Definition Source_Transport_Flux_Chaleur_Turbulente_VDF_Face.cpp:617
Source_Transport_Flux_Chaleur_Turbulente_VDF_Face::calculer_Grad_U
DoubleTab & calculer_Grad_U(const Domaine_VDF &, const DoubleTab &, const DoubleTab &, DoubleTab &) const
Definition Source_Transport_Flux_Chaleur_Turbulente_VDF_Face.cpp:280
Source_base
classe Source_base Un objet Source_base est un terme apparaissant au second membre d'une
Definition Source_base.h:42
TRUST_Ref_Objet_U::valeur
const Objet_U & valeur() const
Definition TRUST_Ref.h:134
Transport_Fluctuation_Temperature
Definition Transport_Fluctuation_Temperature.h:31
Transport_Fluctuation_Temperature::inconnue
const Champ_Inc_base & inconnue() const override
renvoie le champ inconnue.
Definition Transport_Fluctuation_Temperature.h:84
Transport_Flux_Chaleur_Turbulente
Definition Transport_Flux_Chaleur_Turbulente.h:28
Transport_K_Eps_base
Classe Transport_K_Eps_base Classe de base pour les equations.
Definition Transport_K_Eps_base.h:33
Transport_K_Eps_base::inconnue
const Champ_Inc_base & inconnue() const override
Renvoie le champ inconnue de l'equation.
Definition Transport_K_Eps_base.h:74