TRUST 1.9.8
HPC thermohydraulic platform
Loading...
Searching...
No Matches
Op_Diff_VEF_Anisotrope_Face.cpp
1/****************************************************************************
2* Copyright (c) 2025, 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_Anisotrope_Face.h>
17#include <Echange_externe_radiatif.h>
18#include <Echange_externe_impose.h>
19#include <Neumann_sortie_libre.h>
20#include <Navier_Stokes_std.h>
21#include <Neumann_homogene.h>
22#include <Porosites_champ.h>
23#include <Champ_Uniforme.h>
24#include <Neumann_paroi.h>
25#include <Probleme_base.h>
26#include <Milieu_base.h>
27#include <Champ_P1NC.h>
28#include <Champ_Q1NC.h>
29#include <Periodique.h>
30#include <TRUSTTrav.h>
31#include <Symetrie.h>
32
33Implemente_instanciable( Op_Diff_VEF_Anisotrope_Face, "Op_Diff_VEFANISOTROPE_P1NC", Op_Diff_VEF_base) ;
34
35Sortie& Op_Diff_VEF_Anisotrope_Face::printOn(Sortie& s ) const
36{
37 return s << que_suis_je() ;
38}
39
40Entree& Op_Diff_VEF_Anisotrope_Face::readOn(Entree& s )
41{
42 return s ;
43}
44
45/*! @brief associe le champ de diffusivite
46 *
47 */
48void Op_Diff_VEF_Anisotrope_Face::associer_diffusivite(const Champ_base& diffu)
49{
50 diffusivite_ = diffu;
51}
52
57
58const Champ_base& Op_Diff_VEF_Anisotrope_Face::diffusivite() const
59{
60 return diffusivite_.valeur();
61}
62
63void Op_Diff_VEF_Anisotrope_Face::ajouter_cas_scalaire(const DoubleTab& inconnue,
64 DoubleTab& resu, DoubleTab& tab_flux_bords,
65 DoubleTab& nu,
66 const Domaine_Cl_VEF& domaine_Cl_VEF,
67 const Domaine_VEF& domaine_VEF ) const
68{
69 // assurer on a un tableau bidimensionnel
70 assert(nu.nb_dim()==2);
71 // assurer vrai nombre de composants pour l'anisotropie (9 pour 3d et 4 pour 2d)
72 assert(nu.dimension(1)==dimension*dimension);
73
74 const IntTab& elemfaces = domaine_VEF.elem_faces();
75 const IntTab& face_voisins = domaine_VEF.face_voisins();
76 int i,j,num_face;
77 int nb_faces = domaine_VEF.nb_faces();
78 int nb_faces_elem = domaine_VEF.domaine().nb_faces_elem();
79 double valA,flux;
80 int n_bord, ind_face;
81 int nb_bords=domaine_VEF.nb_front_Cl();
82 // On dimensionne et initialise le tableau des bilans de flux:
83 tab_flux_bords.resize(domaine_VEF.nb_faces_bord(),1);
84 tab_flux_bords=0.;
85 const int premiere_face_int=domaine_VEF.premiere_face_int();
86
87 // On traite les faces bord
88 for (n_bord=0; n_bord<nb_bords; n_bord++)
89 {
90 const Cond_lim& la_cl = domaine_Cl_VEF.les_conditions_limites(n_bord);
91 const Front_VF& le_bord = ref_cast(Front_VF,la_cl->frontiere_dis());
92 //const IntTab& elemfaces = domaine_VEF.elem_faces();
93 int num1=0;
94 int num2=le_bord.nb_faces_tot();
95 int nb_faces_bord_reel = le_bord.nb_faces();
96
97 if (sub_type(Periodique,la_cl.valeur()))
98 {
99 const Periodique& la_cl_perio = ref_cast(Periodique,la_cl.valeur());
100 int fac_asso;
101 for (ind_face=num1; ind_face<nb_faces_bord_reel; ind_face++)
102 {
103 num_face = le_bord.num_face(ind_face);
104 fac_asso = la_cl_perio.face_associee(ind_face);
105 fac_asso = le_bord.num_face(fac_asso);
106 for (int kk=0; kk<2; kk++)
107 {
108 int elem = face_voisins(num_face,kk);
109 for (i=0; i<nb_faces_elem; i++)
110 {
111 if ( ( (j= elemfaces(elem,i)) > num_face ) && (j != fac_asso) )
112 {
113 valA = viscA(num_face,j,elem,nu);
114 resu(num_face)+=valA*inconnue(j);
115 resu(num_face)-=valA*inconnue(num_face);
116 if(j<nb_faces) // face reelle
117 {
118 resu(j)+=0.5*valA*inconnue(num_face);
119 resu(j)-=0.5*valA*inconnue(j);
120 }
121 }
122 }
123 }
124 }
125 }
126 else // Il n'y a qu'une seule composante, donc on traite
127 // une equation scalaire (pas la vitesse) on a pas a utiliser
128 // le tau tangentiel (les lois de paroi thermiques ne calculent pas
129 // d'echange turbulent a la paroi pour l'instant
130 {
131 for (ind_face=num1; ind_face<num2; ind_face++)
132 {
133 num_face = le_bord.num_face(ind_face);
134 int elem = face_voisins(num_face,0);
135
136 for (i=0; i<nb_faces_elem; i++)
137 {
138 if (( (j= elemfaces(elem,i)) > num_face ) || (ind_face>=nb_faces_bord_reel))
139 {
140 valA = viscA(num_face,j,elem,nu);
141
142 if (ind_face<nb_faces_bord_reel)
143 {
144 flux=valA*(inconnue(j)-inconnue(num_face));
145 // PL : c'est bien un - ici pour flux_bords. Cette valeur est ensuite
146 // ecrasee pour les bords avec Neumann et ne sert donc que pour les bords
147 // avec Dirichlet ou le volume de controle est nul
148 tab_flux_bords(num_face,0)-=flux;
149 resu(num_face)+=flux;
150 }
151
152 if(j<nb_faces) // face reelle
153 {
154 flux=valA*(inconnue(num_face)-inconnue(j));
155 if (j<premiere_face_int)
156 tab_flux_bords(j,0)-=flux;
157 resu(j)+=flux;
158 }
159 }
160 }
161 }
162 }
163 }
164
165 // Faces internes :
166 for (num_face=premiere_face_int; num_face<nb_faces; num_face++)
167 {
168 for (int k=0; k<2; k++)
169 {
170 int elem = face_voisins(num_face,k);
171 {
172 for (i=0; i<nb_faces_elem; i++)
173 {
174 j=elemfaces(elem,i);
175 if ( j > num_face )
176 {
177 int el1,el2;
178 int contrib=1;
179 if(j>=nb_faces) // C'est une face virtuelle
180 {
181 el1 = face_voisins(j,0);
182 el2 = face_voisins(j,1);
183 if((el1==-1)||(el2==-1))
184 contrib=0;
185 }
186 if(contrib)
187 {
188 valA = viscA(num_face,j,elem,nu);
189 resu(num_face)+=valA*inconnue(j);
190 resu(num_face)-=valA*inconnue(num_face);
191 if(j<nb_faces) // On traite les faces reelles
192 {
193 resu(j)+=valA*inconnue(num_face);
194 resu(j)-=valA*inconnue(j);
195 }
196 }
197 }
198 }
199 }
200 }
201 }
202
203 // Neumann :
204 for (n_bord=0; n_bord<nb_bords; n_bord++)
205 {
206 const Cond_lim& la_cl = domaine_Cl_VEF.les_conditions_limites(n_bord);
207
208 if (sub_type(Neumann_paroi,la_cl.valeur()))
209 {
210 const Neumann_paroi& la_cl_paroi = ref_cast(Neumann_paroi, la_cl.valeur());
211 const Front_VF& le_bord = ref_cast(Front_VF,la_cl->frontiere_dis());
212 int ndeb = le_bord.num_premiere_face();
213 int nfin = ndeb + le_bord.nb_faces();
214 for (int face=ndeb; face<nfin; face++)
215 {
216 flux=la_cl_paroi.flux_impose(face-ndeb)*domaine_VEF.surface(face);
217 resu[face] += flux;
218 tab_flux_bords(face,0) = flux;
219 }
220 }
221 else if (sub_type(Echange_externe_impose,la_cl.valeur()))
222 {
223 const Echange_externe_impose& la_cl_paroi = ref_cast(Echange_externe_impose, la_cl.valeur());
224 const Front_VF& le_bord = ref_cast(Front_VF,la_cl->frontiere_dis());
225 int ndeb = le_bord.num_premiere_face();
226 int nfin = ndeb + le_bord.nb_faces();
227 for (int face=ndeb; face<nfin; face++)
228 {
229 flux=la_cl_paroi.h_imp(face-ndeb)*(la_cl_paroi.T_ext(face-ndeb)-inconnue(face))*domaine_VEF.surface(face);
230 resu[face] += flux;
231 tab_flux_bords(face,0) = flux;
232 if (la_cl_paroi.has_emissivite())
233 {
234 const double text = la_cl_paroi.T_ext(face - ndeb), T = inconnue(face);
235 flux = COEFF_STEFAN_BOLTZMANN * la_cl_paroi.emissivite(face - ndeb) * (text * text * text * text - T * T * T * T) * domaine_VEF.face_surfaces(face);
236 resu[face] += flux;
237 tab_flux_bords(face, 0) += flux;
238 }
239 }
240 }
241 else if (sub_type(Neumann_homogene,la_cl.valeur())
242 || sub_type(Symetrie,la_cl.valeur())
243 || sub_type(Neumann_sortie_libre,la_cl.valeur()))
244 {
245 const Front_VF& le_bord = ref_cast(Front_VF,la_cl->frontiere_dis());
246 int ndeb = le_bord.num_premiere_face();
247 int nfin = ndeb + le_bord.nb_faces();
248 for (int face=ndeb; face<nfin; face++)
249 tab_flux_bords(face,0) = 0.;
250 }
251 }
252}
253
254void Op_Diff_VEF_Anisotrope_Face::ajouter_cas_vectoriel(const DoubleTab& inconnue,
255 DoubleTab& resu, DoubleTab& tab_flux_bords,
256 DoubleTab& nu,
257 const Domaine_Cl_VEF& domaine_Cl_VEF,
258 const Domaine_VEF& domaine_VEF,
259 int nb_comp) const
260{
261 Cerr << "Error in Op_Diff_VEF_Anisotrope_Face::ajouter_cas_vectoriel()" << finl;
262 Cerr << "This case is not coded yet" << finl;
263 Process::exit(-1);
264}
265
266void Op_Diff_VEF_Anisotrope_Face::ajouter_cas_multi_scalaire(const DoubleTab& inconnue,
267 DoubleTab& resu, DoubleTab& tab_flux_bords,
268 DoubleTab& nu,
269 const Domaine_Cl_VEF& domaine_Cl_VEF,
270 const Domaine_VEF& domaine_VEF,
271 int nb_comp) const
272{
273 const int nb_cols_nu = nu.dimension(1);
274 assert(nb_cols_nu == dimension*dimension*nb_comp*nb_comp);
275
276 const IntTab& elemfaces = domaine_VEF.elem_faces();
277 const IntTab& face_voisins = domaine_VEF.face_voisins();
278 int i0,j,num_face;
279 int nb_faces = domaine_VEF.nb_faces();
280 int n_bord;
281 int nb_faces_elem = domaine_VEF.domaine().nb_faces_elem();
282 double valA,flux0;
283 //DoubleVect n(Objet_U::dimension);
284 //DoubleTrav Tgrad(Objet_U::dimension,Objet_U::dimension);
285
286 // dimensionning and initializing flow balance tabulars
287 tab_flux_bords.resize(domaine_VEF.nb_faces_bord(),nb_comp);
288 tab_flux_bords=0.;
289 assert( nb_comp>1 );
290 int nb_bords=domaine_VEF.nb_front_Cl();
291 int ind_face;
292
293 for (n_bord=0; n_bord<nb_bords; n_bord++)
294 {
295 const Cond_lim& la_cl = domaine_Cl_VEF.les_conditions_limites(n_bord);
296 const Front_VF& le_bord = ref_cast(Front_VF,la_cl->frontiere_dis());
297
298 int num1 = 0;
299 int num2 = le_bord.nb_faces_tot();
300 int nb_faces_bord_reel = le_bord.nb_faces();
301
302 //periodic case
303 if (sub_type(Periodique,la_cl.valeur()))
304 {
305 const Periodique& la_cl_perio = ref_cast(Periodique,la_cl.valeur());
306 int fac_asso;
307 for (ind_face=num1; ind_face<nb_faces_bord_reel; ind_face++)
308 {
309 fac_asso = la_cl_perio.face_associee(ind_face);
310 fac_asso = le_bord.num_face(fac_asso);
311 num_face = le_bord.num_face(ind_face);
312 for (int kk=0; kk<2; kk++)
313 {
314 int elem = face_voisins(num_face, kk);
315 for (i0=0; i0<nb_faces_elem; i0++)
316 {
317 if ( ( (j= elemfaces(elem,i0)) > num_face ) && (j != fac_asso ) )
318 {
319 for(int c1=0; c1<nb_comp; c1++)
320 {
321 for(int c2=0; c2<nb_comp; c2++)
322 {
323 int diffusivity_index = c1*nb_comp + c2;
324 int start_id = elem*nb_cols_nu+diffusivity_index*dimension*dimension;
325 ArrOfDouble diffu_c1_c2_elem;
326 diffu_c1_c2_elem.ref_array(nu, start_id ,dimension*dimension);
327 valA = viscA(num_face,j,elem,diffu_c1_c2_elem);
328
329 resu(num_face,c1)+=valA*inconnue(j,c2);
330 resu(num_face,c1)-=valA*inconnue(num_face,c2);
331 if(j<nb_faces) // real face
332 {
333 resu(j,c1)+=0.5*valA*inconnue(num_face,c2);
334 resu(j,c1)-=0.5*valA*inconnue(j,c2);
335 }
336 }
337 }
338 }
339 }//loop over i0 (nb_faces) for elem1
340 }//loop over kk
341 } // ind face
342 }// end periodic
343 else
344 {
345 for (ind_face=num1; ind_face<num2; ind_face++)
346 {
347 num_face = le_bord.num_face(ind_face);
348 int elem=face_voisins(num_face,0);
349
350 // Loop over faces :
351 for (int i=0; i<nb_faces_elem; i++)
352 if (( (j= elemfaces(elem,i)) > num_face ) || (ind_face>=nb_faces_bord_reel))
353 {
354 for(int c1=0; c1<nb_comp; c1++)
355 {
356 for(int c2=0; c2<nb_comp; c2++)
357 {
358 int diffusivity_index = c1*nb_comp + c2;
359 int start_id = elem*nb_cols_nu+diffusivity_index*dimension*dimension;
360 ArrOfDouble diffu_c1_c2_elem;
361 diffu_c1_c2_elem.ref_array(nu, start_id ,dimension*dimension);
362 valA = viscA(num_face,j,elem,diffu_c1_c2_elem);
363
364 if (ind_face<nb_faces_bord_reel)
365 {
366 double flux=valA*(inconnue(j,c2)-inconnue(num_face,c2));
367 resu(num_face,c1)+=flux;
368 tab_flux_bords(num_face,c1)+=flux;
369 }
370 if(j<nb_faces) // real faces
371 {
372 resu(j,c1)+=valA*inconnue(num_face,c2);
373 resu(j,c1)-=valA*inconnue(j,c2);
374 }
375 }// loop c2
376 }// loop c1
377 } // j
378 }//end of ind_face loop
379 }//else
380 }//end for the boundaries loop
381
382 // dealing now with internal faces
383
384
385 for (num_face=domaine_VEF.premiere_face_int(); num_face<nb_faces; num_face++)
386 {
387 for (int k=0; k<2; k++)
388 {
389 int elem = face_voisins(num_face,k);
390 for (i0=0; i0<nb_faces_elem; i0++)
391 {
392 if ( (j= elemfaces(elem,i0)) > num_face )
393 {
394 int el1,el2;
395 int contrib=1;
396 if(j>=nb_faces) // it is a virtual face
397 {
398 el1 = face_voisins(j,0);
399 el2 = face_voisins(j,1);
400 if((el1==-1)||(el2==-1))
401 contrib=0;
402 }
403 if(contrib)
404 {
405 for(int c1=0; c1<nb_comp; c1++)
406
407 for(int c2=0; c2<nb_comp; c2++)
408 {
409 int diffusivity_index = c1*nb_comp + c2;
410 int start_id = elem*nb_cols_nu+diffusivity_index*dimension*dimension;
411 ArrOfDouble diffu_c1_c2_elem;
412 diffu_c1_c2_elem.ref_array(nu, start_id ,dimension*dimension);
413 valA = viscA(num_face,j,elem,diffu_c1_c2_elem);
414
415 resu(num_face,c1)+=valA*inconnue(j,c2);
416 resu(num_face,c1)-=valA*inconnue(num_face,c2);
417 if(j<nb_faces) // dealing with real faces
418 {
419 resu(j,c1)+=valA*inconnue(num_face,c2);
420 resu(j,c1)-=valA*inconnue(j,c2);
421 }
422 else
423 {
424 //the face is virtual
425 }
426 }
427 }
428 }
429 }//loop i0 over elem faces
430 }//loop over k
431 }//loop over faces
432
433
434 // Neumann
435 //On se base sur ce qui est fait pour le cas scalaire
436 for (n_bord=0; n_bord<nb_bords; n_bord++)
437 {
438 const Cond_lim& la_cl = domaine_Cl_VEF.les_conditions_limites(n_bord);
439
440 if (sub_type(Neumann_paroi,la_cl.valeur()))
441 {
442 const Neumann_paroi& la_cl_paroi = ref_cast(Neumann_paroi, la_cl.valeur());
443 const Front_VF& le_bord = ref_cast(Front_VF,la_cl->frontiere_dis());
444 int ndeb = le_bord.num_premiere_face();
445 int nfin = ndeb + le_bord.nb_faces();
446 for (int face=ndeb; face<nfin; face++)
447 {
448 for (int nc=0; nc<nb_comp; nc++)
449 {
450 flux0=la_cl_paroi.flux_impose(face-ndeb,nc)*domaine_VEF.surface(face);
451 resu(face,nc) += flux0;
452 tab_flux_bords(face,nc) = flux0;
453 }
454 }
455 }
456 else if (sub_type(Echange_externe_impose,la_cl.valeur()))
457 {
458 const Echange_externe_impose& la_cl_paroi = ref_cast(Echange_externe_impose, la_cl.valeur());
459 const Front_VF& le_bord = ref_cast(Front_VF,la_cl->frontiere_dis());
460 int ndeb = le_bord.num_premiere_face();
461 int nfin = ndeb + le_bord.nb_faces();
462 for (int face=ndeb; face<nfin; face++)
463 {
464 for (int nc=0; nc<nb_comp; nc++)
465 {
466 flux0=la_cl_paroi.h_imp(face-ndeb,nc)*(la_cl_paroi.T_ext(face-ndeb,nc)-inconnue(face,nc))*domaine_VEF.surface(face);
467 resu(face,nc) += flux0;
468 tab_flux_bords(face,nc) = flux0;
469
470 if (la_cl_paroi.has_emissivite())
471 {
472 const double text = la_cl_paroi.T_ext(face - ndeb, nc), T = inconnue(face, nc);
473 flux0 = COEFF_STEFAN_BOLTZMANN * la_cl_paroi.emissivite(face - ndeb, nc) * (text * text * text * text - T * T * T * T) * domaine_VEF.face_surfaces(face);
474 resu(face, nc) += flux0;
475 tab_flux_bords(face, nc) += flux0;
476 }
477 }
478 }
479 }
480 else if (sub_type(Neumann_homogene,la_cl.valeur())
481 || sub_type(Symetrie,la_cl.valeur())
482 || sub_type(Neumann_sortie_libre,la_cl.valeur()))
483 {
484 const Front_VF& le_bord = ref_cast(Front_VF,la_cl->frontiere_dis());
485 int ndeb = le_bord.num_premiere_face();
486 int nfin = ndeb + le_bord.nb_faces();
487 for (int face=ndeb; face<nfin; face++)
488 for (int nc=0; nc<nb_comp; nc++)
489 tab_flux_bords(face,nc) = 0.;
490 }
491 }
492}
493
494
495DoubleTab& Op_Diff_VEF_Anisotrope_Face::ajouter(const DoubleTab& inconnue_org, DoubleTab& resu) const
496{
497 remplir_nu(nu_);
498 const Domaine_Cl_VEF& domaine_Cl_VEF = la_zcl_vef.valeur();
499 const Domaine_VEF& domaine_VEF = le_dom_vef.valeur();
500
501 int nb_comp = 1;
502 int nb_dim = resu.nb_dim();
503 if(nb_dim==2)
504 nb_comp=resu.dimension(1);
505 DoubleTab nu;
506 DoubleTab tab_inconnue;
507 int marq=phi_psi_diffuse(equation());
508 const DoubleVect& porosite_face = equation().milieu().porosite_face();
509 const DoubleVect& porosite_elem = equation().milieu().porosite_elem();
510 // soit on a div(phi nu grad inco)
511 // soit on a div(nu grad phi inco)
512 // cela depend si on diffuse phi_psi ou psi
513 modif_par_porosite_si_flag(nu_,nu,!marq,porosite_elem);
514 const DoubleTab& inconnue=modif_par_porosite_si_flag(inconnue_org,tab_inconnue,marq,porosite_face);
515
516 const Champ_base& inco = equation().inconnue();
517 const Nature_du_champ nature_champ = inco.nature_du_champ();
518 if(nature_champ==scalaire)
519 ajouter_cas_scalaire(inconnue, resu, flux_bords_, nu, domaine_Cl_VEF, domaine_VEF);
520 else if (nature_champ==vectoriel)
521 ajouter_cas_vectoriel(inconnue, resu, flux_bords_, nu, domaine_Cl_VEF, domaine_VEF,nb_comp);
522 else if (nature_champ==multi_scalaire)
523 ajouter_cas_multi_scalaire(inconnue, resu, flux_bords_, nu, domaine_Cl_VEF, domaine_VEF,nb_comp);
524 modifier_flux(*this);
525
526 return resu;
527}
528
529DoubleTab& Op_Diff_VEF_Anisotrope_Face::calculer(const DoubleTab& inconnue, DoubleTab& resu) const
530{
531 resu = 0;
532 return ajouter(inconnue,resu);
533}
534
535void Op_Diff_VEF_Anisotrope_Face::ajouter_contribution(const DoubleTab& transporte, Matrice_Morse& matrice) const
536{
537
538 modifier_matrice_pour_periodique_avant_contribuer(matrice,equation());
539 // On remplit le tableau nu car l'assemblage d'une
540 // matrice avec ajouter_contribution peut se faire
541 // avant le premier pas de temps
542 remplir_nu(nu_);
543 const Domaine_Cl_VEF& domaine_Cl_VEF = la_zcl_vef.valeur();
544 const Domaine_VEF& domaine_VEF = le_dom_vef.valeur();
545 const IntTab& elem_faces = domaine_VEF.elem_faces();
546 const IntTab& face_voisins = domaine_VEF.face_voisins();
547
548 int n1 = domaine_VEF.nb_faces();
549 int nb_comp = 1;
550 int nb_dim = transporte.nb_dim();
551
552 DoubleTab nu;
553 int marq=phi_psi_diffuse(equation());
554 const DoubleVect& porosite_elem = equation().milieu().porosite_elem();
555
556 // soit on a div(phi nu grad inco)
557 // soit on a div(nu grad phi inco)
558 // cela depend si on diffuse phi_psi ou psi
559 modif_par_porosite_si_flag(nu_,nu,!marq,porosite_elem);
560 DoubleVect porosite_eventuelle(equation().milieu().porosite_face());
561 if (!marq)
562 porosite_eventuelle=1;
563
564
565 if(nb_dim==2)
566 nb_comp=transporte.dimension(1);
567
568 int i,j,num_face;
569 int elem1,elem2;
570 int nb_faces_elem = domaine_VEF.domaine().nb_faces_elem();
571 double val;
572
573 int nb_bords=domaine_VEF.nb_front_Cl();
574 for (int n_bord=0; n_bord<nb_bords; n_bord++)
575 {
576 const Cond_lim& la_cl = domaine_Cl_VEF.les_conditions_limites(n_bord);
577 const Front_VF& le_bord = ref_cast(Front_VF,la_cl->frontiere_dis());
578 int num1 = le_bord.num_premiere_face();
579 int num2 = num1 + le_bord.nb_faces();
580
581 if (sub_type(Periodique,la_cl.valeur()))
582 {
583 const Periodique& la_cl_perio = ref_cast(Periodique,la_cl.valeur());
584 int fac_asso;
585 // on ne parcourt que la moitie des faces periodiques
586 // on copiera a la fin le resultat dans la face associe..
587 int num2b=num1+le_bord.nb_faces()/2;
588 for (num_face=num1; num_face<num2b; num_face++)
589 {
590 elem1 = face_voisins(num_face,0);
591 elem2 = face_voisins(num_face,1);
592 fac_asso = la_cl_perio.face_associee(num_face-num1)+num1;
593 for (i=0; i<nb_faces_elem; i++)
594 {
595 if ( (j=elem_faces(elem1,i)) > num_face )
596 {
597 val = viscA(num_face,j,elem1,nu);
598 for (int nc=0; nc<nb_comp; nc++)
599 {
600 int n0=num_face*nb_comp+nc;
601 int j0=j*nb_comp+nc;
602
603 matrice(n0,n0)+=val*porosite_eventuelle(num_face);
604 matrice(n0,j0)-=val*porosite_eventuelle(j);
605 matrice(j0,n0)-=val*porosite_eventuelle(num_face);
606 matrice(j0,j0)+=val*porosite_eventuelle(j);
607
608 }
609 }
610 if (elem2!=-1)
611 if ( (j=elem_faces(elem2,i)) > num_face )
612 {
613 val= viscA(num_face,j,elem2,nu);
614 for (int nc=0; nc<nb_comp; nc++)
615 {
616 int n0=num_face*nb_comp+nc;
617 int j0=j*nb_comp+nc;
618 int n0perio=fac_asso*nb_comp+nc;
619 matrice(n0,n0)+=val*porosite_eventuelle(num_face);
620 matrice(n0,j0)-=val*porosite_eventuelle(j);
621 matrice(j0,n0perio)-=val*porosite_eventuelle(num_face);
622 matrice(j0,j0)+=val*porosite_eventuelle(j);
623
624 }
625 }
626 }
627 }
628
629 }
630 else
631 {
632 for (num_face=num1; num_face<num2; num_face++)
633 {
634 elem1 = face_voisins(num_face,0);
635 for (i=0; i<nb_faces_elem; i++)
636 {
637 if ( (j= elem_faces(elem1,i)) > num_face )
638 {
639 val = viscA(num_face,j,elem1,nu);
640 for (int nc=0; nc<nb_comp; nc++)
641 {
642 int n0=num_face*nb_comp+nc;
643 int j0=j*nb_comp+nc;
644
645 matrice(n0,n0)+=val*porosite_eventuelle(num_face);
646 matrice(n0,j0)-=val*porosite_eventuelle(j);
647 matrice(j0,n0)-=val*porosite_eventuelle(num_face);
648 matrice(j0,j0)+=val*porosite_eventuelle(j);
649
650 }
651 }
652 }
653 }
654 }
655 }
656 int n0 = domaine_VEF.premiere_face_int();
657 for (num_face=n0; num_face<n1; num_face++)
658 {
659 elem1 = face_voisins(num_face,0);
660 elem2 = face_voisins(num_face,1);
661
662 for (i=0; i<nb_faces_elem; i++)
663 {
664 if ( (j=elem_faces(elem1,i)) > num_face )
665 {
666 val = viscA(num_face,j,elem1,nu);
667 for (int nc=0; nc<nb_comp; nc++)
668 {
669 int nn0=num_face*nb_comp+nc;
670 int j0=j*nb_comp+nc;
671
672 matrice(nn0,nn0)+=val*porosite_eventuelle(num_face);
673 matrice(nn0,j0)-=val*porosite_eventuelle(j);
674 matrice(j0,nn0)-=val*porosite_eventuelle(num_face);
675 matrice(j0,j0)+=val*porosite_eventuelle(j);
676
677 }
678 }
679 if (elem2!=-1)
680 if ( (j=elem_faces(elem2,i)) > num_face )
681 {
682 val= viscA(num_face,j,elem2,nu);
683 for (int nc=0; nc<nb_comp; nc++)
684 {
685 int nn0=num_face*nb_comp+nc;
686 int j0=j*nb_comp+nc;
687
688 matrice(nn0,nn0)+=val*porosite_eventuelle(num_face);
689 matrice(nn0,j0)-=val*porosite_eventuelle(j);
690 matrice(j0,nn0)-=val*porosite_eventuelle(num_face);
691 matrice(j0,j0)+=val*porosite_eventuelle(j);
692
693 }
694 }
695 }
696 }
697 // Neumann :
698 for (int n_bord=0; n_bord<nb_bords; n_bord++)
699 {
700 const Cond_lim& la_cl = domaine_Cl_VEF.les_conditions_limites(n_bord);
701
702 if (sub_type(Neumann_paroi,la_cl.valeur()))
703 {
704 }
705 else if (sub_type(Echange_externe_impose,la_cl.valeur()))
706 {
707 const Echange_externe_impose& la_cl_paroi = ref_cast(Echange_externe_impose, la_cl.valeur());
708 const Front_VF& le_bord = ref_cast(Front_VF,la_cl->frontiere_dis());
709 int ndeb = le_bord.num_premiere_face();
710 int nfin = ndeb + le_bord.nb_faces();
711 for (int face=ndeb; face<nfin; face++)
712 {
713 matrice(face,face) += la_cl_paroi.h_imp(face-ndeb)*domaine_VEF.face_surfaces(face);
714 }
715 }
716 else if (sub_type(Echange_externe_radiatif,la_cl.valeur()))
717 {
718 const Echange_externe_radiatif& la_cl_paroi = ref_cast(Echange_externe_radiatif, la_cl.valeur());
719 const Front_VF& le_bord = ref_cast(Front_VF,la_cl->frontiere_dis());
720 int ndeb = le_bord.num_premiere_face();
721 int nfin = ndeb + le_bord.nb_faces();
722 for (int face=ndeb; face<nfin; face++)
723 {
724 const DoubleTab& inconnue = equation().inconnue().valeurs();
725
726 const double T = inconnue(face);
727 matrice(face,face) += 4 * COEFF_STEFAN_BOLTZMANN * la_cl_paroi.emissivite(face-ndeb) * T * T * T *domaine_VEF.face_surfaces(face);
728 }
729 }
730 else if (sub_type(Neumann_homogene,la_cl.valeur())
731 || sub_type(Symetrie,la_cl.valeur())
732 || sub_type(Neumann_sortie_libre,la_cl.valeur()))
733 {
734 }
735 }
736 modifier_matrice_pour_periodique_apres_contribuer(matrice,equation());
737}
738
739void Op_Diff_VEF_Anisotrope_Face::ajouter_contribution_multi_scalaire(const DoubleTab& transporte, Matrice_Morse& matrice) const
740{
741 modifier_matrice_pour_periodique_avant_contribuer(matrice,equation());
742 // On remplit le tableau nu car l'assemblage d'une
743 // matrice avec ajouter_contribution peut se faire
744 // avant le premier pas de temps
745 remplir_nu(nu_);
746 const Domaine_Cl_VEF& domaine_Cl_VEF = la_zcl_vef.valeur();
747 const Domaine_VEF& domaine_VEF = le_dom_vef.valeur();
748 const IntTab& elem_faces = domaine_VEF.elem_faces();
749 const IntTab& face_voisins = domaine_VEF.face_voisins();
750
751 int n1 = domaine_VEF.nb_faces();
752 int nb_comp = 1;
753 int nb_dim = transporte.nb_dim();
754
755 DoubleTab nu;
756 int marq=phi_psi_diffuse(equation());
757 const DoubleVect& porosite_elem = equation().milieu().porosite_elem();
758
759 // soit on a div(phi nu grad inco)
760 // soit on a div(nu grad phi inco)
761 // cela depend si on diffuse phi_psi ou psi
762 modif_par_porosite_si_flag(nu_,nu,!marq,porosite_elem);
763 DoubleVect porosite_eventuelle(equation().milieu().porosite_face());
764 if (!marq)
765 porosite_eventuelle=1;
766
767
768 if(nb_dim==2)
769 nb_comp=transporte.dimension(1);
770
771 const int nb_cols_nu = nu.dimension(1);
772 assert(nb_cols_nu == dimension*dimension*nb_comp*nb_comp);
773
774 int i,j,num_face;
775 int elem1,elem2;
776 int nb_faces_elem = domaine_VEF.domaine().nb_faces_elem();
777 double val;
778
779 int nb_bords=domaine_VEF.nb_front_Cl();
780 for (int n_bord=0; n_bord<nb_bords; n_bord++)
781 {
782 const Cond_lim& la_cl = domaine_Cl_VEF.les_conditions_limites(n_bord);
783 const Front_VF& le_bord = ref_cast(Front_VF,la_cl->frontiere_dis());
784 int num1 = le_bord.num_premiere_face();
785 int num2 = num1 + le_bord.nb_faces();
786 if (sub_type(Periodique,la_cl.valeur()))
787 {
788 const Periodique& la_cl_perio = ref_cast(Periodique,la_cl.valeur());
789 int fac_asso;
790 // on ne parcourt que la moitie des faces periodiques
791 // on copiera a la fin le resultat dans la face associe..
792 int num2b=num1+le_bord.nb_faces()/2;
793 for (num_face=num1; num_face<num2b; num_face++)
794 {
795 elem1 = face_voisins(num_face,0);
796 elem2 = face_voisins(num_face,1);
797 fac_asso = la_cl_perio.face_associee(num_face-num1)+num1;
798 for (i=0; i<nb_faces_elem; i++)
799 {
800 if ( (j=elem_faces(elem1,i)) > num_face )
801 {
802 for(int c1=0; c1<nb_comp; c1++)
803 for(int c2=0; c2<nb_comp; c2++)
804 {
805
806 int diffusivity_index = c1*nb_comp + c2;
807 int start_id = elem1*nb_cols_nu+diffusivity_index*dimension*dimension;
808 ArrOfDouble diffu_c1_c2_elem;
809 diffu_c1_c2_elem.ref_array(nu, start_id ,dimension*dimension);
810 val = viscA(num_face,j,elem1,diffu_c1_c2_elem);
811
812 int n0=num_face*nb_comp+c1;
813 int j0=j*nb_comp+c1;
814 int n0b=num_face*nb_comp+c2;
815 int j0b=j*nb_comp+c2;
816
817 matrice(n0,n0b)+=val*porosite_eventuelle(num_face);
818 matrice(n0,j0b)-=val*porosite_eventuelle(j);
819 matrice(j0,n0b)-=val*porosite_eventuelle(num_face);
820 matrice(j0,j0b)+=val*porosite_eventuelle(j);
821
822
823 }
824 }
825 if (elem2!=-1)
826 if ( (j=elem_faces(elem2,i)) > num_face )
827 {
828 for (int nc=0; nc<nb_comp; nc++)
829 {
830 for(int c1=0; c1<nb_comp; c1++)
831 for(int c2=0; c2<nb_comp; c2++)
832 {
833
834 int diffusivity_index = c1*nb_comp + c2;
835 int start_id = elem1*nb_cols_nu+diffusivity_index*dimension*dimension;
836 ArrOfDouble diffu_c1_c2_elem;
837 diffu_c1_c2_elem.ref_array(nu, start_id ,dimension*dimension);
838 val = viscA(num_face,j,elem1,diffu_c1_c2_elem);
839
840 int n0=num_face*nb_comp+c1;
841 int j0=j*nb_comp+c1;
842 int n0b=num_face*nb_comp+c2;
843 int j0b=j*nb_comp+c2;
844
845 matrice(n0,n0b)+=val*porosite_eventuelle(num_face);
846 matrice(n0,j0b)-=val*porosite_eventuelle(j);
847 matrice(j0,n0b)-=val*porosite_eventuelle(num_face);
848 matrice(j0,j0b)+=val*porosite_eventuelle(j);
849
850 int n0periob=fac_asso*nb_comp+c2;
851 matrice(j0,n0periob)-=val*porosite_eventuelle(num_face);
852 }
853 }
854 }
855 }
856 }
857 }
858 else
859 {
860 for (num_face=num1; num_face<num2; num_face++)
861 {
862 elem1 = face_voisins(num_face,0);
863 for (i=0; i<nb_faces_elem; i++)
864 {
865 if ( (j= elem_faces(elem1,i)) > num_face )
866 {
867 for(int c1=0; c1<nb_comp; c1++)
868
869 for(int c2=0; c2<nb_comp; c2++)
870 {
871
872 int diffusivity_index = c1*nb_comp + c2;
873 int start_id = elem1*nb_cols_nu+diffusivity_index*dimension*dimension;
874 ArrOfDouble diffu_c1_c2_elem;
875 diffu_c1_c2_elem.ref_array(nu, start_id ,dimension*dimension);
876 val = viscA(num_face,j,elem1,diffu_c1_c2_elem);
877
878 int n0=num_face*nb_comp+c1;
879 int j0=j*nb_comp+c1;
880 int n0b=num_face*nb_comp+c2;
881 int j0b=j*nb_comp+c2;
882
883 matrice(n0,n0b)+=val*porosite_eventuelle(num_face);
884 matrice(n0,j0b)-=val*porosite_eventuelle(j);
885 matrice(j0,n0b)-=val*porosite_eventuelle(num_face);
886 matrice(j0,j0b)+=val*porosite_eventuelle(j);
887
888 }
889 }
890 }
891 }
892 }
893 }
894 for (num_face=domaine_VEF.premiere_face_int(); num_face<n1; num_face++)
895 {
896 elem1 = face_voisins(num_face,0);
897 elem2 = face_voisins(num_face,1);
898
899 for (i=0; i<nb_faces_elem; i++)
900 {
901 if ( (j=elem_faces(elem1,i)) > num_face )
902 {
903 for(int c1=0; c1<nb_comp; c1++)
904 for(int c2=0; c2<nb_comp; c2++)
905 {
906 int diffusivity_index = c1*nb_comp + c2;
907 int start_id = elem1*nb_cols_nu+diffusivity_index*dimension*dimension;
908 ArrOfDouble diffu_c1_c2_elem;
909 diffu_c1_c2_elem.ref_array(nu, start_id ,dimension*dimension);
910 val = viscA(num_face,j,elem1,diffu_c1_c2_elem);
911
912 int n0=num_face*nb_comp+c1;
913 int j0=j*nb_comp+c1;
914 int n0b=num_face*nb_comp+c2;
915 int j0b=j*nb_comp+c2;
916
917 matrice(n0,n0b)+=val*porosite_eventuelle(num_face);
918 matrice(n0,j0b)-=val*porosite_eventuelle(j);
919 matrice(j0,n0b)-=val*porosite_eventuelle(num_face);
920 matrice(j0,j0b)+=val*porosite_eventuelle(j);
921
922
923 }
924 }
925 if (elem2!=-1)
926 if ( (j=elem_faces(elem2,i)) > num_face )
927 {
928 for(int c1=0; c1<nb_comp; c1++)
929 for(int c2=0; c2<nb_comp; c2++)
930 {
931 int diffusivity_index = c1*nb_comp + c2;
932 int start_id = elem2*nb_cols_nu+diffusivity_index*dimension*dimension;
933 ArrOfDouble diffu_c1_c2_elem;
934 diffu_c1_c2_elem.ref_array(nu, start_id ,dimension*dimension);
935 val = viscA(num_face,j,elem2,diffu_c1_c2_elem);
936
937 int n0=num_face*nb_comp+c1;
938 int j0=j*nb_comp+c1;
939 int n0b=num_face*nb_comp+c2;
940 int j0b=j*nb_comp+c2;
941
942 matrice(n0,n0b)+=val*porosite_eventuelle(num_face);
943 matrice(n0,j0b)-=val*porosite_eventuelle(j);
944 matrice(j0,n0b)-=val*porosite_eventuelle(num_face);
945 matrice(j0,j0b)+=val*porosite_eventuelle(j);
946
947 }
948 }
949 }
950 }
951 modifier_matrice_pour_periodique_apres_contribuer(matrice,equation());
952}
953
954void Op_Diff_VEF_Anisotrope_Face::contribue_au_second_membre(DoubleTab& resu ) const
955{
956 const Domaine_Cl_VEF& domaine_Cl_VEF = la_zcl_vef.valeur();
957 const Domaine_VEF& domaine_VEF = le_dom_vef.valeur();
958 int nb_comp = resu.line_size();
959 int nb_bords=domaine_VEF.nb_front_Cl();
960
961 // Partie imposee :
962 for (int n_bord=0; n_bord<nb_bords; n_bord++)
963 {
964 const Cond_lim& la_cl = domaine_Cl_VEF.les_conditions_limites(n_bord);
965 if (sub_type(Neumann_paroi,la_cl.valeur()))
966 {
967 const Neumann_paroi& la_cl_paroi = ref_cast(Neumann_paroi, la_cl.valeur());
968 const Front_VF& le_bord = ref_cast(Front_VF,la_cl->frontiere_dis());
969 int ndeb = le_bord.num_premiere_face();
970 int nfin = ndeb + le_bord.nb_faces();
971 for (int face=ndeb; face<nfin; face++)
972 for (int comp=0; comp<nb_comp; comp++)
973 resu(face,comp) += la_cl_paroi.flux_impose(face-ndeb,comp)*domaine_VEF.surface(face);
974 }
975 }
976}
977
978void Op_Diff_VEF_Anisotrope_Face::verifier() const
979{
980 static int testee=0;
981 if(testee)
982 return;
983 testee=1;
984 const Domaine_VEF& domaine_VEF = le_dom_vef.valeur();
985 // const Domaine_Cl_VEF& domaine_Cl_VEF = la_zcl_vef.valeur();
986 // const Conds_lim& les_cl = domaine_Cl_VEF.les_conditions_limites();
987 const DoubleVect& volumes_entrelaces = domaine_VEF.volumes_entrelaces();
988
989 const DoubleTab& xv=domaine_VEF.xv();
990 DoubleTab vit(equation().inconnue().valeurs());
991 DoubleTab resu(vit);
992 int i, comp;
993 if(dimension==2)
994 {
995 const int nbf = vit.dimension(0);
996 Cerr << " Verification de delta(x,0) " << finl;
997 for(i=0; i<nbf; i++)
998 {
999 vit(i,0)=xv(i,0);
1000 vit(i,1)=0;
1001 }
1002 calculer(vit, resu);
1003 for(i=0; i<nbf; i++)
1004 for(comp=0; comp<dimension; comp++)
1005 resu(i,comp)/=(volumes_entrelaces(i));
1006 for(i=0; i<nbf; i++)
1007 {
1008 if(std::fabs(resu(i,0))>1.e-10)
1009 {
1010 Cerr << " delta(x,0) ("<<i<<") = "
1011 << resu(i,0);
1012 Cerr << finl;
1013 }
1014 }
1015 Cerr << " Verification de delta(y(1-y),0) " << finl;
1016 for(i=0; i<nbf; i++)
1017 {
1018 vit(i,0)=xv(i,1)*(1-xv(i,1));
1019 vit(i,1)=0;
1020 }
1021 calculer(vit, resu);
1022 for(i=0; i<nbf; i++)
1023 for(comp=0; comp<dimension; comp++)
1024 resu(i,comp)/=(volumes_entrelaces(i));
1025 for(i=0; i<nbf; i++)
1026 {
1027 if(std::fabs(2-resu(i,0))>1.e-10)
1028 {
1029 Cerr << " delta(y(1-y),0) ("<<i<<") = "
1030 << resu(i,0);
1031 Cerr << finl;
1032 }
1033 }
1034 }
1035}
Champ_Inc_base::valeurs
DoubleTab & valeurs() override
Renvoie le tableau des valeurs du champ au temps courant.
Definition Champ_Inc_base.h:77
Champ_base
classe Champ_base Cette classe est la base de la hierarchie des champs.
Definition Champ_base.h:43
Cond_lim
classe Cond_lim Classe generique servant a representer n'importe quelle classe
Definition Cond_lim.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::face_surfaces
virtual const DoubleVect & face_surfaces() const
Definition Domaine_VF.h:51
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::xv
double xv(int num_face, int k) const
Definition Domaine_VF.h:76
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_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_externe_radiatif
classe Echange_externe_radiatif: Combines radiative (sigma * eps * (T^4 - T_ext^4)) and convective (h...
Definition Echange_externe_radiatif.h:31
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::has_emissivite
bool has_emissivite() const
Definition Echange_impose_base.h:45
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
Echange_impose_base::emissivite
double emissivite(int num) const
Renvoie la valeur de l'emissivite impose sur la i-eme composante.
Definition Echange_impose_base.cpp:150
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
Equation_base::inconnue
virtual const Champ_Inc_base & inconnue() const =0
Field_base::nature_du_champ
virtual Nature_du_champ nature_du_champ() const
Definition Field_base.h:77
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_Anisotrope_Face
Definition Op_Diff_VEF_Anisotrope_Face.h:27
Op_Diff_VEF_Anisotrope_Face::ajouter_cas_multi_scalaire
void ajouter_cas_multi_scalaire(const DoubleTab &inconnue, DoubleTab &resu, DoubleTab &flux_bords, DoubleTab &nu, const Domaine_Cl_VEF &domaine_Cl_VEF, const Domaine_VEF &domaine_VEF, int nb_comp) const
Definition Op_Diff_VEF_Anisotrope_Face.cpp:266
Op_Diff_VEF_Anisotrope_Face::ajouter
DoubleTab & ajouter(const DoubleTab &, DoubleTab &) const override
Definition Op_Diff_VEF_Anisotrope_Face.cpp:495
Op_Diff_VEF_Anisotrope_Face::associer_diffusivite
void associer_diffusivite(const Champ_base &) override
associe le champ de diffusivite
Definition Op_Diff_VEF_Anisotrope_Face.cpp:48
Op_Diff_VEF_Anisotrope_Face::ajouter_contribution
void ajouter_contribution(const DoubleTab &, Matrice_Morse &) const
Definition Op_Diff_VEF_Anisotrope_Face.cpp:535
Op_Diff_VEF_Anisotrope_Face::verifier
void verifier() const
Definition Op_Diff_VEF_Anisotrope_Face.cpp:978
Op_Diff_VEF_Anisotrope_Face::ajouter_cas_scalaire
void ajouter_cas_scalaire(const DoubleTab &inconnue, DoubleTab &resu, DoubleTab &flux_bords, DoubleTab &nu, const Domaine_Cl_VEF &domaine_Cl_VEF, const Domaine_VEF &domaine_VEF) const
Definition Op_Diff_VEF_Anisotrope_Face.cpp:63
Op_Diff_VEF_Anisotrope_Face::diffusivite
const Champ_base & diffusivite() const override
Definition Op_Diff_VEF_Anisotrope_Face.cpp:58
Op_Diff_VEF_Anisotrope_Face::ajouter_cas_vectoriel
void ajouter_cas_vectoriel(const DoubleTab &inconnue, DoubleTab &resu, DoubleTab &flux_bords, DoubleTab &nu, const Domaine_Cl_VEF &domaine_Cl_VEF, const Domaine_VEF &domaine_VEF, int nb_comp) const
Definition Op_Diff_VEF_Anisotrope_Face.cpp:254
Op_Diff_VEF_Anisotrope_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_Anisotrope_Face.cpp:53
Op_Diff_VEF_Anisotrope_Face::calculer
DoubleTab & calculer(const DoubleTab &, DoubleTab &) const override
Definition Op_Diff_VEF_Anisotrope_Face.cpp:529
Op_Diff_VEF_Anisotrope_Face::ajouter_contribution_multi_scalaire
void ajouter_contribution_multi_scalaire(const DoubleTab &, Matrice_Morse &) const
Definition Op_Diff_VEF_Anisotrope_Face.cpp:739
Op_Diff_VEF_Anisotrope_Face::contribue_au_second_membre
void contribue_au_second_membre(DoubleTab &) const
Definition Op_Diff_VEF_Anisotrope_Face.cpp:954
Op_Diff_VEF_base
class Op_Diff_VEF_base
Definition Op_Diff_VEF_base.h:39
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
Operateur_base::completer
virtual void completer()
Associe l'operateur au domaine_dis, le domaine_Cl_dis, et a l'inconnue de son equation.
Definition Operateur_base.cpp:89
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::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
Symetrie
classe Symetrie Sur les faces de symetrie on a les proprietes suivantes:
Definition Symetrie.h:37
TRUSTArray::ref_array
virtual void ref_array(TRUSTArray &, _SIZE_ start=0, _SIZE_ sz=-1)
Definition TRUSTArray.tpp:103
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
TRUSTVect::line_size
int line_size() const
Definition TRUSTVect.tpp:67