TrioCFD 1.9.8
TrioCFD documentation
Loading...
Searching...
No Matches
Op_Diff_VEF_Face_Stab.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 <Op_Diff_VEF_Face_Stab.h>
17#include <Champ_P1NC.h>
18#include <Champ_Q1NC.h>
19
20#include <Periodique.h>
21#include <Symetrie.h>
22#include <Neumann_paroi.h>
23#include <Echange_externe_impose.h>
24#include <Neumann_sortie_libre.h>
25#include <Dirichlet.h>
26#include <Dirichlet_homogene.h>
27#include <Neumann_homogene.h>
28
29
30#include <Milieu_base.h>
31
32#include <TRUSTTrav.h>
33#include <Probleme_base.h>
34#include <Navier_Stokes_std.h>
35#include <Porosites_champ.h>
36
37#include <SFichier.h>
38#include <ArrOfBit.h>
39#include <Schema_Temps_base.h>
40
41Implemente_instanciable_sans_constructeur(Op_Diff_VEF_Face_Stab,"Op_Diff_VEFSTAB_P1NC",Op_Diff_VEF_Face);
42
43double minimum(double a,double b,double c)
44{
45 if (a<=b)
46 if (a<=c) return a;
47 else return c;
48 else if (b<=c) return b;
49 else return c;
50}
51
52double maximum(double a,double b,double c)
53{
54 if (a>=b)
55 if (a>=c) return a;
56 else return c;
57 else if (b>=c) return b;
58 else return c;
59}
60
61double minimum(double a,double b)
62{
63 if (a<=b) return a;
64 else return b;
65}
66
67double maximum(double a,double b)
68{
69 if (a>=b) return a;
70 else return b;
71}
72
77
78Sortie& Op_Diff_VEF_Face_Stab::printOn(Sortie& s ) const
79{
80 return s << que_suis_je() ;
81}
82
83Entree& Op_Diff_VEF_Face_Stab::readOn(Entree& s )
84{
85 Motcle motlu,accouverte="{",accfermee="}";
86 Motcles les_mots(3);
87 {
88 les_mots[0]="standard";
89 les_mots[1]="info";
90 les_mots[2]="new_jacobian";
91 }
92
93 s>>motlu;
94 if (motlu!=accouverte)
95 {
96 Cerr<<"Error in Op_Diff_VEF_Face_Stab::readOn()"<<finl;
97 Cerr<<"Option keywords must be preceded by an open brace"<<finl;
98 Process::exit();
99 }
100
101 s>>motlu;
102 while (motlu!=accfermee)
103 {
104 int rang=les_mots.search(motlu);
105 switch(rang)
106 {
107 case 0 :
108 s>>standard_;
109 break;
110 case 1 :
111 s>>info_;
112 break;
113 case 2 :
114 s>>new_jacobian_;
115 break;
116 default :
117 Cerr<<"Error in Op_Diff_VEF_Face_Stab::readOn()"<<finl;
118 Cerr<<"Word "<<motlu<<" is unknown"<<finl;
119 Cerr<<"Known keywords are : "<<les_mots<<finl;
120 Process::exit();
121 break;
122 }
123 s>>motlu;
124 }
125 return s;
126}
127
128
129DoubleTab& Op_Diff_VEF_Face_Stab::ajouter(const DoubleTab& inconnue_org, DoubleTab& resu) const
130{
131 remplir_nu(nu_);
132 const Domaine_VEF& domaine_VEF = le_dom_vef.valeur();
133
134 const int nb_elem_tot=domaine_VEF.nb_elem_tot();
135 const int nb_faces_elem=domaine_VEF.domaine().nb_faces_elem();
136
137 // soit on a div(phi nu grad inco)
138 // soit on a div(nu grad phi inco)
139 // cela depend si on diffuse phi_psi ou psi
140 DoubleTab nu;
141 DoubleTab tab_inconnue;
142
143 int marq=phi_psi_diffuse(equation());
144
145 const DoubleVect& porosite_face = equation().milieu().porosite_face();
146 const DoubleVect& porosite_elem = equation().milieu().porosite_elem();
147
148 modif_par_porosite_si_flag(nu_,nu,!marq,porosite_elem);
149 const DoubleTab& inconnue=modif_par_porosite_si_flag(inconnue_org,tab_inconnue,marq,porosite_face);
150 //
151 //
152 //
153 DoubleTab resu2(resu);
154 resu2=0.;
155
156 DoubleTab Aij(nb_elem_tot,nb_faces_elem,nb_faces_elem);
157 calculer_coefficients(nu,Aij);
158
159 ajouter_operateur_centre(Aij,inconnue,resu2);
160 if (!standard_)
161 {
162 ajouter_diffusion(Aij,inconnue,resu2);
163 ajouter_antidiffusion(Aij,inconnue,resu2);
164 }
165 modifie_pour_Cl(inconnue,resu2);
166
167 modifier_flux(*this);
168
169 resu-=resu2;//-= car le laplacien est place en terme source dans l'equation
170 return resu;
171}
172
173void Op_Diff_VEF_Face_Stab::modifie_pour_Cl(const DoubleTab& inconnue, DoubleTab& resu) const
174{
175 const Domaine_VEF& domaine_VEF = le_dom_vef.valeur();
176 const Domaine_Cl_VEF& domaine_Cl_VEF = la_zcl_vef.valeur();
177 const Conds_lim& les_cl = domaine_Cl_VEF.les_conditions_limites();
178
179 const DoubleVect& inconnueVect = inconnue;
180 DoubleVect& resuVect = resu;
181
182 const int nb_bords=les_cl.size();
183
184 int nb_comp=1;
185 if(resu.nb_dim()==2) nb_comp=resu.dimension(1);
186
187 DoubleTab& tab_flux_bords = flux_bords_;
188 tab_flux_bords.resize(domaine_VEF.nb_faces_bord(),nb_comp);
189 tab_flux_bords=0.;
190
191 int num1=0, num2=0;
192 int n_bord=0;
193 int face=0;
194 int face_associee=0;
195 int ind_face=0;
196 int dim=0;
197
198 double surface=0.;
199 double flux=0.;
200
201 for (n_bord=0; n_bord<nb_bords; n_bord++)
202 {
203 const Cond_lim& la_cl = domaine_Cl_VEF.les_conditions_limites(n_bord);
204 const Front_VF& le_bord = ref_cast(Front_VF,la_cl->frontiere_dis());
205
206 num1 = 0;
207 num2 = le_bord.nb_faces();
208
209 if (sub_type(Periodique,la_cl.valeur()))
210 {
211 const Periodique& la_cl_perio = ref_cast(Periodique,la_cl.valeur());
212
213 for (ind_face=num1; ind_face<num2; ind_face++)
214 {
215 face=le_bord.num_face(ind_face);
216 face_associee=le_bord.num_face(la_cl_perio.face_associee(ind_face));
217
218 if (face<face_associee)
219 for (dim=0; dim<nb_comp; dim++)
220 {
221 resuVect[face*nb_comp+dim]+=resuVect[face_associee*nb_comp+dim];
222 resuVect[face_associee*nb_comp+dim]=resuVect[face*nb_comp+dim];
223 }
224 }
225 }
226 if (sub_type(Neumann_paroi,la_cl.valeur()))
227 {
228 const Neumann_paroi& la_cl_paroi = ref_cast(Neumann_paroi,la_cl.valeur());
229
230 for (ind_face=num1; ind_face<num2; ind_face++)
231 {
232 face=le_bord.num_face(ind_face);
233 surface=domaine_VEF.surface(face);
234
235 for (dim=0; dim<nb_comp; dim++)
236 {
237 flux=la_cl_paroi.flux_impose(ind_face,dim)*surface;
238 resuVect[face*nb_comp+dim]-=flux;
239 tab_flux_bords(face,dim)=flux;
240 }
241 }
242 }
243 if (sub_type(Echange_externe_impose,la_cl.valeur()))
244 {
245 const Echange_externe_impose& la_cl_paroi = ref_cast(Echange_externe_impose,la_cl.valeur());
246
247 for (ind_face=num1; ind_face<num2; ind_face++)
248 {
249 face=le_bord.num_face(ind_face);
250 surface=domaine_VEF.surface(face);
251
252 for (dim=0; dim<nb_comp; dim++)
253 {
254 flux=la_cl_paroi.h_imp(ind_face,dim)*(la_cl_paroi.T_ext(ind_face,dim)-inconnueVect[face*nb_comp+dim])*surface;
255 resuVect[face*nb_comp+dim]-=flux;
256 tab_flux_bords(face,dim)=flux;
257 }
258 }
259 }
260 if (sub_type(Neumann_homogene,la_cl.valeur())
261 || sub_type(Symetrie,la_cl.valeur())
262 || sub_type(Neumann_sortie_libre,la_cl.valeur()))
263 {
264 for (ind_face=num1; ind_face<num2; ind_face++)
265 {
266 face=le_bord.num_face(ind_face);
267
268 for (dim=0; dim<nb_comp; dim++)
269 tab_flux_bords(face,dim)=0.;
270 }
271 }
272
273 }
274}
275
276void Op_Diff_VEF_Face_Stab::ajouter_operateur_centre(const DoubleTab& Aij, const DoubleTab& inconnueTab, DoubleTab& resuTab) const
277{
278 const Domaine_VEF& domaine_VEF = le_dom_vef.valeur();
279
280 const int nb_elem_tot=domaine_VEF.nb_elem_tot();
281 const int nb_faces_elem=domaine_VEF.domaine().nb_faces_elem();
282
283 int nb_comp=1;
284 if(resuTab.nb_dim()==2) nb_comp=resuTab.dimension(1);
285
286 const DoubleVect& inconnue = inconnueTab;
287 DoubleVect& resu = resuTab;
288
289 int elem=0;
290 int facei_loc=0,facei=0;
291 int facej_loc=0,facej=0;
292 int dim=0;
293
294 double inc_i=0.;
295 double inc_j=0.;
296 double delta_ij=0.;
297
298 const IntTab& elem_faces=domaine_VEF.elem_faces();
299
300 for (elem=0; elem<nb_elem_tot; elem++)
301 for (facei_loc=0; facei_loc<nb_faces_elem; facei_loc++)
302 {
303 facei=elem_faces(elem,facei_loc);
304
305 for (facej_loc=facei_loc+1; facej_loc<nb_faces_elem; facej_loc++)
306 {
307 facej=elem_faces(elem,facej_loc);
308
309 const double aij=Aij(elem,facei_loc,facej_loc);
310
311 for (dim=0; dim<nb_comp; dim++)
312 {
313 inc_i=inconnue[facei*nb_comp+dim];
314 inc_j=inconnue[facej*nb_comp+dim];
315 delta_ij=aij*(inc_j-inc_i);
316
317 resu[facei*nb_comp+dim]+=delta_ij;
318 resu[facej*nb_comp+dim]-=delta_ij;
319 }
320 }
321 }
322}
323
324void Op_Diff_VEF_Face_Stab::ajouter_diffusion(const DoubleTab& Aij, const DoubleTab& inconnueTab, DoubleTab& resuTab) const
325{
326 const Domaine_VEF& domaine_VEF = le_dom_vef.valeur();
327
328 const int nb_elem_tot=domaine_VEF.nb_elem_tot();
329 const int nb_faces_elem=domaine_VEF.domaine().nb_faces_elem();
330
331 int nb_comp=1;
332 if(resuTab.nb_dim()==2) nb_comp=resuTab.dimension(1);
333
334 const DoubleVect& inconnue= inconnueTab;
335 DoubleVect& resu= resuTab;
336
337 int elem=0;
338 int facei_loc=0,facei=0;
339 int facej_loc=0,facej=0;
340 int dim=0;
341
342 double inc_i=0.;
343 double inc_j=0.;
344 double delta_ij=0.;
345 double dij=0.;
346
347 const IntTab& elem_faces=domaine_VEF.elem_faces();
348
349 for (elem=0; elem<nb_elem_tot; elem++)
350 for (facei_loc=0; facei_loc<nb_faces_elem; facei_loc++)
351 {
352 facei=elem_faces(elem,facei_loc);
353
354 for (facej_loc=facei_loc+1; facej_loc<nb_faces_elem; facej_loc++)
355 {
356 facej=elem_faces(elem,facej_loc);
357
358 const double aij=Aij(elem,facei_loc,facej_loc);
359
360 if (aij>0.)
361 {
362 dij=-aij;
363
364 for (dim=0; dim<nb_comp; dim++)
365 {
366 inc_i=inconnue[facei*nb_comp+dim];
367 inc_j=inconnue[facej*nb_comp+dim];
368 delta_ij=dij*(inc_j-inc_i);
369
370 resu[facei*nb_comp+dim]+=delta_ij;
371 resu[facej*nb_comp+dim]-=delta_ij;
372 }
373 }
374 }
375 }
376}
377
378void Op_Diff_VEF_Face_Stab::ajouter_antidiffusion(const DoubleTab& Aij, const DoubleTab& inconnueTab, DoubleTab& resuTab) const
379{
380 const Domaine_VEF& domaine_VEF = le_dom_vef.valeur();
381
382 const int nb_elem_tot=domaine_VEF.nb_elem_tot();
383 const int nb_faces_tot=domaine_VEF.nb_faces_tot();
384 const int nb_faces_elem=domaine_VEF.domaine().nb_faces_elem();
385
386 int nb_comp=1;
387 if(resuTab.nb_dim()==2) nb_comp=resuTab.dimension(1);
388
389 const DoubleVect& inconnue = inconnueTab;
390 DoubleVect& resu = resuTab;
391
392 const DoubleTab& xv=domaine_VEF.xv();
393 DoubleTab rij(Objet_U::dimension);
394 DoubleTab rji(rij);
395
396 int elem=0;
397 int facei_loc=0,facei=0;
398 int facej_loc=0,facej=0;
399 int dim=0;
400 int dim2=0;
401
402 double inc_i=0.;
403 double inc_j=0.;
404 double delta_ij=0.;
405 double delta_imax=0.,delta_imin=0.;
406 double delta_jmax=0.,delta_jmin=0.;
407 double sij=0.;
408 double sij_max=DMINFLOAT;
409 double sij_min=DMAXFLOAT;
410 double muij=0.,muji=0.;
411
412 bool ok_facei=false;
413 bool ok_facej=false;
414
415
416
417 const IntTab& elem_faces=domaine_VEF.elem_faces();
418
419 DoubleTab Minima(nb_faces_tot);
420 DoubleTab Maxima(nb_faces_tot);
421
422
423 for (dim=0; dim<nb_comp; dim++)
424 {
425 calculer_min(inconnueTab,dim,Minima);
426 calculer_max(inconnueTab,dim,Maxima);
427
428 for (elem=0; elem<nb_elem_tot; elem++)
429 for (facei_loc=0; facei_loc<nb_faces_elem; facei_loc++)
430 {
431 facei=elem_faces(elem,facei_loc);
432 ok_facei=is_dirichlet_faces_(facei);
433 inc_i=inconnue[facei*nb_comp+dim];
434
435 delta_imin=Minima(facei)-inc_i;
436 delta_imax=Maxima(facei)-inc_i;
437 assert(delta_imax>=0.);
438 assert(delta_imin<=0.);
439
440 for (facej_loc=facei_loc+1; facej_loc<nb_faces_elem; facej_loc++)
441 {
442 const double aij=Aij(elem,facei_loc,facej_loc);
443
444 if (aij>0.)
445 {
446 facej=elem_faces(elem,facej_loc);
447 ok_facej=is_dirichlet_faces_(facej);
448 inc_j=inconnue[facej*nb_comp+dim];
449
450 for (dim2=0; dim2<Objet_U::dimension; dim2++)
451 rij(dim2)=xv(facej,dim2)-xv(facei,dim2);
452
453 rji=rij;
454 rji*=-1.;
455
456 delta_ij=inc_i-inc_j;
457 delta_jmin=Minima(facej)-inc_j;
458 delta_jmax=Maxima(facej)-inc_j;
459 assert(delta_jmax>=0.);
460 assert(delta_jmin<=0.);
461
462 muij=calculer_gradients(facei,rij);
463 muji=calculer_gradients(facej,rji);
464
465 sij=0.; //reste a 0 si que des faces de Dirichlet
466 if (delta_ij>0.)
467 {
468 muij*=delta_imax;
469 muji*=-delta_jmin;
470
471 if (!ok_facei && !ok_facej) //pas de face de Dirichlet
472 sij=minimum(muij,delta_ij,muji);
473 if (!ok_facei && ok_facej) //facej Dirichlet et pas facei
474 sij=minimum(muij,delta_ij);
475 if (ok_facei && !ok_facej) //facei Dirichlet et pas facej
476 sij=minimum(delta_ij,muji);
477 }
478 else if (delta_ij<0.)
479 {
480 muij*=delta_imin;
481 muji*=-delta_jmax;
482
483 if (!ok_facei && !ok_facej) //pas de face de Dirichlet
484 sij=maximum(muij,delta_ij,muji);
485 if (!ok_facei && ok_facej) //facej Dirichlet et pas facei
486 sij=maximum(muij,delta_ij);
487 if (ok_facei && !ok_facej) //facei Dirichlet et pas facej
488 sij=maximum(delta_ij,muji);
489 }
490
491 if (info_)
492 if (delta_ij!=0.)
493 {
494 double tmp=sij/delta_ij;
495 if (tmp>sij_max) sij_max=tmp;
496 if (tmp<sij_min) sij_min=tmp;
497 }
498
499 resu[facei*nb_comp+dim]-=aij*sij;
500 resu[facej*nb_comp+dim]+=aij*sij;
501
502 }
503 }
504 }
505 }
506
507 {
508 sij_max = Process::mp_max(sij_max);
509 sij_min = Process::mp_min(sij_min);
510 if (info_ && Process::je_suis_maitre())
511 {
512 SFichier mem_fichier("sij_memory.txt");
513 mem_fichier<<sij_max<<" "<<sij_min<<finl;
514 }
515 }
516}
517
518void Op_Diff_VEF_Face_Stab::calculer_coefficients(const DoubleTab& nu, DoubleTab& Aij) const
519{
520 const Domaine_VEF& domaine_VEF = le_dom_vef.valeur();
521
522 const int nb_elem_tot=domaine_VEF.nb_elem_tot();
523 const int nb_faces_elem=domaine_VEF.domaine().nb_faces_elem();
524
525 const IntTab& elem_faces=domaine_VEF.elem_faces();
526 const IntTab& face_voisins=domaine_VEF.face_voisins();
527
528 const DoubleTab& face_normales=domaine_VEF.face_normales();
529 const DoubleVect& volumes=domaine_VEF.volumes();
530
531 double volume=0.;
532 double signei=0.;
533 double signej=0.;
534 double psc=0.;
535 double nu_elem=0.;
536
537 int elem=0;
538 int facei_loc=0,facei=0;
539 int facej_loc=0,facej=0;
540 int dim=0;
541
542 assert(Aij.nb_dim()==3);
543 assert(Aij.dimension(0)==nb_elem_tot);
544 assert(Aij.dimension(1)==nb_faces_elem);
545 assert(Aij.dimension(2)==nb_faces_elem);
546
547 for (elem=0; elem<nb_elem_tot; elem++)
548 {
549 nu_elem=nu(elem);
550 volume=1./volumes(elem);
551 volume*=nu_elem;
552
553 for (facei_loc=0; facei_loc<nb_faces_elem; facei_loc++)
554 {
555 facei=elem_faces(elem,facei_loc);
556
557 signei=1.;
558 if (face_voisins(facei,0)!=elem) signei=-1.;
559
560 for (facej_loc=facei_loc+1; facej_loc<nb_faces_elem; facej_loc++)
561 {
562 facej=elem_faces(elem,facej_loc);
563
564 signej=1.;
565 if (face_voisins(facej,0)!=elem) signej=-1.;
566
567 psc=0.;
568 for (dim=0; dim<Objet_U::dimension; dim++)
569 psc+=face_normales(facei,dim)*face_normales(facej,dim);
570 psc*=signei*signej;
571 psc*=volume;
572
573 Aij(elem,facei_loc,facej_loc)=psc;
574 Aij(elem,facej_loc,facei_loc)=psc;
575 }
576 }
577 }
578}
579
580double Op_Diff_VEF_Face_Stab::calculer_gradients(int facei, const DoubleTab& rij) const
581{
582 const Domaine_VEF& domaine_VEF = le_dom_vef.valeur();
583
584 const int nb_faces_elem=domaine_VEF.domaine().nb_faces_elem();
585
586 const IntTab& elem_faces=domaine_VEF.elem_faces();
587 const IntTab& face_voisins=domaine_VEF.face_voisins();
588 const IntTab& get_num_fac_loc=domaine_VEF.get_num_fac_loc();
589
590 const DoubleTab& face_normales=domaine_VEF.face_normales();
591 const DoubleVect& volumes=domaine_VEF.volumes();
592
593 double volume=0.;
594 double signek=0.;
595 double psc=0.;
596
597 int elem=0;
598 int elem_loc=0;
599 int facei_loc=0;
600 int facek_loc=0,facek=0;
601 int dim=0;
602
603 double mu_ij=0.;
604 for (elem_loc=0; elem_loc<2; elem_loc++)
605 {
606 facei_loc=get_num_fac_loc(facei,elem_loc);
607 elem=face_voisins(facei,elem_loc);
608
609 if (elem!=-1)
610 {
611 volume+=volumes(elem);
612
613 for (facek_loc=0; facek_loc<nb_faces_elem; facek_loc++)
614 if (facek_loc!=facei_loc)
615 {
616 facek=elem_faces(elem,facek_loc);
617
618 signek=1.;
619 if (face_voisins(facek,0)!=elem) signek=-1.;
620
621 psc=0.;
622 for (dim=0; dim<Objet_U::dimension; dim++)
623 psc+=face_normales(facek,dim)*rij(dim);
624 psc*=signek;
625 if (psc<0.) psc*=-1.;
626
627 mu_ij+=psc;
628 }
629 }
630 }
631
632 mu_ij/=volume;
633 mu_ij*=2.;
634 return mu_ij;
635}
636
637void Op_Diff_VEF_Face_Stab::calculer_min(const DoubleTab& inconnueTab, int& dim, DoubleTab& Minima) const
638{
639 const Domaine_VEF& domaine_VEF = le_dom_vef.valeur();
640
641 const int nb_elem_tot=domaine_VEF.nb_elem_tot();
642 const int nb_faces_elem=domaine_VEF.domaine().nb_faces_elem();
643 const int nb_faces_tot=domaine_VEF.nb_faces_tot();
644
645 const IntTab& elem_faces=domaine_VEF.elem_faces();
646
647 int elem=0;
648 int facei_loc=0,facei=0;
649 int facej_loc=0,facej=0;
650
651 int nb_comp = 1;
652 if(inconnueTab.nb_dim()==2) nb_comp=inconnueTab.dimension(1);
653
654 double inc_i=0.;
655 double inc_j=0.;
656
657 const DoubleVect& inconnue= inconnueTab;
658
659 assert(Minima.nb_dim()==1);
660 assert(Minima.dimension(0)==nb_faces_tot);
661 assert(dim<nb_comp);
662
663 for (facei=0; facei<nb_faces_tot; facei++)
664 Minima(facei)=inconnue[facei*nb_comp+dim];
665
666 for (elem=0; elem<nb_elem_tot; elem++)
667 for (facei_loc=0; facei_loc<nb_faces_elem; facei_loc++)
668 {
669 facei=elem_faces(elem,facei_loc);
670
671 inc_i=inconnue[facei*nb_comp+dim];
672 double& mini=Minima(facei);
673
674 for (facej_loc=facei_loc+1; facej_loc<nb_faces_elem; facej_loc++)
675 {
676 facej=elem_faces(elem,facej_loc);
677
678 inc_j=inconnue[facej*nb_comp+dim];
679 double& minj=Minima(facej);
680
681 if (inc_j<mini) mini=inc_j;
682 if (inc_i<minj) minj=inc_i;
683 }
684 }
685
686 const Domaine_Cl_VEF& domaine_Cl_VEF = la_zcl_vef.valeur();
687 const Conds_lim& les_cl = domaine_Cl_VEF.les_conditions_limites();
688
689 const int nb_bords=les_cl.size();
690
691 int num1=0, num2=0;
692 int n_bord=0;
693 int ind_face=0;
694
695 for (n_bord=0; n_bord<nb_bords; n_bord++)
696 {
697 const Cond_lim& la_cl = domaine_Cl_VEF.les_conditions_limites(n_bord);
698 const Front_VF& le_bord = ref_cast(Front_VF,la_cl->frontiere_dis());
699
700 num1 = 0;
701 num2 = le_bord.nb_faces_tot();
702
703 if (sub_type(Periodique,la_cl.valeur()))
704 {
705 const Periodique& la_cl_perio = ref_cast(Periodique,la_cl.valeur());
706
707 for (ind_face=num1; ind_face<num2; ind_face++)
708 {
709 facei=le_bord.num_face(ind_face);
710 facej=le_bord.num_face(la_cl_perio.face_associee(ind_face));
711
712 if (facei<facej)
713 {
714 double& mini=Minima(facei);
715 double& minj=Minima(facej);
716
717 if (mini<minj) minj=mini;
718 if (minj<mini) mini=minj;
719 }
720 }
721 }
722 }
723}
724
725void Op_Diff_VEF_Face_Stab::calculer_max(const DoubleTab& inconnueTab, int& dim, DoubleTab& Maxima) const
726{
727 const Domaine_VEF& domaine_VEF = le_dom_vef.valeur();
728
729 const int nb_elem_tot=domaine_VEF.nb_elem_tot();
730 const int nb_faces_elem=domaine_VEF.domaine().nb_faces_elem();
731 const int nb_faces_tot=domaine_VEF.nb_faces_tot();
732
733 const IntTab& elem_faces=domaine_VEF.elem_faces();
734
735 int elem=0;
736 int facei_loc=0,facei=0;
737 int facej_loc=0,facej=0;
738
739 int nb_comp = 1;
740 if(inconnueTab.nb_dim()==2) nb_comp=inconnueTab.dimension(1);
741
742 double inc_i=0.;
743 double inc_j=0.;
744
745 const DoubleVect& inconnue = inconnueTab;
746
747 assert(Maxima.nb_dim()==1);
748 assert(Maxima.dimension(0)==nb_faces_tot);
749 assert(dim<nb_comp);
750
751 for (facei=0; facei<nb_faces_tot; facei++)
752 Maxima(facei)=inconnue[facei*nb_comp+dim];
753
754 for (elem=0; elem<nb_elem_tot; elem++)
755 for (facei_loc=0; facei_loc<nb_faces_elem; facei_loc++)
756 {
757 facei=elem_faces(elem,facei_loc);
758
759 inc_i=inconnue[facei*nb_comp+dim];
760 double& maxi=Maxima(facei);
761
762 for (facej_loc=facei_loc+1; facej_loc<nb_faces_elem; facej_loc++)
763 {
764 facej=elem_faces(elem,facej_loc);
765
766 inc_j=inconnue[facej*nb_comp+dim];
767 double& maxj=Maxima(facej);
768
769 if (inc_j>maxi) maxi=inc_j;
770 if (inc_i>maxj) maxj=inc_i;
771 }
772 }
773
774 const Domaine_Cl_VEF& domaine_Cl_VEF = la_zcl_vef.valeur();
775 const Conds_lim& les_cl = domaine_Cl_VEF.les_conditions_limites();
776
777 const int nb_bords=les_cl.size();
778
779 int num1=0, num2=0;
780 int n_bord=0;
781 int ind_face=0;
782
783 for (n_bord=0; n_bord<nb_bords; n_bord++)
784 {
785 const Cond_lim& la_cl = domaine_Cl_VEF.les_conditions_limites(n_bord);
786 const Front_VF& le_bord = ref_cast(Front_VF,la_cl->frontiere_dis());
787
788 num1 = 0;
789 num2 = le_bord.nb_faces_tot();
790
791 if (sub_type(Periodique,la_cl.valeur()))
792 {
793 const Periodique& la_cl_perio = ref_cast(Periodique,la_cl.valeur());
794
795 for (ind_face=num1; ind_face<num2; ind_face++)
796 {
797 facei=le_bord.num_face(ind_face);
798 facej=le_bord.num_face(la_cl_perio.face_associee(ind_face));
799
800 if (facei<facej)
801 {
802 double& maxi=Maxima(facei);
803 double& maxj=Maxima(facej);
804
805 if (maxi>maxj) maxj=maxi;
806 if (maxj>maxi) maxi=maxj;
807 }
808 }
809 }
810
811 }
812}
813
814void Op_Diff_VEF_Face_Stab::completer()
815{
816 Op_Diff_VEF_Face::completer();
817
818 {
819 const Domaine_VEF& domaine_VEF=le_dom_vef.valeur();
820 const Domaine_Cl_VEF& domaine_Cl_VEF=la_zcl_vef.valeur();
821
822 const Conds_lim& les_cl=domaine_Cl_VEF.les_conditions_limites();
823
824 const int nb_bord=les_cl.size();
825 const int nb_faces_tot=domaine_VEF.nb_faces_tot();
826
827 int ind_face=-1;
828
829 is_dirichlet_faces_.resize(nb_faces_tot);
830 is_dirichlet_faces_=0;
831
832 for (int n_bord=0; n_bord<nb_bord; n_bord++)
833 {
834 const Cond_lim& la_cl = domaine_Cl_VEF.les_conditions_limites(n_bord);
835 const Front_VF& le_bord = ref_cast(Front_VF,la_cl->frontiere_dis());
836 int nb_faces_bord_tot=le_bord.nb_faces_tot();
837 int face=-1;
838
839 if ( (sub_type(Dirichlet,la_cl.valeur()))
840 || (sub_type(Dirichlet_homogene,la_cl.valeur()))
841 )
842 for (ind_face=0; ind_face<nb_faces_bord_tot; ind_face++)
843 {
844 face = le_bord.num_face(ind_face);
845 is_dirichlet_faces_(face)=1;
846 }
847 }
848 }
849}
850
851void Op_Diff_VEF_Face_Stab::ajouter_contribution(const DoubleTab& transporte, Matrice_Morse& matrice) const
852{
853 if (!new_jacobian_)
854 Op_Diff_VEF_Face::ajouter_contribution(transporte,matrice);
855 else
856 {
857 modifier_matrice_pour_periodique_avant_contribuer(matrice,equation());
858 // On remplit le tableau nu car l'assemblage d'une
859 // matrice avec ajouter_contribution peut se faire
860 // avant le premier pas de temps
861 remplir_nu(nu_);
862 const Domaine_Cl_VEF& domaine_Cl_VEF = la_zcl_vef.valeur();
863 const Domaine_VEF& domaine_VEF = le_dom_vef.valeur();
864 const IntTab& elem_faces = domaine_VEF.elem_faces();
865 const IntTab& face_voisins = domaine_VEF.face_voisins();
866
867 int n1 = domaine_VEF.nb_faces();
868 int nb_comp = 1;
869 int nb_dim = transporte.nb_dim();
870
871 DoubleTab nu;
872 int marq=phi_psi_diffuse(equation());
873 const DoubleVect& porosite_elem = equation().milieu().porosite_elem();
874
875 // soit on a div(phi nu grad inco)
876 // soit on a div(nu grad phi inco)
877 // cela depend si on diffuse phi_psi ou psi
878 modif_par_porosite_si_flag(nu_,nu,!marq,porosite_elem);
879 DoubleVect porosite_eventuelle(equation().milieu().porosite_face());
880 if (!marq)
881 porosite_eventuelle=1;
882
883
884 if(nb_dim==2)
885 nb_comp=transporte.dimension(1);
886
887 int i,j,num_face;
888 int elem1,elem2;
889 int nb_faces_elem = domaine_VEF.domaine().nb_faces_elem();
890 double val;
891
892 int nb_bords=domaine_VEF.nb_front_Cl();
893 for (int n_bord=0; n_bord<nb_bords; n_bord++)
894 {
895 const Cond_lim& la_cl = domaine_Cl_VEF.les_conditions_limites(n_bord);
896 const Front_VF& le_bord = ref_cast(Front_VF,la_cl->frontiere_dis());
897 int num1 = le_bord.num_premiere_face();
898 int num2 = num1 + le_bord.nb_faces();
899
900 if (sub_type(Periodique,la_cl.valeur()))
901 {
902 const Periodique& la_cl_perio = ref_cast(Periodique,la_cl.valeur());
903 int fac_asso;
904 // on ne parcourt que la moitie des faces periodiques
905 // on copiera a la fin le resultat dans la face associe..
906 int num2b=num1+le_bord.nb_faces()/2;
907 for (num_face=num1; num_face<num2b; num_face++)
908 {
909 elem1 = face_voisins(num_face,0);
910 elem2 = face_voisins(num_face,1);
911 fac_asso = la_cl_perio.face_associee(num_face-num1)+num1;
912 for (i=0; i<nb_faces_elem; i++)
913 {
914 if ( (j=elem_faces(elem1,i)) > num_face )
915 {
916 val = viscA(num_face,j,elem1,nu(elem1));
917 if (val<0.) val=0.;
918 for (int nc=0; nc<nb_comp; nc++)
919 {
920 int n0=num_face*nb_comp+nc;
921 int j0=j*nb_comp+nc;
922
923 matrice(n0,n0)+=val*porosite_eventuelle(num_face);
924 matrice(n0,j0)-=val*porosite_eventuelle(j);
925 matrice(j0,n0)-=val*porosite_eventuelle(num_face);
926 matrice(j0,j0)+=val*porosite_eventuelle(j);
927
928 }
929 }
930 if (elem2!=-1)
931 if ( (j=elem_faces(elem2,i)) > num_face )
932 {
933 val= viscA(num_face,j,elem2,nu(elem2));
934 if (val<0.) val=0.;
935 for (int nc=0; nc<nb_comp; nc++)
936 {
937 int n0=num_face*nb_comp+nc;
938 int j0=j*nb_comp+nc;
939 int n0perio=fac_asso*nb_comp+nc;
940 matrice(n0,n0)+=val*porosite_eventuelle(num_face);
941 matrice(n0,j0)-=val*porosite_eventuelle(j);
942 matrice(j0,n0perio)-=val*porosite_eventuelle(num_face);
943 matrice(j0,j0)+=val*porosite_eventuelle(j);
944
945 }
946 }
947 }
948 }
949
950 }
951 else
952 {
953 for (num_face=num1; num_face<num2; num_face++)
954 {
955 elem1 = face_voisins(num_face,0);
956 for (i=0; i<nb_faces_elem; i++)
957 {
958 if ( (j= elem_faces(elem1,i)) > num_face )
959 {
960 val = viscA(num_face,j,elem1,nu(elem1));
961 if (val<0.) val=0.;
962 for (int nc=0; nc<nb_comp; nc++)
963 {
964 int n0=num_face*nb_comp+nc;
965 int j0=j*nb_comp+nc;
966
967 matrice(n0,n0)+=val*porosite_eventuelle(num_face);
968 matrice(n0,j0)-=val*porosite_eventuelle(j);
969 matrice(j0,n0)-=val*porosite_eventuelle(num_face);
970 matrice(j0,j0)+=val*porosite_eventuelle(j);
971
972 }
973 }
974 }
975 }
976 }
977 }
978 int num_premiere_face = domaine_VEF.premiere_face_int();
979 for (num_face=num_premiere_face; num_face<n1; num_face++)
980 {
981 elem1 = face_voisins(num_face,0);
982 elem2 = face_voisins(num_face,1);
983
984 for (i=0; i<nb_faces_elem; i++)
985 {
986 if ( (j=elem_faces(elem1,i)) > num_face )
987 {
988 val = viscA(num_face,j,elem1,nu(elem1));
989 if (val<0.) val=0.;
990 for (int nc=0; nc<nb_comp; nc++)
991 {
992 int n0=num_face*nb_comp+nc;
993 int j0=j*nb_comp+nc;
994
995 matrice(n0,n0)+=val*porosite_eventuelle(num_face);
996 matrice(n0,j0)-=val*porosite_eventuelle(j);
997 matrice(j0,n0)-=val*porosite_eventuelle(num_face);
998 matrice(j0,j0)+=val*porosite_eventuelle(j);
999
1000 }
1001 }
1002 if (elem2!=-1)
1003 if ( (j=elem_faces(elem2,i)) > num_face )
1004 {
1005 val= viscA(num_face,j,elem2,nu(elem2));
1006 if (val<0.) val=0.;
1007 for (int nc=0; nc<nb_comp; nc++)
1008 {
1009 int n0=num_face*nb_comp+nc;
1010 int j0=j*nb_comp+nc;
1011
1012 matrice(n0,n0)+=val*porosite_eventuelle(num_face);
1013 matrice(n0,j0)-=val*porosite_eventuelle(j);
1014 matrice(j0,n0)-=val*porosite_eventuelle(num_face);
1015 matrice(j0,j0)+=val*porosite_eventuelle(j);
1016
1017 }
1018 }
1019 }
1020 }
1021 modifier_matrice_pour_periodique_apres_contribuer(matrice,equation());
1022 }
1023}
1024void Op_Diff_VEF_Face_Stab::ajouter_contribution_multi_scalaire(const DoubleTab& transporte, Matrice_Morse& matrice) const
1025{
1026 if (!new_jacobian_)
1027 Op_Diff_VEF_Face::ajouter_contribution_multi_scalaire(transporte,matrice);
1028 else
1029 {
1030 modifier_matrice_pour_periodique_avant_contribuer(matrice,equation());
1031 // On remplit le tableau nu car l'assemblage d'une
1032 // matrice avec ajouter_contribution peut se faire
1033 // avant le premier pas de temps
1034 remplir_nu(nu_);
1035 const Domaine_Cl_VEF& domaine_Cl_VEF = la_zcl_vef.valeur();
1036 const Domaine_VEF& domaine_VEF = le_dom_vef.valeur();
1037 const IntTab& elem_faces = domaine_VEF.elem_faces();
1038 const IntTab& face_voisins = domaine_VEF.face_voisins();
1039
1040 int n1 = domaine_VEF.nb_faces();
1041 int nb_comp = 1;
1042 int nb_dim = transporte.nb_dim();
1043
1044 DoubleTab nu;
1045 int marq=phi_psi_diffuse(equation());
1046 const DoubleVect& porosite_elem = equation().milieu().porosite_elem();
1047
1048 // soit on a div(phi nu grad inco)
1049 // soit on a div(nu grad phi inco)
1050 // cela depend si on diffuse phi_psi ou psi
1051 modif_par_porosite_si_flag(nu_,nu,!marq,porosite_elem);
1052 DoubleVect porosite_eventuelle(equation().milieu().porosite_face());
1053 if (!marq)
1054 porosite_eventuelle=1;
1055
1056
1057 if(nb_dim==2)
1058 nb_comp=transporte.dimension(1);
1059
1060 int i,j,num_face;
1061 int elem1,elem2;
1062 int nb_faces_elem = domaine_VEF.domaine().nb_faces_elem();
1063 double val;
1064
1065 int nb_bords=domaine_VEF.nb_front_Cl();
1066 for (int n_bord=0; n_bord<nb_bords; n_bord++)
1067 {
1068 const Cond_lim& la_cl = domaine_Cl_VEF.les_conditions_limites(n_bord);
1069 const Front_VF& le_bord = ref_cast(Front_VF,la_cl->frontiere_dis());
1070 int num1 = le_bord.num_premiere_face();
1071 int num2 = num1 + le_bord.nb_faces();
1072 if (sub_type(Periodique,la_cl.valeur()))
1073 {
1074 const Periodique& la_cl_perio = ref_cast(Periodique,la_cl.valeur());
1075 int fac_asso;
1076 // on ne parcourt que la moitie des faces periodiques
1077 // on copiera a la fin le resultat dans la face associe..
1078 int num2b=num1+le_bord.nb_faces()/2;
1079 for (num_face=num1; num_face<num2b; num_face++)
1080 {
1081 elem1 = face_voisins(num_face,0);
1082 elem2 = face_voisins(num_face,1);
1083 fac_asso = la_cl_perio.face_associee(num_face-num1)+num1;
1084 for (i=0; i<nb_faces_elem; i++)
1085 {
1086 if ( (j=elem_faces(elem1,i)) > num_face )
1087 {
1088 for (int nc=0; nc<nb_comp; nc++)
1089 {
1090 val = viscA(num_face,j,elem1,nu(elem1,nc));
1091 if (val<0.) val=0.;
1092
1093 int n0=num_face*nb_comp+nc;
1094 int j0=j*nb_comp+nc;
1095
1096 matrice(n0,n0)+=val*porosite_eventuelle(num_face);
1097 matrice(n0,j0)-=val*porosite_eventuelle(j);
1098 matrice(j0,n0)-=val*porosite_eventuelle(num_face);
1099 matrice(j0,j0)+=val*porosite_eventuelle(j);
1100
1101 }
1102 }
1103 if (elem2!=-1)
1104 if ( (j=elem_faces(elem2,i)) > num_face )
1105 {
1106 for (int nc=0; nc<nb_comp; nc++)
1107 {
1108 val = viscA(num_face,j,elem2,nu(elem1,nc));
1109 if (val<0.) val=0.;
1110 int n0=num_face*nb_comp+nc;
1111 int j0=j*nb_comp+nc;
1112 int n0perio=fac_asso*nb_comp+nc;
1113 matrice(n0,n0)+=val*porosite_eventuelle(num_face);
1114 matrice(n0,j0)-=val*porosite_eventuelle(j);
1115 matrice(j0,n0perio)-=val*porosite_eventuelle(num_face);
1116 matrice(j0,j0)+=val*porosite_eventuelle(j);
1117
1118 }
1119 }
1120 }
1121 }
1122
1123 }
1124 else
1125 {
1126 for (num_face=num1; num_face<num2; num_face++)
1127 {
1128 elem1 = face_voisins(num_face,0);
1129 for (i=0; i<nb_faces_elem; i++)
1130 {
1131 if ( (j= elem_faces(elem1,i)) > num_face )
1132 {
1133 for (int nc=0; nc<nb_comp; nc++)
1134 {
1135 val = viscA(num_face,j,elem1,nu(elem1,nc));
1136 if (val<0.) val=0.;
1137 int n0=num_face*nb_comp+nc;
1138 int j0=j*nb_comp+nc;
1139
1140 matrice(n0,n0)+=val*porosite_eventuelle(num_face);
1141 matrice(n0,j0)-=val*porosite_eventuelle(j);
1142 matrice(j0,n0)-=val*porosite_eventuelle(num_face);
1143 matrice(j0,j0)+=val*porosite_eventuelle(j);
1144
1145 }
1146 }
1147 }
1148 }
1149 }
1150 }
1151 for (num_face=domaine_VEF.premiere_face_int(); num_face<n1; num_face++)
1152 {
1153 elem1 = face_voisins(num_face,0);
1154 elem2 = face_voisins(num_face,1);
1155
1156 for (i=0; i<nb_faces_elem; i++)
1157 {
1158 if ( (j=elem_faces(elem1,i)) > num_face )
1159 {
1160 for (int nc=0; nc<nb_comp; nc++)
1161 {
1162 val = viscA(num_face,j,elem1,nu(elem1,nc));
1163 if (val<0.) val=0.;
1164 int n0=num_face*nb_comp+nc;
1165 int j0=j*nb_comp+nc;
1166
1167 matrice(n0,n0)+=val*porosite_eventuelle(num_face);
1168 matrice(n0,j0)-=val*porosite_eventuelle(j);
1169 matrice(j0,n0)-=val*porosite_eventuelle(num_face);
1170 matrice(j0,j0)+=val*porosite_eventuelle(j);
1171
1172 }
1173 }
1174 if (elem2!=-1)
1175 if ( (j=elem_faces(elem2,i)) > num_face )
1176 {
1177 for (int nc=0; nc<nb_comp; nc++)
1178 {
1179 val= viscA(num_face,j,elem2,nu(elem2,nc));
1180 if (val<0.) val=0.;
1181 int n0=num_face*nb_comp+nc;
1182 int j0=j*nb_comp+nc;
1183
1184 matrice(n0,n0)+=val*porosite_eventuelle(num_face);
1185 matrice(n0,j0)-=val*porosite_eventuelle(j);
1186 matrice(j0,n0)-=val*porosite_eventuelle(num_face);
1187 matrice(j0,j0)+=val*porosite_eventuelle(j);
1188
1189 }
1190 }
1191 }
1192 }
1193 modifier_matrice_pour_periodique_apres_contribuer(matrice,equation());
1194 }
1195}
Cond_lim
classe Cond_lim Classe generique servant a representer n'importe quelle classe
Definition Cond_lim.h:31
Conds_lim
classe Conds_lim Cette classe represente un vecteur de conditions aux limites.
Definition Conds_lim.h:32
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_32_64::nb_faces_elem
int nb_faces_elem(int=0) const
Renvoie le nombre de face de type i des elements geometriques constituants le domaine.
Definition Domaine.h:484
Domaine_Cl_VEF
Definition Domaine_Cl_VEF.h:40
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_VEF
class Domaine_VEF
Definition Domaine_VEF.h:54
Domaine_VF::nb_faces
int nb_faces() const
renvoie le nombre global de faces.
Definition Domaine_VF.h:471
Domaine_VF::nb_faces_tot
int nb_faces_tot() const
renvoie le nombre total de faces.
Definition Domaine_VF.h:481
Domaine_VF::face_normales
virtual double face_normales(int face, int comp) const
Definition Domaine_VF.h:47
Domaine_VF::xv
double xv(int num_face, int k) const
Definition Domaine_VF.h:76
Domaine_VF::volumes
double volumes(int i) const
Definition Domaine_VF.h:113
Domaine_VF::get_num_fac_loc
const IntTab & get_num_fac_loc() const
Definition Domaine_VF.h:140
Domaine_VF::surface
virtual double surface(int i) const
Definition Domaine_VF.h:53
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_VF::nb_faces_bord
int nb_faces_bord() const
renvoie le nombre de faces sur lesquelles sont appliquees les conditions limites :
Definition Domaine_VF.h:513
Domaine_dis_base::nb_elem_tot
int nb_elem_tot() const
Definition Domaine_dis_base.h:50
Domaine_dis_base::nb_front_Cl
int nb_front_Cl() const
Definition Domaine_dis_base.h:53
Domaine_dis_base::domaine
const Domaine & domaine() const
Definition Domaine_dis_base.h:46
Echange_externe_impose
Classe Echange_externe_impose: Cette classe represente le cas particulier de la classe.
Definition Echange_externe_impose.h:46
Echange_impose_base::h_imp
virtual double h_imp(int num) const
Renvoie la valeur du coefficient d'echange de chaleur impose sur la i-eme composante.
Definition Echange_impose_base.cpp:112
Echange_impose_base::T_ext
virtual double T_ext(int num) const
Renvoie la valeur de la temperature imposee sur la i-eme composante du champ de frontiere.
Definition Echange_impose_base.cpp:76
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
Front_VF::nb_faces_tot
int nb_faces_tot() const
Definition Front_VF.h:58
Front_VF::num_face
int num_face(const int) const
Definition Front_VF.h:68
Matrice_Morse
Classe Matrice_Morse Represente une matrice M (creuse), non necessairement carree.
Definition Matrice_Morse.h:50
Milieu_base::porosite_elem
DoubleVect & porosite_elem()
Definition Milieu_base.h:58
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
Neumann_homogene
Classe Neumann_homogene Cette classe est la classe de base de la hierarchie des conditions aux limite...
Definition Neumann_homogene.h:31
Neumann_paroi
Classe Neumann_paroi Cette condition limite correspond a un flux impose pour l'equation de.
Definition Neumann_paroi.h:29
Neumann_sortie_libre
classe Neumann_sortie_libre Cette classe represente une frontiere ouverte sans vitesse imposee
Definition Neumann_sortie_libre.h:34
Neumann::flux_impose
virtual double flux_impose(int i) const
Renvoie la valeur du flux impose sur la i-eme composante du champ representant le flux a la frontiere...
Definition Neumann.cpp:35
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
Op_Diff_VEF_Face_Stab
class Op_Diff_VEF_Face_Stab Cette classe represente l'operateur de diffusion
Definition Op_Diff_VEF_Face_Stab.h:29
Op_Diff_VEF_Face_Stab::ajouter_contribution
void ajouter_contribution(const DoubleTab &, Matrice_Morse &) const
Definition Op_Diff_VEF_Face_Stab.cpp:851
Op_Diff_VEF_Face_Stab::calculer_min
void calculer_min(const DoubleTab &, int &, DoubleTab &) const
Definition Op_Diff_VEF_Face_Stab.cpp:637
Op_Diff_VEF_Face_Stab::ajouter_antidiffusion
void ajouter_antidiffusion(const DoubleTab &, const DoubleTab &, DoubleTab &) const
Definition Op_Diff_VEF_Face_Stab.cpp:378
Op_Diff_VEF_Face_Stab::modifie_pour_Cl
void modifie_pour_Cl(const DoubleTab &, DoubleTab &) const
Definition Op_Diff_VEF_Face_Stab.cpp:173
Op_Diff_VEF_Face_Stab::ajouter
DoubleTab & ajouter(const DoubleTab &, DoubleTab &) const override
Definition Op_Diff_VEF_Face_Stab.cpp:129
Op_Diff_VEF_Face_Stab::ajouter_diffusion
void ajouter_diffusion(const DoubleTab &, const DoubleTab &, DoubleTab &) const
Definition Op_Diff_VEF_Face_Stab.cpp:324
Op_Diff_VEF_Face_Stab::calculer_max
void calculer_max(const DoubleTab &, int &, DoubleTab &) const
Definition Op_Diff_VEF_Face_Stab.cpp:725
Op_Diff_VEF_Face_Stab::Op_Diff_VEF_Face_Stab
Op_Diff_VEF_Face_Stab()
Definition Op_Diff_VEF_Face_Stab.cpp:73
Op_Diff_VEF_Face_Stab::calculer_coefficients
void calculer_coefficients(const DoubleTab &, DoubleTab &) const
Definition Op_Diff_VEF_Face_Stab.cpp:518
Op_Diff_VEF_Face_Stab::calculer_gradients
double calculer_gradients(int, const DoubleTab &) const
Definition Op_Diff_VEF_Face_Stab.cpp:580
Op_Diff_VEF_Face_Stab::ajouter_contribution_multi_scalaire
void ajouter_contribution_multi_scalaire(const DoubleTab &, Matrice_Morse &) const
Definition Op_Diff_VEF_Face_Stab.cpp:1024
Op_Diff_VEF_Face_Stab::ajouter_operateur_centre
void ajouter_operateur_centre(const DoubleTab &, const DoubleTab &, DoubleTab &) const
Definition Op_Diff_VEF_Face_Stab.cpp:276
Op_Diff_VEF_Face_Stab::completer
void completer() override
Associe l'operateur au domaine_dis, le domaine_Cl_dis, et a l'inconnue de son equation.
Definition Op_Diff_VEF_Face_Stab.cpp:814
Op_Diff_VEF_Face
class Op_Diff_VEF_Face Cette classe represente l'operateur de diffusion
Definition Op_Diff_VEF_Face.h:32
Op_Diff_VEF_Face::completer
void completer() override
Associe l'operateur au domaine_dis, le domaine_Cl_dis, et a l'inconnue de son equation.
Definition Op_Diff_VEF_Face.cpp:61
Op_Diff_VEF_Face::ajouter_contribution_multi_scalaire
void ajouter_contribution_multi_scalaire(const DoubleTab &, Matrice_Morse &) const
Definition Op_Diff_VEF_Face.cpp:1019
Op_Diff_VEF_Face::ajouter_contribution
void ajouter_contribution(const DoubleTab &, Matrice_Morse &) const
Definition Op_Diff_VEF_Face.cpp:724
Op_Diff_VEF_base::phi_psi_diffuse
int phi_psi_diffuse(const Equation_base &eq) const
definit si on calcule div(phi nu grad Psi) ou div(nu grap Phi psi)
Definition Op_Diff_VEF_base.cpp:44
Op_Diff_VEF_base::nu_
DoubleTab nu_
Definition Op_Diff_VEF_base.h:66
Op_Diff_VEF_base::remplir_nu
virtual void remplir_nu(DoubleTab &) const
Definition Op_Diff_VEF_base.cpp:251
Op_Diff_VEF_base::viscA
double viscA(int face_i, int face_j, int num_elem, const _TYPE_ &diffu) const
Definition Op_Diff_VEF_base.h:92
Op_VEF_Face::modifier_matrice_pour_periodique_apres_contribuer
void modifier_matrice_pour_periodique_apres_contribuer(Matrice_Morse &matrice, const Equation_base &) const
Somme les 2 lignes des faces periodiques associees permet de calculer dans le code sans se poser de q...
Definition Op_VEF_Face.cpp:738
Op_VEF_Face::modifier_matrice_pour_periodique_avant_contribuer
void modifier_matrice_pour_periodique_avant_contribuer(Matrice_Morse &matrice, const Equation_base &) const
divise les coefficients sur les ligne des faces periodiques par 2 en prevision de l'application modif...
Definition Op_VEF_Face.cpp:725
Op_VEF_Face::modifier_flux
void modifier_flux(const Operateur_base &) const
Definition Op_VEF_Face.cpp:338
Operateur_base::flux_bords_
DoubleTab flux_bords_
Definition Operateur_base.h:140
Periodique
classe Periodique Cette classe represente une condition aux limites periodique.
Definition Periodique.h:31
Periodique::face_associee
int face_associee(int i) const
Definition Periodique.h:35
Process::mp_min
static double mp_min(double)
Definition Process.cpp:386
Process::mp_max
static double mp_max(double)
Definition Process.cpp:376
Process::exit
static void exit(int exit_code=-1)
Routine de sortie de TRUST dans une region Kokkos.
Definition Process.cpp:455
Process::je_suis_maitre
static int je_suis_maitre()
renvoie 1 si on est sur le processeur maitre du groupe courant (c'est a dire me() == 0),...
Definition Process.cpp:86
SFichier
Cette classe est a la classe C++ ofstream ce que la classe Sortie est a la classe C++ ostream Elle re...
Definition SFichier.h:27
Sortie
Classe de base des flux de sortie.
Definition Sortie.h:52
Support_Champ_Masse_Volumique::declare_support_masse_volumique
virtual void declare_support_masse_volumique(int ok)
Le constructeur d'une classe derivee qui se sert de la masse volumique doit appeler cette fonction av...
Definition Support_Champ_Masse_Volumique.cpp:46
Symetrie
classe Symetrie Sur les faces de symetrie on a les proprietes suivantes:
Definition Symetrie.h:37
TRUSTTab::nb_dim
int nb_dim() const
Definition TRUSTTab.h:199
TRUSTTab::resize
void resize(_SIZE_ n, RESIZE_OPTIONS opt=RESIZE_OPTIONS::COPY_INIT)
Definition TRUSTTab.tpp:469
TRUSTTab::dimension
_SIZE_ dimension(int d) const
Definition TRUSTTab.tpp:133