TrioCFD 1.9.8
TrioCFD documentation
Loading...
Searching...
No Matches
Terme_Source_inc_VDF_Face.cpp
1/****************************************************************************
2* Copyright (c) 2024, 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#include <Terme_Source_inc_VDF_Face.h>
17#include <math.h>
18#include <Domaine_VDF.h>
19#include <Domaine_Cl_VDF.h>
20#include <Neumann_sortie_libre.h>
21#include <Symetrie.h>
22#include <Dirichlet.h>
23#include <Dirichlet_homogene.h>
24#include <Periodique.h>
25#include <Pb_Fluide_base.h>
26#include <Navier_Stokes_std.h>
27#include <TRUSTTrav.h>
28
29Implemente_instanciable(Terme_Source_inc_VDF_Face,"inc_VDF_Face",Terme_Source_inc_base);
30
31//// printOn
32//
33
34Sortie& Terme_Source_inc_VDF_Face::printOn(Sortie& s ) const
35{
36 return s << que_suis_je() ;
37}
38
39
40//// readOn
41//
42
43Entree& Terme_Source_inc_VDF_Face::readOn(Entree& s )
44{
45 return Terme_Source_inc_base::readOn(s);
46}
47
48void Terme_Source_inc_VDF_Face::associer_pb(const Probleme_base& pb)
49{
50 if (sub_type(Pb_Fluide_base,pb))
51 {
52 const Navier_Stokes_std& eqn_th = ref_cast(Navier_Stokes_std,pb.equation(0));
53 Terme_Source_inc_base::associer_eqn(eqn_th);
54 }
55 else
56 {
57 Cerr << "Error for the method Terme_Source_inc_VDF_Face::associer_pb" << finl;
58 Cerr << "The source term "<<que_suis_je()<<" cannot be activated for the problem "<<pb.que_suis_je()<< finl;
59 exit();
60 }
61}
62
63void Terme_Source_inc_VDF_Face::associer_domaines(const Domaine_dis_base& domaine_dis,
64 const Domaine_Cl_dis_base& domaine_Cl_dis)
65{
66 le_dom_VDF = ref_cast(Domaine_VDF, domaine_dis);
67 le_dom_Cl_VDF = ref_cast(Domaine_Cl_VDF, domaine_Cl_dis);
68}
69
70// void Terme_Source_inc_VDF_Face::mettre_a_jour(double temps)
71// //void Turbulence_hyd_sous_maille_inc_VDF::mettre_a_jour(double )
72// {
73// int nb_elem_tot = le_dom_VDF->domaine().nb_elem_tot();
74// DoubleTrav cell_cent_vel(nb_elem_tot,dimension);
75// calculer_cell_cent_vel(cell_cent_vel);
76// }
77
78
79void Terme_Source_inc_VDF_Face::ajouter_blocs(matrices_t matrices, DoubleTab& secmem, const tabs_t& semi_impl) const
80{
81 const Domaine_VDF& domaine_VDF = le_dom_VDF.valeur();
82 const Domaine_Cl_VDF& domaine_Cl_VDF = le_dom_Cl_VDF.valeur();
83 const IntTab& face_voisins = domaine_VDF.face_voisins();
84 const IntVect& orientation = domaine_VDF.orientation();
85 //const DoubleTab& xv = domaine_VDF.xv();
86 const DoubleVect& porosite_surf = equation().milieu().porosite_face();
87 const DoubleVect& volumes_entrelaces = domaine_VDF.volumes_entrelaces();
88 const Domaine& domaine = le_dom_VDF->domaine();
89 int nb_elem = domaine.nb_elem();
90
91 int ndeb,nfin,ncomp,num_face;
92 // double debit_e=0.,dt,vol,Surf;
93 double vol;
94 DoubleTrav s(3);
95 s = 0.;
96 //int nb_elem_tot = le_dom_VDF->domaine().nb_elem_tot();
97 // double dQij=0;
98 // double si;
99
100 // static int deb=0;
101 // static double source=0.;
102 // static double debnm1;
103 // static double debit_ref=0.;
104 // Cerr << " debut de inc" << finl;
105 // double tps = eq_hydraulique().inconnue().temps();
106 // const DoubleVect& vit = eq_hydraulique().inconnue().valeurs();
107
108 // calculer_cell_cent_vel
109 // -------------------------------------------------------------------
110
111
112 // Exemple XTOF
113 // Cerr << " debut de parallel " << finl;
114 DoubleTab cell_cent_vel(0,dimension);
115 le_dom_VDF->domaine().creer_tableau_elements(cell_cent_vel);
116 // DoubleTrav toto(cell_cent_vel);
117 DoubleTab temp1(cell_cent_vel);
118 DoubleTab temp2(cell_cent_vel);
119 DoubleTab filt_vel(cell_cent_vel);
120 DoubleTab inc_dv(cell_cent_vel);
121 DoubleTab dQij_j(cell_cent_vel);
122
123
124 // DoubleTrav cell_cent_vel(nb_elem_tot,dimension);
125
126 // -------------------------------------------------------------------
127 const DoubleTab& vitesse = mon_equation->inconnue().valeurs();
128 // const DoubleTab& vitesse = mon_equation->inconnue().valeurs();
129 // const Domaine_VDF& domaine_VDF = le_dom_VDF.valeur();
130 // int nb_elem_tot = domaine_VDF.domaine().nb_elem_tot();
131 const IntTab& elem_faces = domaine_VDF.elem_faces();
132 int element_number;
133 int num0=-1,num1,num2=-1,num3,num4=-1,num5=-1;
134 // Cerr << " vitesse " << vitesse << finl;
135 // This is to calculate the cell centered velocity values
136
137 DoubleTab uij_filt_1(cell_cent_vel);
138 DoubleTab uij_filt_2(cell_cent_vel);
139 DoubleTab uij_filt_3(cell_cent_vel);
140 //DoubleTab uij_filt(nb_elem,dimension,dimension);
141 for (element_number=0 ; element_number<nb_elem ; element_number ++)
142 {
143 // Cerr << me() << " " << element_number << finl;
144 num0 = elem_faces(element_number,0);
145 num1 = elem_faces(element_number,1);
146 num2 = elem_faces(element_number,2);
147 num3 = elem_faces(element_number,3);
148 // uij_filt(element_number,0,0)=uij_filt_1(element_number,0);
149 // uij_filt(element_number,1,0)=uij_filt_1(element_number,1);
150 // uij_filt(element_number,0,1)=uij_filt_2(element_number,0);
151 // uij_filt(element_number,1,1)=uij_filt_2(element_number,1);
152 if (dimension == 3)
153 {
154 // uij_filt(element_number,0,2)=uij_filt_3(element_number,0);
155 // uij_filt(element_number,1,2)=uij_filt_3(element_number,1);
156 // uij_filt(element_number,2,2)=uij_filt_3(element_number,2);
157 // uij_filt(element_number,2,0)=uij_filt_1(element_number,2);
158 // uij_filt(element_number,2,1)=uij_filt_2(element_number,2);
159 num4 = elem_faces(element_number,4);
160 num5 = elem_faces(element_number,5);
161 }
162
163 if (dimension == 2)
164 {
165 cell_cent_vel(element_number,0)=0.5*(vitesse[num0]+vitesse[num2]);
166 cell_cent_vel(element_number,1)=0.5*(vitesse[num1]+vitesse[num3]);
167 }
168 else
169 {
170 cell_cent_vel(element_number,0)=0.5*(vitesse[num0]+vitesse[num3]);
171 cell_cent_vel(element_number,1)=0.5*(vitesse[num1]+vitesse[num4]);
172 cell_cent_vel(element_number,2)=0.5*(vitesse[num2]+vitesse[num5]);
173 }
174 }
175 cell_cent_vel.echange_espace_virtuel();
176
177 // Cerr << " calculer_filter_field" << finl;
178 //
179 // calculer_filter_field(cell_cent_vel,filt_vel);
180 //
181 // calculate filter vector, unfilter tensor and
182 // increment fields in the same loop to speed up calculation
183 //
184 // -------------------------------------------------------------------
185
186 // DoubleTab toto(cell_cent_vel);
187
188 DoubleTab Qij_1(cell_cent_vel);
189 DoubleTab Qij_2(cell_cent_vel);
190 DoubleTab Qij_3(cell_cent_vel);
191 DoubleTab Lij_1(cell_cent_vel);
192 DoubleTab Lij_2(cell_cent_vel);
193 DoubleTab Lij_3(cell_cent_vel);
194 DoubleTab ttemp1_1(cell_cent_vel);
195 DoubleTab ttemp1_2(cell_cent_vel);
196 DoubleTab ttemp1_3(cell_cent_vel);
197 DoubleTab ttemp2_1(cell_cent_vel);
198 DoubleTab ttemp2_2(cell_cent_vel);
199 DoubleTab ttemp2_3(cell_cent_vel);
200 // DoubleTab Qij(uij_filt);
201 // DoubleTab Lij(uij_filt);
202 // DoubleTab ttemp1(uij_filt);
203 // DoubleTab ttemp2(uij_filt);
204 // DoubleTrav filt_vel(nb_elem_tot,dimension);
205 // DoubleTrav inc_dv(nb_elem_tot,dimension);
206 // inc_dv.resize(nb_elem_tot,dimension);
207 // DoubleTrav uij_filt(nb_elem_tot,dimension,dimension);
208
209 // -------------------------------------------------------------------
210 // const Domaine_VDF& domaine_VDF = le_dom_VDF.valeur();
211 // const IntTab& face_voisins = domaine_VDF.face_voisins();
212 // int nb_elem_tot = domaine_VDF.domaine().nb_elem_tot();
213 // const IntTab& elem_faces = domaine_VDF.elem_faces();
214 // int element_number;
215 // int num0,num1,num2,num3,num4,num5;
216 int f0,f1,f2,f3,f4,f5;
217 int i;
218 int num0_1,num1_1,num2_1,num3_1,num4_1,num5_1;
219 int f0_1,f1_1,f2_1,f3_1,f4_1,f5_1;
220
221 // DoubleTrav temp1(nb_elem_tot,dimension);
222 // DoubleTrav temp2(nb_elem_tot,dimension);
223
224 // This is to calculate the filtered velocity field
225 // Cerr << me() << " boucle 1 " << finl;
226 if (dimension ==2)
227 {
228 for (element_number=0 ; element_number<nb_elem ; element_number ++)
229 {
230 // for (i=0 ; i<dimension ; i++)
231 // for (j=0 ; j<dimension ; j++)
232 // uij_filt(element_number,i,j)=cell_cent_vel(element_number,i)*
233 // cell_cent_vel(element_number,j);
234 for (i=0 ; i<dimension ; i++)
235 {
236 uij_filt_1(element_number,i)=cell_cent_vel(element_number,i)*
237 cell_cent_vel(element_number,0);
238 uij_filt_2(element_number,i)=cell_cent_vel(element_number,i)*
239 cell_cent_vel(element_number,1);
240 }
241 f0 = elem_faces(element_number,0);
242 num0 = face_voisins(f0,0);
243 f2 = elem_faces(element_number,2);
244 num2 = face_voisins(f2,1);
245 if ( (num0 == -1) || (num2 == -1) )
246 for (i=0 ; i<dimension ; i ++)
247 {
248 temp1(element_number,i)=cell_cent_vel(element_number,i);
249 inc_dv(element_number,i)=0.;
250 }
251 else
252 {
253 for (i=0 ; i<dimension ; i ++)
254 {
255 temp1(element_number,i)=0.25*(cell_cent_vel(num0,i)+
256 2.0*cell_cent_vel(element_number,i)+
257 cell_cent_vel(num2,i));
258 }
259 f0_1 = elem_faces(num0,0);
260 num0_1 = face_voisins(f0_1,0);
261 f2_1 = elem_faces(num2,2);
262 num2_1 = face_voisins(f2_1,1);
263 if ( (num0_1 == -1) || (num2_1 == -1) )
264 for (i=0 ; i<dimension ; i ++)
265 inc_dv(element_number,i)+=(cell_cent_vel(num0,i))-(cell_cent_vel(num2,i));
266 else
267 {
268 for (i=0 ; i<dimension ; i ++)
269 {
270 inc_dv(element_number,i)+=(cell_cent_vel(num0_1,i))-(cell_cent_vel(num2_1,i));
271 }
272 }
273 }
274 }
275 temp1.echange_espace_virtuel();
276
277 for (element_number=0 ; element_number<nb_elem ; element_number ++)
278 {
279 f1 = elem_faces(element_number,1);
280 num1 = face_voisins(f1,0);
281 f3 = elem_faces(element_number,3);
282 num3 = face_voisins(f3,1);
283 if ( (num1 == -1) || (num3 == -1) )
284 for (i=0 ; i<dimension ; i ++)
285 {
286 filt_vel(element_number,i)=temp1(element_number,i);
287 inc_dv(element_number,i)=0.;
288 }
289 else
290 {
291 for (i=0 ; i<dimension ; i ++)
292 {
293 filt_vel(element_number,i)=0.25*(temp1(num1,i)+
294 2.0*temp1(element_number,i)+
295 temp1(num3,i));
296 }
297 f1_1 = elem_faces(num0,1);
298 num1_1 = face_voisins(f1_1,0);
299 f3_1 = elem_faces(num3,3);
300 num3_1 = face_voisins(f3_1,1);
301 if ( (num1_1 == -1) || (num3_1 == -1) )
302 for (i=0 ; i<dimension ; i ++)
303 inc_dv(element_number,i)+=(cell_cent_vel(num1,i))-(cell_cent_vel(num3,i));
304 else
305 {
306 for (i=0 ; i<dimension ; i ++)
307 {
308 inc_dv(element_number,i)+=(cell_cent_vel(num1_1,i))-(cell_cent_vel(num3_1,i));
309 }
310 }
311 }
312 }
313 }
314 else // dimension == 3
315 {
316 for (element_number=0 ; element_number<nb_elem ; element_number ++)
317 {
318 // for (i=0 ; i<dimension ; i++)
319 // for (j=0 ; j<dimension ; j++)
320 // uij_filt(element_number,i,j)=cell_cent_vel(element_number,i)*
321 // cell_cent_vel(element_number,j);
322 for (i=0 ; i<dimension ; i++)
323 {
324 uij_filt_1(element_number,i)=cell_cent_vel(element_number,i)*
325 cell_cent_vel(element_number,0);
326 uij_filt_2(element_number,i)=cell_cent_vel(element_number,i)*
327 cell_cent_vel(element_number,1);
328 uij_filt_3(element_number,i)=cell_cent_vel(element_number,i)*
329 cell_cent_vel(element_number,2);
330 }
331 f0 = elem_faces(element_number,0);
332 num0 = face_voisins(f0,0);
333 f3 = elem_faces(element_number,3);
334 num3 = face_voisins(f3,1);
335 if ( (num0 == -1) || (num3 == -1) )
336 for (i=0 ; i<dimension ; i ++)
337 {
338 temp1(element_number,i)=cell_cent_vel(element_number,i);
339 inc_dv(element_number,i)+=0.;
340 }
341 else
342 {
343 for (i=0 ; i<dimension ; i ++)
344 {
345 temp1(element_number,i)=0.25*(cell_cent_vel(num0,i)+
346 2.0*cell_cent_vel(element_number,i)+
347 cell_cent_vel(num3,i));
348 }
349 // Cerr << " not num0 et num3 " << num0 << " " << num3 << finl;
350 f0_1 = elem_faces(num0,0);
351 num0_1 = face_voisins(f0_1,0);
352 f3_1 = elem_faces(num3,3);
353 num3_1 = face_voisins(f3_1,1);
354 if ( (num0_1 == -1) || (num3_1 == -1) )
355 for (i=0 ; i<dimension ; i ++)
356 inc_dv(element_number,i)+=(cell_cent_vel(num0,i))-(cell_cent_vel(num3,i));
357 else
358 {
359 // Cerr << " not num0_1 et num3_1 " << num0_1 << " " << num3_1 << finl;
360 for (i=0 ; i<dimension ; i ++)
361 {
362 inc_dv(element_number,i)+=(cell_cent_vel(num0_1,i))-(cell_cent_vel(num3_1,i));
363 }
364 }
365 }
366 }
367
368 temp1.echange_espace_virtuel();
369 for (element_number=0 ; element_number<nb_elem ; element_number ++)
370 {
371 f1 = elem_faces(element_number,1);
372 num1 = face_voisins(f1,0);
373 f4 = elem_faces(element_number,4);
374 num4 = face_voisins(f4,1);
375 if ( (num1 == -1) || (num4 == -1) )
376 for (i=0 ; i<dimension ; i ++)
377 {
378 temp2(element_number,i)=temp1(element_number,i);
379 inc_dv(element_number,i)+=0.;
380 }
381 else
382 {
383 for (i=0 ; i<dimension ; i ++)
384 {
385 temp2(element_number,i)=0.25*(temp1(num1,i)+
386 2.0*temp1(element_number,i)+
387 temp1(num4,i));
388 }
389 // Cerr << " not num1 et num4 " << num1 << " " << num4 << finl;
390 f1_1 = elem_faces(num1,1);
391 num1_1 = face_voisins(f1_1,0);
392 f4_1 = elem_faces(num4,4);
393 num4_1 = face_voisins(f4_1,1);
394 if ( (num1_1 == -1) || (num4_1 == -1) )
395 for (i=0 ; i<dimension ; i ++)
396 inc_dv(element_number,i)+=(cell_cent_vel(num1,i))-(cell_cent_vel(num4,i));
397 else
398 {
399 // Cerr << " not num1_1 et num4_1 " << num1_1 << " " << num4_1 << finl;
400 for (i=0 ; i<dimension ; i ++)
401 {
402 inc_dv(element_number,i)+=(cell_cent_vel(num1_1,i))-(cell_cent_vel(num4_1,i));
403 }
404 }
405 }
406 }
407
408 temp2.echange_espace_virtuel();
409 for (element_number=0 ; element_number<nb_elem ; element_number ++)
410 {
411 f2 = elem_faces(element_number,2);
412 num2 = face_voisins(f2,0);
413 f5 = elem_faces(element_number,5);
414 num5 = face_voisins(f5,1);
415 if ( (num2 == -1) || (num5 == -1) )
416 for (i=0 ; i<dimension ; i ++)
417 {
418 filt_vel(element_number,i)=temp2(element_number,i);
419 inc_dv(element_number,i)+=0.;
420 }
421 else
422 {
423 for (i=0 ; i<dimension ; i ++)
424 {
425 filt_vel(element_number,i)=0.25*(temp2(num2,i)+
426 2.0*temp2(element_number,i)+
427 temp2(num5,i));
428 }
429 // Cerr << " not num2 et num5 " << num2 << " " << num5 << finl;
430 f2_1 = elem_faces(num2,2);
431 num2_1 = face_voisins(f2_1,0);
432 f5_1 = elem_faces(num5,5);
433 num5_1 = face_voisins(f5_1,1);
434 if ( (num2_1 == -1) || (num5_1 == -1) )
435 for (i=0 ; i<dimension ; i ++)
436 inc_dv(element_number,i)+=(cell_cent_vel(num2,i))-(cell_cent_vel(num5,i));
437 else
438 {
439 // Cerr << " not num2_1 et num5_1 " << num2_1 << " " << num5_1 << finl;
440 for (i=0 ; i<dimension ; i ++)
441 {
442 inc_dv(element_number,i)+=(cell_cent_vel(num2_1,i))-(cell_cent_vel(num5_1,i));
443 }
444 }
445 }
446 }
447 }
448 filt_vel.echange_espace_virtuel();
449 inc_dv.echange_espace_virtuel();
450 uij_filt_1.echange_espace_virtuel();
451 uij_filt_2.echange_espace_virtuel();
452 uij_filt_3.echange_espace_virtuel();
453
454 //
455 // calculer_Qij(inc_dv,Qij);
456 // -------------------------------------------------------------------
457
458 // DoubleTrav Qij(nb_elem_tot,dimension,dimension);
459
460 // -------------------------------------------------------------------
461 // const Domaine_VDF& domaine_VDF = le_dom_VDF.valeur();
462 // int nb_elem_tot = domaine_VDF.domaine().nb_elem_tot();
463 // int element_number;
464
465 // This is to calculate the Qij tensor
466
467 // for (element_number=0 ; element_number<nb_elem_tot ; element_number ++)
468 // {
469 // for (int i=0 ; i<dimension ; i++)
470 // for (int j=0 ; j<dimension ; j++)
471 // Qij(element_number,i,j)=inc_dv(element_number,i)*inc_dv(element_number,j);
472 // }
473
474 // Cerr << " calculer_Lij " << finl;
475 //
476 // calculer_Lij(cell_cent_vel,filt_vel,Lij);
477 //
478 // calculate Qij and uij_filt in the same loop to speed up calculation
479 //
480 // -------------------------------------------------------------------
481
482 // DoubleTrav Lij(nb_elem_tot,dimension,dimension);
483
484 // -------------------------------------------------------------------
485 // const Domaine_VDF& domaine_VDF = le_dom_VDF.valeur();
486 // int nb_elem_tot = domaine_VDF.domaine().nb_elem_tot();
487 // int element_number;
488
489 // DoubleTrav uij_filt(nb_elem_tot,dimension,dimension);
490 // DoubleTrav ttemp1(nb_elem_tot,dimension,dimension);
491 // DoubleTrav ttemp2(nb_elem_tot,dimension,dimension);
492
493 // This is to calculate the Lij term for the C coefficient
494
495 // for (element_number=0 ; element_number<nb_elem_tot ; element_number ++)
496 // {
497 // for (int i=0 ; i<dimension ; i++)
498 // for (int j=0 ; j<dimension ; j++)
499 // {
500 // uij_filt(element_number,i,j)=cell_cent_vel(element_number,i)*
501 // cell_cent_vel(element_number,j);
502 // }
503 // }
504
505 // calculer_filter_tensor(uij_filt);
506 // Cerr << " calculer_uij_filt " << finl;
507
508 // This is to calculate the filtered tensor field
509 // int j;
510 // Cerr << me() << " boucle 2 " << finl;
511 if (dimension ==2)
512 {
513 for (element_number=0 ; element_number<nb_elem ; element_number ++)
514 {
515 f0 = elem_faces(element_number,0);
516 num0 = face_voisins(f0,0);
517 f2 = elem_faces(element_number,2);
518 num2 = face_voisins(f2,1);
519 if ( (num0 == -1) || (num2 == -1) )
520 // for (i=0 ; i<dimension ; i ++)
521 // for (j=0 ; j<dimension ; j ++)
522 // ttemp1(element_number,i,j)=uij_filt(element_number,i,j);
523 for (i=0 ; i<dimension ; i++)
524 {
525 ttemp1_1(element_number,i)=uij_filt_1(element_number,i);
526 ttemp1_2(element_number,i)=uij_filt_2(element_number,i);
527 }
528 else
529 {
530 // for (i=0 ; i<dimension ; i ++)
531 // for (j=0 ; j<dimension ; j ++)
532 // {
533 // ttemp1(element_number,i,j)=0.25*(uij_filt(num0,i,j)+
534 // 2.0*uij_filt(element_number,i,j)+
535 // uij_filt(num2,i,j));
536 // }
537 for (i=0 ; i<dimension ; i++)
538 {
539 ttemp1_1(element_number,i)=0.25*(uij_filt_1(num0,i)+
540 2.0*uij_filt_1(element_number,i)+
541 uij_filt_1(num2,i));
542 ttemp1_2(element_number,i)=0.25*(uij_filt_2(num0,i)+
543 2.0*uij_filt_2(element_number,i)+
544 uij_filt_2(num2,i));
545 }
546 }
547 }
548
549 ttemp1_1.echange_espace_virtuel();
550 ttemp1_2.echange_espace_virtuel();
551 for (element_number=0 ; element_number<nb_elem ; element_number ++)
552 {
553 f1 = elem_faces(element_number,1);
554 num1 = face_voisins(f1,0);
555 f3 = elem_faces(element_number,3);
556 num3 = face_voisins(f3,1);
557 if ( (num1 == -1) || (num3 == -1) )
558 // for (i=0 ; i<dimension ; i ++)
559 // for (j=0 ; j<dimension ; j ++)
560 // uij_filt(element_number,i,j)=ttemp1(element_number,i,j);
561 for (i=0 ; i<dimension ; i++)
562 {
563 uij_filt_1(element_number,i)=ttemp1_1(element_number,i);
564 uij_filt_2(element_number,i)=ttemp1_2(element_number,i);
565 }
566 else
567 {
568 // for (i=0 ; i<dimension ; i ++)
569 // for (j=0 ; j<dimension ; j ++)
570 // {
571 // uij_filt(element_number,i,j)=0.25*(ttemp1(num1,i,j)+
572 // 2.0*ttemp1(element_number,i,j)+
573 // ttemp1(num3,i,j));
574 // }
575 for (i=0 ; i<dimension ; i++)
576 {
577 uij_filt_1(element_number,i)=0.25*(ttemp1_1(num0,i)+
578 2.0*ttemp1_1(element_number,i)+
579 ttemp1_1(num2,i));
580 uij_filt_2(element_number,i)=0.25*(ttemp1_2(num0,i)+
581 2.0*ttemp1_2(element_number,i)+
582 ttemp1_2(num2,i));
583 }
584 }
585 }
586 }
587 else
588 {
589 for (element_number=0 ; element_number<nb_elem ; element_number ++)
590 {
591 f0 = elem_faces(element_number,0);
592 num0 = face_voisins(f0,0);
593 f3 = elem_faces(element_number,3);
594 num3 = face_voisins(f3,1);
595 if ( (num0 == -1) || (num3 == -1) )
596 // for (i=0 ; i<dimension ; i ++)
597 // for (j=0 ; j<dimension ; j ++)
598 // ttemp1(element_number,i,j)=uij_filt(element_number,i,j);
599 for (i=0 ; i<dimension ; i++)
600 {
601 ttemp1_1(element_number,i)=uij_filt_1(element_number,i);
602 ttemp1_2(element_number,i)=uij_filt_2(element_number,i);
603 ttemp1_3(element_number,i)=uij_filt_3(element_number,i);
604 }
605 else
606 {
607 // for (i=0 ; i<dimension ; i ++)
608 // for (j=0 ; j<dimension ; j ++)
609 // {
610 // ttemp1(element_number,i,j)=0.25*(uij_filt(num0,i,j)+
611 // 2.0*uij_filt(element_number,i,j)+
612 // uij_filt(num3,i,j));
613 // }
614 for (i=0 ; i<dimension ; i++)
615 {
616 ttemp1_1(element_number,i)=0.25*(uij_filt_1(num0,i)+
617 2.0*uij_filt_1(element_number,i)+
618 uij_filt_1(num2,i));
619 ttemp1_2(element_number,i)=0.25*(uij_filt_2(num0,i)+
620 2.0*uij_filt_2(element_number,i)+
621 uij_filt_2(num2,i));
622 ttemp1_3(element_number,i)=0.25*(uij_filt_3(num0,i)+
623 2.0*uij_filt_3(element_number,i)+
624 uij_filt_3(num2,i));
625 }
626 }
627 }
628
629 ttemp1_1.echange_espace_virtuel();
630 ttemp1_2.echange_espace_virtuel();
631 ttemp1_3.echange_espace_virtuel();
632 for (element_number=0 ; element_number<nb_elem ; element_number ++)
633 {
634 f1 = elem_faces(element_number,1);
635 num1 = face_voisins(f1,0);
636 f4 = elem_faces(element_number,4);
637 num4 = face_voisins(f4,1);
638 if ( (num1 == -1) || (num4 == -1) )
639 // for (i=0 ; i<dimension ; i ++)
640 // for (j=0 ; j<dimension ; j ++)
641 // ttemp2(element_number,i,j)=ttemp1(element_number,i,j);
642 for (i=0 ; i<dimension ; i++)
643 {
644 ttemp2_1(element_number,i)=ttemp1_1(element_number,i);
645 ttemp2_2(element_number,i)=ttemp1_2(element_number,i);
646 ttemp2_3(element_number,i)=ttemp1_3(element_number,i);
647 }
648 else
649 {
650 // for (i=0 ; i<dimension ; i ++)
651 // for (j=0 ; j<dimension ; j ++)
652 // {
653 // ttemp2(element_number,i,j)=0.25*(ttemp1(num1,i,j)+
654 // 2.0*ttemp1(element_number,i,j)+
655 // ttemp1(num4,i,j));
656 // }
657 }
658 }
659
660 ttemp2_1.echange_espace_virtuel();
661 ttemp2_2.echange_espace_virtuel();
662 ttemp2_3.echange_espace_virtuel();
663 for (element_number=0 ; element_number<nb_elem ; element_number ++)
664 {
665 f2 = elem_faces(element_number,2);
666 num2 = face_voisins(f2,0);
667 f5 = elem_faces(element_number,5);
668 num5 = face_voisins(f5,1);
669 if ( (num2 == -1) || (num5 == -1) )
670 // for (i=0 ; i<dimension ; i ++)
671 // for (j=0 ; j<dimension ; j ++)
672 // uij_filt(element_number,i,j)=ttemp2(element_number,i,j);
673 for (i=0 ; i<dimension ; i++)
674 {
675 uij_filt_1(element_number,i)=ttemp2_1(element_number,i);
676 uij_filt_2(element_number,i)=ttemp2_2(element_number,i);
677 uij_filt_3(element_number,i)=ttemp2_3(element_number,i);
678 }
679 else
680 {
681 // for (i=0 ; i<dimension ; i ++)
682 // for (j=0 ; j<dimension ; j ++)
683 // {
684 // uij_filt(element_number,i,j)=0.25*(ttemp2(num2,i,j)+
685 // 2.0*ttemp2(element_number,i,j)+
686 // ttemp2(num5,i,j));
687 // }
688 for (i=0 ; i<dimension ; i++)
689 {
690 uij_filt_1(element_number,i)=0.25*(ttemp2_1(num0,i)+
691 2.0*ttemp2_1(element_number,i)+
692 ttemp2_1(num2,i));
693 uij_filt_2(element_number,i)=0.25*(ttemp2_2(num0,i)+
694 2.0*ttemp2_2(element_number,i)+
695 ttemp2_2(num2,i));
696 uij_filt_3(element_number,i)=0.25*(ttemp2_3(num0,i)+
697 2.0*ttemp2_3(element_number,i)+
698 ttemp2_3(num2,i));
699 }
700 }
701 }
702 }
703 // finish calculating Lij
704
705 uij_filt_1.echange_espace_virtuel();
706 uij_filt_2.echange_espace_virtuel();
707 uij_filt_3.echange_espace_virtuel();
708 // Cerr << me() << " boucle 3 " << finl;
709 for (element_number=0 ; element_number<nb_elem ; element_number ++)
710 {
711 // for (int i=0 ; i<dimension ; i++)
712 // for (int j=0 ; j<dimension ; j++)
713 // {
714 // Qij(element_number,i,j)=inc_dv(element_number,i)*inc_dv(element_number,j);
715 // Lij(element_number,i,j)=uij_filt(element_number,i,j)-
716 // filt_vel(element_number,i)*filt_vel(element_number,j);
717 // }
718 for (int ii=0 ; ii<dimension ; ii++)
719 {
720 Qij_1(element_number,ii)=inc_dv(element_number,ii)*inc_dv(element_number,0);
721 Qij_2(element_number,ii)=inc_dv(element_number,ii)*inc_dv(element_number,1);
722 Lij_1(element_number,ii)=uij_filt_1(element_number,ii)-
723 filt_vel(element_number,ii)*filt_vel(element_number,0);
724 Lij_2(element_number,ii)=uij_filt_2(element_number,ii)-
725 filt_vel(element_number,ii)*filt_vel(element_number,1);
726 if (dimension == 3)
727 {
728 Qij_3(element_number,ii)=inc_dv(element_number,ii)*inc_dv(element_number,2);
729 Lij_3(element_number,ii)=uij_filt_3(element_number,ii)-
730 filt_vel(element_number,ii)*filt_vel(element_number,2);
731 }
732 }
733 }
734
735 Lij_1.echange_espace_virtuel();
736 Lij_2.echange_espace_virtuel();
737 Lij_3.echange_espace_virtuel();
738 Qij_1.echange_espace_virtuel();
739 Qij_2.echange_espace_virtuel();
740 Qij_3.echange_espace_virtuel();
741 //
742 // calculer_f(Lij,Qij);
743 // -------------------------------------------------------------------
744
745 DoubleVect f(nb_elem);
746
747 // -------------------------------------------------------------------
748 DoubleVect temp_1(nb_elem);
749 DoubleVect temp_2(nb_elem);
750
751 // Evaluate the dynamic model coefficient f
752 int elem;
753 if (dimension == 2)
754 for (elem=0; elem<nb_elem; elem++)
755 {
756 // temp_1(elem)=0.;
757 // temp_2(elem)=0.;
758 // for (int k=0 ; k<dimension ; k++)
759 // for (int l=0 ; l<dimension ; l++)
760 // {
761 // temp_1(elem)+=Lij(elem,k,k);
762 // temp_2(elem)+=4.*Qij(elem,l,l);
763 // }
764
765 temp_1(elem)=Lij_1(elem,0)+Lij_2(elem,1);
766 temp_2(elem)=4.*Qij_1(elem,0)+4.*Qij_2(elem,1);
767 if(std::fabs(temp_2(elem)) < 1.e-12)
768 f(elem)=0.;
769 else
770 f(elem)=temp_1(elem)/temp_2(elem);
771 }
772 else
773 for (elem=0; elem<nb_elem; elem++)
774 {
775 // temp_1(elem)=0.;
776 // temp_2(elem)=0.;
777
778 temp_1(elem)=Lij_1(elem,0)+Lij_2(elem,1)+Lij_3(elem,2);
779 temp_2(elem)=4.*Qij_1(elem,0)+4.*Qij_2(elem,1)+4.*Qij_3(elem,2);
780 if(std::fabs(temp_2(elem)) < 1.e-12)
781 f(elem)=0.;
782 else
783 f(elem)=temp_1(elem)/temp_2(elem);
784 }
785
786 f.echange_espace_virtuel();
787 // Cerr << " calculer_dQij_j" << f << " " << Qij << finl;
788 //
789 // calculer_dQij_j(f,Qij,dQij_j);
790 // -------------------------------------------------------------------
791
792 // DoubleTrav dQij_j(nb_elem_tot,dimension);
793 // dQij_j.resize(nb_elem_tot,dimension);
794
795 // -------------------------------------------------------------------
796 //const IntTab& Qdm = domaine_VDF.Qdm();
797 // const IntVect& orientation = domaine_VDF.orientation();
798
799 //
800 // Calculate the source term dQij_j = d/dxj ( f Qij )
801 //
802 // Cerr << me() << " boucle 4 " << nb_elem << finl;
803 if (dimension ==2)
804 {
805 for (element_number=0 ; element_number<nb_elem ; element_number ++)
806 {
807 f0 = elem_faces(element_number,0);
808 num0 = face_voisins(f0,0);
809 if (num0 == -1)
810 num0 = element_number;
811 f1 = elem_faces(element_number,1);
812 num1 = face_voisins(f1,0);
813 if (num1 == -1)
814 num1 = element_number;
815 f2 = elem_faces(element_number,2);
816 num2 = face_voisins(f2,1);
817 if (num2 == -1)
818 num2 = element_number;
819 f3 = elem_faces(element_number,3);
820 num3 = face_voisins(f3,1);
821 if (num3 == -1)
822 num3 = element_number;
823 // dQij_j(element_number,0)=0.5*((f(num2)*Qij(num2,0,0)-f(num0)*Qij(num0,0,0))/
824 // domaine_VDF.dim_elem(element_number,0));
825 // dQij_j(element_number,0)+=0.5*((f(num3)*Qij(num3,0,1)-f(num1)*Qij(num1,0,1))/
826 // domaine_VDF.dim_elem(element_number,1));
827 // dQij_j(element_number,1)=0.5*((f(num2)*Qij(num2,1,0)-f(num0)*Qij(num0,1,0))/
828 // domaine_VDF.dim_elem(element_number,0));
829 // dQij_j(element_number,1)+=0.5*((f(num3)*Qij(num3,1,1)-f(num1)*Qij(num1,1,1))/
830 // domaine_VDF.dim_elem(element_number,1));
831 dQij_j(element_number,0)=0.5*((f(num2)*Qij_1(num2,0)-f(num0)*Qij_1(num0,0))/
832 domaine_VDF.dim_elem(element_number,0));
833 dQij_j(element_number,0)+=0.5*((f(num3)*Qij_2(num3,0)-f(num1)*Qij_2(num1,0))/
834 domaine_VDF.dim_elem(element_number,1));
835 dQij_j(element_number,1)=0.5*((f(num2)*Qij_1(num2,1)-f(num0)*Qij_1(num0,1))/
836 domaine_VDF.dim_elem(element_number,0));
837 dQij_j(element_number,1)+=0.5*((f(num3)*Qij_2(num3,1)-f(num1)*Qij_2(num1,1))/
838 domaine_VDF.dim_elem(element_number,1));
839 }
840 }
841 else
842 {
843 for (element_number=0 ; element_number<nb_elem ; element_number ++)
844 {
845 f0 = elem_faces(element_number,0);
846 num0 = face_voisins(f0,0);
847 if (num0 == -1 || num0 >= nb_elem)
848 {
849 // Cerr << me() << " bord num0 " << finl;
850 num0 = element_number;
851 }
852 f1 = elem_faces(element_number,1);
853 num1 = face_voisins(f1,0);
854 if (num1 == -1 || num0 >= nb_elem)
855 {
856 // Cerr << me() << " bord num1 " << finl;
857 num1 = element_number;
858 }
859 f2 = elem_faces(element_number,2);
860 num2 = face_voisins(f2,0);
861 if (num2 == -1 || num2 >= nb_elem)
862 {
863 // Cerr << me() << " bord num2 " << finl;
864 num2 = element_number;
865 }
866 f3 = elem_faces(element_number,3);
867 num3 = face_voisins(f3,1);
868 if (num3 == -1 || num3 >= nb_elem)
869 {
870 // Cerr << me() << " bord num3 " << finl;
871 num3 = element_number;
872 }
873 f4 = elem_faces(element_number,4);
874 num4 = face_voisins(f4,1);
875 if (num4 == -1 || num4 >= nb_elem)
876 {
877 // Cerr << me() << " bord num4 " << finl;
878 num4 = element_number;
879 }
880 f5 = elem_faces(element_number,5);
881 num5 = face_voisins(f5,1);
882 if (num5 == -1 || num5 >= nb_elem)
883 {
884 // Cerr << me() << " bord num5 " << finl;
885 num5 = element_number;
886 }
887 // dQij_j(element_number,0)=0.5*((f(num3)*Qij(num3,0,0)-f(num0)*Qij(num0,0,0))/
888 // domaine_VDF.dim_elem(element_number,0));
889 // dQij_j(element_number,0)+=0.5*((f(num4)*Qij(num4,0,1)-f(num1)*Qij(num1,0,1))/
890 // domaine_VDF.dim_elem(element_number,1));
891 // dQij_j(element_number,0)+=0.5*((f(num5)*Qij(num5,0,2)-f(num2)*Qij(num2,0,2))/
892 // domaine_VDF.dim_elem(element_number,2));
893 dQij_j(element_number,0)=0.5*((f(num3)*Qij_1(num3,0)-f(num0)*Qij_1(num0,0))/
894 domaine_VDF.dim_elem(element_number,0));
895 dQij_j(element_number,0)+=0.5*((f(num4)*Qij_2(num4,0)-f(num1)*Qij_2(num1,0))/
896 domaine_VDF.dim_elem(element_number,1));
897 dQij_j(element_number,0)+=0.5*((f(num5)*Qij_3(num5,0)-f(num2)*Qij_3(num2,0))/
898 domaine_VDF.dim_elem(element_number,2));
899
900
901 // dQij_j(element_number,1)=0.5*((f(num3)*Qij(num3,1,0)-f(num0)*Qij(num0,1,0))/
902 // domaine_VDF.dim_elem(element_number,0));
903 // dQij_j(element_number,1)+=0.5*((f(num4)*Qij(num4,1,1)-f(num1)*Qij(num1,1,1))/
904 // domaine_VDF.dim_elem(element_number,1));
905 // dQij_j(element_number,1)+=0.5*((f(num5)*Qij(num5,1,2)-f(num2)*Qij(num2,1,2))/
906 // domaine_VDF.dim_elem(element_number,2));
907 dQij_j(element_number,1)=0.5*((f(num3)*Qij_1(num3,1)-f(num0)*Qij_1(num0,1))/
908 domaine_VDF.dim_elem(element_number,0));
909 dQij_j(element_number,1)+=0.5*((f(num4)*Qij_2(num4,1)-f(num1)*Qij_2(num1,1))/
910 domaine_VDF.dim_elem(element_number,1));
911 dQij_j(element_number,1)+=0.5*((f(num5)*Qij_3(num5,1)-f(num2)*Qij_3(num2,1))/
912 domaine_VDF.dim_elem(element_number,2));
913
914 // dQij_j(element_number,2)=0.5*((f(num3)*Qij(num3,2,0)-f(num0)*Qij(num0,2,0))/
915 // domaine_VDF.dim_elem(element_number,0));
916 // dQij_j(element_number,2)+=0.5*((f(num4)*Qij(num4,2,1)-f(num1)*Qij(num1,2,1))/
917 // domaine_VDF.dim_elem(element_number,1));
918 // dQij_j(element_number,2)+=0.5*((f(num5)*Qij(num5,2,2)-f(num2)*Qij(num2,2,2))/
919 // domaine_VDF.dim_elem(element_number,2));
920 dQij_j(element_number,2)=0.5*((f(num3)*Qij_1(num3,2)-f(num0)*Qij_1(num0,2))/
921 domaine_VDF.dim_elem(element_number,0));
922 dQij_j(element_number,2)+=0.5*((f(num4)*Qij_2(num4,2)-f(num1)*Qij_2(num1,2))/
923 domaine_VDF.dim_elem(element_number,1));
924 dQij_j(element_number,2)+=0.5*((f(num5)*Qij_3(num5,2)-f(num2)*Qij_3(num2,2))/
925 domaine_VDF.dim_elem(element_number,2));
926 }
927 }
928 dQij_j.echange_espace_virtuel();
929 // double min_f=1.e6, max_f=-1.e6;
930 // double min_q=1.e6, max_q=-1.e6;
931 // double min_dq=1.e6, max_dq=-1.e6;
932 // for (element_number=0 ; element_number<nb_elem ; element_number ++)
933 // {
934 // // if (Qij(element_number,0,1)<min_q)
935 // // min_q=Qij(element_number,0,1);
936 // // if (Qij(element_number,0,1)>max_q)
937 // // max_q=Qij(element_number,0,1);
938 // if (f(element_number)<min_f)
939 // min_f=f(element_number);
940 // if (f(element_number)>max_f)
941 // max_f=f(element_number);
942 // if (dQij_j(element_number,0)<min_dq)
943 // min_dq=dQij_j(element_number,0);
944 // if (dQij_j(element_number,0)>max_dq)
945 // max_dq=dQij_j(element_number,0);
946 // }
947 // Cerr << me() << " min/max " << min_f << " " << max_f << " " << min_dq << " " << max_dq << finl;
948 // Cerr << " min/max " << min_f << " " << max_f << " " << min_q << " " << max_q << " " << min_dq << " " << max_dq << finl;
949
950 double inc_s;
951 // Cerr << "Force de volume (gradient de pression moteur) = " << source << finl;
952
953 // Boucle sur les conditions limites pour traiter les faces de bord
954 // Cerr << me() << " cond lims " << finl;
955 for (int n_bord=0; n_bord<domaine_VDF.nb_front_Cl(); n_bord++)
956 {
957
958 // pour chaque Condition Limite on regarde son type
959 // Si face de Dirichlet ou de Symetrie on ne fait rien
960 // Si face de Neumann on calcule la contribution au terme source
961
962 const Cond_lim& la_cl = domaine_Cl_VDF.les_conditions_limites(n_bord);
963
964 if (sub_type(Neumann_sortie_libre,la_cl.valeur()))
965 {
966
967 //const Neumann_sortie_libre& la_cl_neumann = ref_cast(Neumann_sortie_libre,la_cl.valeur());
968 const Front_VF& le_bord = ref_cast(Front_VF,la_cl->frontiere_dis());
969 ndeb = le_bord.num_premiere_face();
970 nfin = ndeb + le_bord.nb_faces();
971
972 for (num_face=ndeb; num_face<nfin; num_face++)
973 {
974 vol = volumes_entrelaces(num_face)*porosite_surf(num_face);
975 ncomp = orientation(num_face);
976 num0 = face_voisins(num_face,0);
977 if (num0 == -1)
978 num0 = face_voisins(num_face,1);
979 inc_s=dQij_j(num0,ncomp)*vol;
980 // resu(num_face)+= s(ncomp)*vol;
981 secmem(num_face)+= inc_s;
982 }
983 }
984
985 else if (sub_type(Symetrie,la_cl.valeur()))
986 { /* Do nothing */}
987 else if ( (sub_type(Dirichlet,la_cl.valeur()))
988 ||
989 (sub_type(Dirichlet_homogene,la_cl.valeur()))
990 )
991 { /* Do nothing */}
992 else if (sub_type(Periodique,la_cl.valeur()))
993 {
994 const Front_VF& le_bord = ref_cast(Front_VF,la_cl->frontiere_dis());
995 ndeb = le_bord.num_premiere_face();
996 nfin = ndeb + le_bord.nb_faces();
997
998 for (num_face=ndeb; num_face<nfin; num_face++)
999 {
1000 vol = volumes_entrelaces(num_face)*porosite_surf(num_face);
1001 ncomp = orientation(num_face);
1002 num0 = face_voisins(num_face,0);
1003 if (num0 == -1)
1004 num0 = face_voisins(num_face,1);
1005 inc_s=dQij_j(num0,ncomp)*vol;
1006 // resu(num_face)+= s(ncomp)*vol;
1007 secmem(num_face)+= inc_s;
1008
1009 }
1010 }
1011 }
1012
1013 // Boucle sur les faces internes
1014 Cerr << me() << " faces internes " << finl;
1015
1016 double min_inc=1.e6, max_inc=-1.e6;
1017 int num_e1=-1, n_comp1=-1;
1018 int num_e2=-1, n_comp2=-1;
1019 ndeb = domaine_VDF.premiere_face_int();
1020 for (num_face =domaine_VDF.premiere_face_int(); num_face<domaine_VDF.nb_faces(); num_face++)
1021 {
1022
1023 vol = volumes_entrelaces(num_face)*porosite_surf(num_face);
1024 ncomp = orientation(num_face);
1025 num0 = face_voisins(num_face,0);
1026 num1 = face_voisins(num_face,1);
1027 inc_s=0.5*(dQij_j(num0,ncomp)+dQij_j(num1,ncomp))*vol;
1028 // resu(num_face)+= s(ncomp)*vol;
1029 secmem(num_face)+= inc_s;
1030 if (inc_s<min_inc)
1031 {
1032 min_inc=inc_s;
1033 num_e1=num0;
1034 n_comp1=ncomp;
1035 }
1036 if (inc_s>max_inc)
1037 {
1038 max_inc=inc_s;
1039 num_e2=num0;
1040 n_comp2=ncomp;
1041 }
1042 }
1043 Cerr << min_inc << " " << num_e1 << " " << n_comp1 << finl;
1044 Cerr << max_inc << " " << num_e2 << " " << n_comp2 << finl;
1045 secmem.echange_espace_virtuel();
1046}
1047
1048DoubleTab& Terme_Source_inc_VDF_Face::calculer(DoubleTab& resu) const
1049{
1050 resu = 0;
1051 ajouter(resu);
1052 resu.echange_espace_virtuel();
1053 return resu;
1054}
1055
1056
Cond_lim
classe Cond_lim Classe generique servant a representer n'importe quelle classe
Definition Cond_lim.h:31
Dirichlet_homogene
Classe Dirichlet_homogene Cette classe est la classe de base de la hierarchie des conditions aux limi...
Definition Dirichlet_homogene.h:31
Dirichlet
classe Dirichlet Cette classe est la classe de base de la hierarchie des conditions aux limites de ty...
Definition Dirichlet.h:31
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::dim_elem
double dim_elem(int, int) const
Definition Domaine_VDF.h:627
Domaine_VDF::orientation
int orientation(int) const override
inline DoubleVect& Domaine_VDF::porosite_face() {
Definition Domaine_VDF.h:297
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::elem_faces
int elem_faces(int i, int j) const
renvoie le numero de le ieme face de la maille num_elem la facon dont ces faces sont numerotees est
Definition Domaine_VF.h:543
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_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
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::porosite_face
DoubleVect & porosite_face()
Definition Milieu_base.h:62
MorEqn::equation
const Equation_base & equation() const
Renvoie la reference sur l'equation pointe par MorEqn::mon_equation.
Definition MorEqn.h:62
Navier_Stokes_std
classe Navier_Stokes_std Cette classe porte les termes de l'equation de la dynamique
Definition Navier_Stokes_std.h:56
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
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
Pb_Fluide_base
classe Pb_Fluide_base Cette classe a pour but de disposer d une classe amont pour
Definition Pb_Fluide_base.h:29
Periodique
classe Periodique Cette classe represente une condition aux limites periodique.
Definition Periodique.h:31
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::me
static int me()
renvoie mon rang dans le groupe de communication courant.
Definition Process.cpp:125
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_base::ajouter
virtual DoubleTab & ajouter(DoubleTab &) const
Definition Source_base.cpp:225
Symetrie
classe Symetrie Sur les faces de symetrie on a les proprietes suivantes:
Definition Symetrie.h:37
TRUSTVect::echange_espace_virtuel
virtual void echange_espace_virtuel(IsExchangeBlocking exchange_type=IsExchangeBlocking::DefaultBlocking, const std::string kernel_name="noname")
Definition TRUSTVect.tpp:282
Terme_Source_inc_VDF_Face
class Terme_Source_inc_VDF_Face Cette classe permet de conserver le debit dans une simulation
Definition Terme_Source_inc_VDF_Face.h:37
Terme_Source_inc_VDF_Face::calculer
DoubleTab & calculer(DoubleTab &) const override
Definition Terme_Source_inc_VDF_Face.cpp:1048
Terme_Source_inc_VDF_Face::associer_domaines
void associer_domaines(const Domaine_dis_base &, const Domaine_Cl_dis_base &) override
Definition Terme_Source_inc_VDF_Face.cpp:63
Terme_Source_inc_VDF_Face::ajouter_blocs
void ajouter_blocs(matrices_t matrices, DoubleTab &secmem, const tabs_t &semi_impl) const override
Definition Terme_Source_inc_VDF_Face.cpp:79
Terme_Source_inc_VDF_Face::associer_pb
void associer_pb(const Probleme_base &) override
Definition Terme_Source_inc_VDF_Face.cpp:48
Terme_Source_inc_base
Definition Terme_Source_inc_base.h:29
Terme_Source_inc_base::associer_eqn
void associer_eqn(const Navier_Stokes_std &eq_hyd)
Definition Terme_Source_inc_base.h:33