TrioCFD 1.9.9_beta
TrioCFD documentation
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 Associate the diffusivity field.
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 // ensure we have a two-dimensional array
70 assert(nu.nb_dim()==2);
71 // ensure correct number of components for anisotropy (9 for 3d and 4 for 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 // Size and initialize the flux balance array:
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 // Process boundary faces
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) // real face
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 // There is only one component, so this is a scalar equation (not velocity): no need to use
127 // the tangential tau (wall thermal laws do not compute turbulent wall exchange for now
128 {
129 for (ind_face=num1; ind_face<num2; ind_face++)
130 {
131 num_face = le_bord.num_face(ind_face);
132 int elem = face_voisins(num_face,0);
133
134 for (i=0; i<nb_faces_elem; i++)
135 {
136 if (( (j= elemfaces(elem,i)) > num_face ) || (ind_face>=nb_faces_bord_reel))
137 {
138 valA = viscA(num_face,j,elem,nu);
139
140 if (ind_face<nb_faces_bord_reel)
141 {
142 flux=valA*(inconnue(j)-inconnue(num_face));
143 // PL : this is indeed a minus sign here for flux_bords. This value is then
144 // overwritten for Neumann boundaries and is therefore only used for
145 // Dirichlet boundaries where the control volume is zero
146 tab_flux_bords(num_face,0)-=flux;
147 resu(num_face)+=flux;
148 }
149
150 if(j<nb_faces) // real face
151 {
152 flux=valA*(inconnue(num_face)-inconnue(j));
153 if (j<premiere_face_int)
154 tab_flux_bords(j,0)-=flux;
155 resu(j)+=flux;
156 }
157 }
158 }
159 }
160 }
161 }
162
163 // Faces internes :
164 for (num_face=premiere_face_int; num_face<nb_faces; num_face++)
165 {
166 for (int k=0; k<2; k++)
167 {
168 int elem = face_voisins(num_face,k);
169 {
170 for (i=0; i<nb_faces_elem; i++)
171 {
172 j=elemfaces(elem,i);
173 if ( j > num_face )
174 {
175 int el1,el2;
176 int contrib=1;
177 if(j>=nb_faces) // This is a virtual face
178 {
179 el1 = face_voisins(j,0);
180 el2 = face_voisins(j,1);
181 if((el1==-1)||(el2==-1))
182 contrib=0;
183 }
184 if(contrib)
185 {
186 valA = viscA(num_face,j,elem,nu);
187 resu(num_face)+=valA*inconnue(j);
188 resu(num_face)-=valA*inconnue(num_face);
189 if(j<nb_faces) // Process real faces only
190 {
191 resu(j)+=valA*inconnue(num_face);
192 resu(j)-=valA*inconnue(j);
193 }
194 }
195 }
196 }
197 }
198 }
199 }
200
201 // Neumann :
202 for (n_bord=0; n_bord<nb_bords; n_bord++)
203 {
204 const Cond_lim& la_cl = domaine_Cl_VEF.les_conditions_limites(n_bord);
205
206 if (sub_type(Neumann_paroi,la_cl.valeur()))
207 {
208 const Neumann_paroi& la_cl_paroi = ref_cast(Neumann_paroi, la_cl.valeur());
209 const Front_VF& le_bord = ref_cast(Front_VF,la_cl->frontiere_dis());
210 int ndeb = le_bord.num_premiere_face();
211 int nfin = ndeb + le_bord.nb_faces();
212 for (int face=ndeb; face<nfin; face++)
213 {
214 flux=la_cl_paroi.flux_impose(face-ndeb)*domaine_VEF.surface(face);
215 resu[face] += flux;
216 tab_flux_bords(face,0) = flux;
217 }
218 }
219 else if (sub_type(Echange_externe_impose,la_cl.valeur()))
220 {
221 const Echange_externe_impose& la_cl_paroi = ref_cast(Echange_externe_impose, la_cl.valeur());
222 const Front_VF& le_bord = ref_cast(Front_VF,la_cl->frontiere_dis());
223 int ndeb = le_bord.num_premiere_face();
224 int nfin = ndeb + le_bord.nb_faces();
225 for (int face=ndeb; face<nfin; face++)
226 {
227 flux=la_cl_paroi.h_imp(face-ndeb)*(la_cl_paroi.T_ext(face-ndeb)-inconnue(face))*domaine_VEF.surface(face);
228 resu[face] += flux;
229 tab_flux_bords(face,0) = flux;
230 if (la_cl_paroi.has_emissivite())
231 {
232 const double text = la_cl_paroi.T_ext(face - ndeb), T = inconnue(face);
233 flux = COEFF_STEFAN_BOLTZMANN * la_cl_paroi.emissivite(face - ndeb) * (text * text * text * text - T * T * T * T) * domaine_VEF.face_surfaces(face);
234 resu[face] += flux;
235 tab_flux_bords(face, 0) += flux;
236 }
237 }
238 }
239 else if (sub_type(Neumann_homogene,la_cl.valeur())
240 || sub_type(Symetrie,la_cl.valeur())
241 || sub_type(Neumann_sortie_libre,la_cl.valeur()))
242 {
243 const Front_VF& le_bord = ref_cast(Front_VF,la_cl->frontiere_dis());
244 int ndeb = le_bord.num_premiere_face();
245 int nfin = ndeb + le_bord.nb_faces();
246 for (int face=ndeb; face<nfin; face++)
247 tab_flux_bords(face,0) = 0.;
248 }
249 }
250}
251
252void Op_Diff_VEF_Anisotrope_Face::ajouter_cas_vectoriel(const DoubleTab& inconnue,
253 DoubleTab& resu, DoubleTab& tab_flux_bords,
254 DoubleTab& nu,
255 const Domaine_Cl_VEF& domaine_Cl_VEF,
256 const Domaine_VEF& domaine_VEF,
257 int nb_comp) const
258{
259 Cerr << "Error in Op_Diff_VEF_Anisotrope_Face::ajouter_cas_vectoriel()" << finl;
260 Cerr << "This case is not coded yet" << finl;
261 Process::exit(-1);
262}
263
264void Op_Diff_VEF_Anisotrope_Face::ajouter_cas_multi_scalaire(const DoubleTab& inconnue,
265 DoubleTab& resu, DoubleTab& tab_flux_bords,
266 DoubleTab& nu,
267 const Domaine_Cl_VEF& domaine_Cl_VEF,
268 const Domaine_VEF& domaine_VEF,
269 int nb_comp) const
270{
271 const int nb_cols_nu = nu.dimension(1);
272 assert(nb_cols_nu == dimension*dimension*nb_comp*nb_comp);
273
274 const IntTab& elemfaces = domaine_VEF.elem_faces();
275 const IntTab& face_voisins = domaine_VEF.face_voisins();
276 int i0,j,num_face;
277 int nb_faces = domaine_VEF.nb_faces();
278 int n_bord;
279 int nb_faces_elem = domaine_VEF.domaine().nb_faces_elem();
280 double valA,flux0;
281 //DoubleVect n(Objet_U::dimension);
282 //DoubleTrav Tgrad(Objet_U::dimension,Objet_U::dimension);
283
284 // dimensionning and initializing flow balance tabulars
285 tab_flux_bords.resize(domaine_VEF.nb_faces_bord(),nb_comp);
286 tab_flux_bords=0.;
287 assert( nb_comp>1 );
288 int nb_bords=domaine_VEF.nb_front_Cl();
289 int ind_face;
290
291 for (n_bord=0; n_bord<nb_bords; n_bord++)
292 {
293 const Cond_lim& la_cl = domaine_Cl_VEF.les_conditions_limites(n_bord);
294 const Front_VF& le_bord = ref_cast(Front_VF,la_cl->frontiere_dis());
295
296 int num1 = 0;
297 int num2 = le_bord.nb_faces_tot();
298 int nb_faces_bord_reel = le_bord.nb_faces();
299
300 //periodic case
301 if (sub_type(Periodique,la_cl.valeur()))
302 {
303 const Periodique& la_cl_perio = ref_cast(Periodique,la_cl.valeur());
304 int fac_asso;
305 for (ind_face=num1; ind_face<nb_faces_bord_reel; ind_face++)
306 {
307 fac_asso = la_cl_perio.face_associee(ind_face);
308 fac_asso = le_bord.num_face(fac_asso);
309 num_face = le_bord.num_face(ind_face);
310 for (int kk=0; kk<2; kk++)
311 {
312 int elem = face_voisins(num_face, kk);
313 for (i0=0; i0<nb_faces_elem; i0++)
314 {
315 if ( ( (j= elemfaces(elem,i0)) > num_face ) && (j != fac_asso ) )
316 {
317 for(int c1=0; c1<nb_comp; c1++)
318 {
319 for(int c2=0; c2<nb_comp; c2++)
320 {
321 int diffusivity_index = c1*nb_comp + c2;
322 int start_id = elem*nb_cols_nu+diffusivity_index*dimension*dimension;
323 ArrOfDouble diffu_c1_c2_elem;
324 diffu_c1_c2_elem.ref_array(nu, start_id ,dimension*dimension);
325 valA = viscA(num_face,j,elem,diffu_c1_c2_elem);
326
327 resu(num_face,c1)+=valA*inconnue(j,c2);
328 resu(num_face,c1)-=valA*inconnue(num_face,c2);
329 if(j<nb_faces) // real face
330 {
331 resu(j,c1)+=0.5*valA*inconnue(num_face,c2);
332 resu(j,c1)-=0.5*valA*inconnue(j,c2);
333 }
334 }
335 }
336 }
337 }//loop over i0 (nb_faces) for elem1
338 }//loop over kk
339 } // ind face
340 }// end periodic
341 else
342 {
343 for (ind_face=num1; ind_face<num2; ind_face++)
344 {
345 num_face = le_bord.num_face(ind_face);
346 int elem=face_voisins(num_face,0);
347
348 // Loop over faces :
349 for (int i=0; i<nb_faces_elem; i++)
350 if (( (j= elemfaces(elem,i)) > num_face ) || (ind_face>=nb_faces_bord_reel))
351 {
352 for(int c1=0; c1<nb_comp; c1++)
353 {
354 for(int c2=0; c2<nb_comp; c2++)
355 {
356 int diffusivity_index = c1*nb_comp + c2;
357 int start_id = elem*nb_cols_nu+diffusivity_index*dimension*dimension;
358 ArrOfDouble diffu_c1_c2_elem;
359 diffu_c1_c2_elem.ref_array(nu, start_id ,dimension*dimension);
360 valA = viscA(num_face,j,elem,diffu_c1_c2_elem);
361
362 if (ind_face<nb_faces_bord_reel)
363 {
364 double flux=valA*(inconnue(j,c2)-inconnue(num_face,c2));
365 resu(num_face,c1)+=flux;
366 tab_flux_bords(num_face,c1)+=flux;
367 }
368 if(j<nb_faces) // real faces
369 {
370 resu(j,c1)+=valA*inconnue(num_face,c2);
371 resu(j,c1)-=valA*inconnue(j,c2);
372 }
373 }// loop c2
374 }// loop c1
375 } // j
376 }//end of ind_face loop
377 }//else
378 }//end for the boundaries loop
379
380 // dealing now with internal faces
381
382
383 for (num_face=domaine_VEF.premiere_face_int(); num_face<nb_faces; num_face++)
384 {
385 for (int k=0; k<2; k++)
386 {
387 int elem = face_voisins(num_face,k);
388 for (i0=0; i0<nb_faces_elem; i0++)
389 {
390 if ( (j= elemfaces(elem,i0)) > num_face )
391 {
392 int el1,el2;
393 int contrib=1;
394 if(j>=nb_faces) // it is a virtual face
395 {
396 el1 = face_voisins(j,0);
397 el2 = face_voisins(j,1);
398 if((el1==-1)||(el2==-1))
399 contrib=0;
400 }
401 if(contrib)
402 {
403 for(int c1=0; c1<nb_comp; c1++)
404
405 for(int c2=0; c2<nb_comp; c2++)
406 {
407 int diffusivity_index = c1*nb_comp + c2;
408 int start_id = elem*nb_cols_nu+diffusivity_index*dimension*dimension;
409 ArrOfDouble diffu_c1_c2_elem;
410 diffu_c1_c2_elem.ref_array(nu, start_id ,dimension*dimension);
411 valA = viscA(num_face,j,elem,diffu_c1_c2_elem);
412
413 resu(num_face,c1)+=valA*inconnue(j,c2);
414 resu(num_face,c1)-=valA*inconnue(num_face,c2);
415 if(j<nb_faces) // dealing with real faces
416 {
417 resu(j,c1)+=valA*inconnue(num_face,c2);
418 resu(j,c1)-=valA*inconnue(j,c2);
419 }
420 else
421 {
422 //the face is virtual
423 }
424 }
425 }
426 }
427 }//loop i0 over elem faces
428 }//loop over k
429 }//loop over faces
430
431
432 // Neumann
433 //Based on what is done for the scalar case
434 for (n_bord=0; n_bord<nb_bords; n_bord++)
435 {
436 const Cond_lim& la_cl = domaine_Cl_VEF.les_conditions_limites(n_bord);
437
438 if (sub_type(Neumann_paroi,la_cl.valeur()))
439 {
440 const Neumann_paroi& la_cl_paroi = ref_cast(Neumann_paroi, la_cl.valeur());
441 const Front_VF& le_bord = ref_cast(Front_VF,la_cl->frontiere_dis());
442 int ndeb = le_bord.num_premiere_face();
443 int nfin = ndeb + le_bord.nb_faces();
444 for (int face=ndeb; face<nfin; face++)
445 {
446 for (int nc=0; nc<nb_comp; nc++)
447 {
448 flux0=la_cl_paroi.flux_impose(face-ndeb,nc)*domaine_VEF.surface(face);
449 resu(face,nc) += flux0;
450 tab_flux_bords(face,nc) = flux0;
451 }
452 }
453 }
454 else if (sub_type(Echange_externe_impose,la_cl.valeur()))
455 {
456 const Echange_externe_impose& la_cl_paroi = ref_cast(Echange_externe_impose, la_cl.valeur());
457 const Front_VF& le_bord = ref_cast(Front_VF,la_cl->frontiere_dis());
458 int ndeb = le_bord.num_premiere_face();
459 int nfin = ndeb + le_bord.nb_faces();
460 for (int face=ndeb; face<nfin; face++)
461 {
462 for (int nc=0; nc<nb_comp; nc++)
463 {
464 flux0=la_cl_paroi.h_imp(face-ndeb,nc)*(la_cl_paroi.T_ext(face-ndeb,nc)-inconnue(face,nc))*domaine_VEF.surface(face);
465 resu(face,nc) += flux0;
466 tab_flux_bords(face,nc) = flux0;
467
468 if (la_cl_paroi.has_emissivite())
469 {
470 const double text = la_cl_paroi.T_ext(face - ndeb, nc), T = inconnue(face, nc);
471 flux0 = COEFF_STEFAN_BOLTZMANN * la_cl_paroi.emissivite(face - ndeb, nc) * (text * text * text * text - T * T * T * T) * domaine_VEF.face_surfaces(face);
472 resu(face, nc) += flux0;
473 tab_flux_bords(face, nc) += flux0;
474 }
475 }
476 }
477 }
478 else if (sub_type(Neumann_homogene,la_cl.valeur())
479 || sub_type(Symetrie,la_cl.valeur())
480 || sub_type(Neumann_sortie_libre,la_cl.valeur()))
481 {
482 const Front_VF& le_bord = ref_cast(Front_VF,la_cl->frontiere_dis());
483 int ndeb = le_bord.num_premiere_face();
484 int nfin = ndeb + le_bord.nb_faces();
485 for (int face=ndeb; face<nfin; face++)
486 for (int nc=0; nc<nb_comp; nc++)
487 tab_flux_bords(face,nc) = 0.;
488 }
489 }
490}
491
492
493DoubleTab& Op_Diff_VEF_Anisotrope_Face::ajouter(const DoubleTab& inconnue_org, DoubleTab& resu) const
494{
495 remplir_nu(nu_);
496 const Domaine_Cl_VEF& domaine_Cl_VEF = la_zcl_vef.valeur();
497 const Domaine_VEF& domaine_VEF = le_dom_vef.valeur();
498
499 int nb_comp = 1;
500 int nb_dim = resu.nb_dim();
501 if(nb_dim==2)
502 nb_comp=resu.dimension(1);
503 DoubleTab nu;
504 DoubleTab tab_inconnue;
505 int marq=phi_psi_diffuse(equation());
506 const DoubleVect& porosite_face = equation().milieu().porosite_face();
507 const DoubleVect& porosite_elem = equation().milieu().porosite_elem();
508 // either div(phi nu grad inco)
509 // or div(nu grad phi inco)
510 // depending on whether phi_psi or psi is diffused
511 modif_par_porosite_si_flag(nu_,nu,!marq,porosite_elem);
512 const DoubleTab& inconnue=modif_par_porosite_si_flag(inconnue_org,tab_inconnue,marq,porosite_face);
513
514 const Champ_base& inco = equation().inconnue();
515 const Nature_du_champ nature_champ = inco.nature_du_champ();
516 if(nature_champ==scalaire)
517 ajouter_cas_scalaire(inconnue, resu, flux_bords_, nu, domaine_Cl_VEF, domaine_VEF);
518 else if (nature_champ==vectoriel)
519 ajouter_cas_vectoriel(inconnue, resu, flux_bords_, nu, domaine_Cl_VEF, domaine_VEF,nb_comp);
520 else if (nature_champ==multi_scalaire)
521 ajouter_cas_multi_scalaire(inconnue, resu, flux_bords_, nu, domaine_Cl_VEF, domaine_VEF,nb_comp);
522 modifier_flux(*this);
523
524 return resu;
525}
526
527DoubleTab& Op_Diff_VEF_Anisotrope_Face::calculer(const DoubleTab& inconnue, DoubleTab& resu) const
528{
529 resu = 0;
530 return ajouter(inconnue,resu);
531}
532
533void Op_Diff_VEF_Anisotrope_Face::ajouter_contribution(const DoubleTab& transporte, Matrice_Morse& matrice) const
534{
535
536 modifier_matrice_pour_periodique_avant_contribuer(matrice,equation());
537 // Fill the nu array because matrix assembly with ajouter_contribution
538 // may be performed before the first time step
539 remplir_nu(nu_);
540 const Domaine_Cl_VEF& domaine_Cl_VEF = la_zcl_vef.valeur();
541 const Domaine_VEF& domaine_VEF = le_dom_vef.valeur();
542 const IntTab& elem_faces = domaine_VEF.elem_faces();
543 const IntTab& face_voisins = domaine_VEF.face_voisins();
544
545 int n1 = domaine_VEF.nb_faces();
546 int nb_comp = 1;
547 int nb_dim = transporte.nb_dim();
548
549 DoubleTab nu;
550 int marq=phi_psi_diffuse(equation());
551 const DoubleVect& porosite_elem = equation().milieu().porosite_elem();
552
553 // either div(phi nu grad inco)
554 // or div(nu grad phi inco)
555 // depending on whether phi_psi or psi is diffused
556 modif_par_porosite_si_flag(nu_,nu,!marq,porosite_elem);
557 DoubleVect porosite_eventuelle(equation().milieu().porosite_face());
558 if (!marq)
559 porosite_eventuelle=1;
560
561
562 if(nb_dim==2)
563 nb_comp=transporte.dimension(1);
564
565 int i,j,num_face;
566 int elem1,elem2;
567 int nb_faces_elem = domaine_VEF.domaine().nb_faces_elem();
568 double val;
569
570 int nb_bords=domaine_VEF.nb_front_Cl();
571 for (int n_bord=0; n_bord<nb_bords; n_bord++)
572 {
573 const Cond_lim& la_cl = domaine_Cl_VEF.les_conditions_limites(n_bord);
574 const Front_VF& le_bord = ref_cast(Front_VF,la_cl->frontiere_dis());
575 int num1 = le_bord.num_premiere_face();
576 int num2 = num1 + le_bord.nb_faces();
577
578 if (sub_type(Periodique,la_cl.valeur()))
579 {
580 const Periodique& la_cl_perio = ref_cast(Periodique,la_cl.valeur());
581 int fac_asso;
582 // only iterate over half the periodic faces
583 // the result will be copied to the associated face at the end..
584 int num2b=num1+le_bord.nb_faces()/2;
585 for (num_face=num1; num_face<num2b; num_face++)
586 {
587 elem1 = face_voisins(num_face,0);
588 elem2 = face_voisins(num_face,1);
589 fac_asso = la_cl_perio.face_associee(num_face-num1)+num1;
590 for (i=0; i<nb_faces_elem; i++)
591 {
592 if ( (j=elem_faces(elem1,i)) > num_face )
593 {
594 val = viscA(num_face,j,elem1,nu);
595 for (int nc=0; nc<nb_comp; nc++)
596 {
597 int n0=num_face*nb_comp+nc;
598 int j0=j*nb_comp+nc;
599
600 matrice(n0,n0)+=val*porosite_eventuelle(num_face);
601 matrice(n0,j0)-=val*porosite_eventuelle(j);
602 matrice(j0,n0)-=val*porosite_eventuelle(num_face);
603 matrice(j0,j0)+=val*porosite_eventuelle(j);
604
605 }
606 }
607 if (elem2!=-1)
608 if ( (j=elem_faces(elem2,i)) > num_face )
609 {
610 val= viscA(num_face,j,elem2,nu);
611 for (int nc=0; nc<nb_comp; nc++)
612 {
613 int n0=num_face*nb_comp+nc;
614 int j0=j*nb_comp+nc;
615 int n0perio=fac_asso*nb_comp+nc;
616 matrice(n0,n0)+=val*porosite_eventuelle(num_face);
617 matrice(n0,j0)-=val*porosite_eventuelle(j);
618 matrice(j0,n0perio)-=val*porosite_eventuelle(num_face);
619 matrice(j0,j0)+=val*porosite_eventuelle(j);
620
621 }
622 }
623 }
624 }
625
626 }
627 else
628 {
629 for (num_face=num1; num_face<num2; num_face++)
630 {
631 elem1 = face_voisins(num_face,0);
632 for (i=0; i<nb_faces_elem; i++)
633 {
634 if ( (j= elem_faces(elem1,i)) > num_face )
635 {
636 val = viscA(num_face,j,elem1,nu);
637 for (int nc=0; nc<nb_comp; nc++)
638 {
639 int n0=num_face*nb_comp+nc;
640 int j0=j*nb_comp+nc;
641
642 matrice(n0,n0)+=val*porosite_eventuelle(num_face);
643 matrice(n0,j0)-=val*porosite_eventuelle(j);
644 matrice(j0,n0)-=val*porosite_eventuelle(num_face);
645 matrice(j0,j0)+=val*porosite_eventuelle(j);
646
647 }
648 }
649 }
650 }
651 }
652 }
653 int n0 = domaine_VEF.premiere_face_int();
654 for (num_face=n0; num_face<n1; num_face++)
655 {
656 elem1 = face_voisins(num_face,0);
657 elem2 = face_voisins(num_face,1);
658
659 for (i=0; i<nb_faces_elem; i++)
660 {
661 if ( (j=elem_faces(elem1,i)) > num_face )
662 {
663 val = viscA(num_face,j,elem1,nu);
664 for (int nc=0; nc<nb_comp; nc++)
665 {
666 int nn0=num_face*nb_comp+nc;
667 int j0=j*nb_comp+nc;
668
669 matrice(nn0,nn0)+=val*porosite_eventuelle(num_face);
670 matrice(nn0,j0)-=val*porosite_eventuelle(j);
671 matrice(j0,nn0)-=val*porosite_eventuelle(num_face);
672 matrice(j0,j0)+=val*porosite_eventuelle(j);
673
674 }
675 }
676 if (elem2!=-1)
677 if ( (j=elem_faces(elem2,i)) > num_face )
678 {
679 val= viscA(num_face,j,elem2,nu);
680 for (int nc=0; nc<nb_comp; nc++)
681 {
682 int nn0=num_face*nb_comp+nc;
683 int j0=j*nb_comp+nc;
684
685 matrice(nn0,nn0)+=val*porosite_eventuelle(num_face);
686 matrice(nn0,j0)-=val*porosite_eventuelle(j);
687 matrice(j0,nn0)-=val*porosite_eventuelle(num_face);
688 matrice(j0,j0)+=val*porosite_eventuelle(j);
689
690 }
691 }
692 }
693 }
694 // Neumann :
695 for (int 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
699 if (sub_type(Neumann_paroi,la_cl.valeur()))
700 {
701 }
702 else if (sub_type(Echange_externe_impose,la_cl.valeur()))
703 {
704 const Echange_externe_impose& la_cl_paroi = ref_cast(Echange_externe_impose, la_cl.valeur());
705 const Front_VF& le_bord = ref_cast(Front_VF,la_cl->frontiere_dis());
706 int ndeb = le_bord.num_premiere_face();
707 int nfin = ndeb + le_bord.nb_faces();
708 for (int face=ndeb; face<nfin; face++)
709 {
710 matrice(face,face) += la_cl_paroi.h_imp(face-ndeb)*domaine_VEF.face_surfaces(face);
711 }
712 }
713 else if (sub_type(Echange_externe_radiatif,la_cl.valeur()))
714 {
715 const Echange_externe_radiatif& la_cl_paroi = ref_cast(Echange_externe_radiatif, la_cl.valeur());
716 const Front_VF& le_bord = ref_cast(Front_VF,la_cl->frontiere_dis());
717 int ndeb = le_bord.num_premiere_face();
718 int nfin = ndeb + le_bord.nb_faces();
719 for (int face=ndeb; face<nfin; face++)
720 {
721 const DoubleTab& inconnue = equation().inconnue().valeurs();
722
723 const double T = inconnue(face);
724 matrice(face,face) += 4 * COEFF_STEFAN_BOLTZMANN * la_cl_paroi.emissivite(face-ndeb) * T * T * T *domaine_VEF.face_surfaces(face);
725 }
726 }
727 else if (sub_type(Neumann_homogene,la_cl.valeur())
728 || sub_type(Symetrie,la_cl.valeur())
729 || sub_type(Neumann_sortie_libre,la_cl.valeur()))
730 {
731 }
732 }
733 modifier_matrice_pour_periodique_apres_contribuer(matrice,equation());
734}
735
736void Op_Diff_VEF_Anisotrope_Face::ajouter_contribution_multi_scalaire(const DoubleTab& transporte, Matrice_Morse& matrice) const
737{
738 modifier_matrice_pour_periodique_avant_contribuer(matrice,equation());
739 // Fill the nu array because matrix assembly with ajouter_contribution
740 // may be performed before the first time step
741 remplir_nu(nu_);
742 const Domaine_Cl_VEF& domaine_Cl_VEF = la_zcl_vef.valeur();
743 const Domaine_VEF& domaine_VEF = le_dom_vef.valeur();
744 const IntTab& elem_faces = domaine_VEF.elem_faces();
745 const IntTab& face_voisins = domaine_VEF.face_voisins();
746
747 int n1 = domaine_VEF.nb_faces();
748 int nb_comp = 1;
749 int nb_dim = transporte.nb_dim();
750
751 DoubleTab nu;
752 int marq=phi_psi_diffuse(equation());
753 const DoubleVect& porosite_elem = equation().milieu().porosite_elem();
754
755 // either div(phi nu grad inco)
756 // or div(nu grad phi inco)
757 // depending on whether phi_psi or psi is diffused
758 modif_par_porosite_si_flag(nu_,nu,!marq,porosite_elem);
759 DoubleVect porosite_eventuelle(equation().milieu().porosite_face());
760 if (!marq)
761 porosite_eventuelle=1;
762
763
764 if(nb_dim==2)
765 nb_comp=transporte.dimension(1);
766
767 const int nb_cols_nu = nu.dimension(1);
768 assert(nb_cols_nu == dimension*dimension*nb_comp*nb_comp);
769
770 int i,j,num_face;
771 int elem1,elem2;
772 int nb_faces_elem = domaine_VEF.domaine().nb_faces_elem();
773 double val;
774
775 int nb_bords=domaine_VEF.nb_front_Cl();
776 for (int n_bord=0; n_bord<nb_bords; n_bord++)
777 {
778 const Cond_lim& la_cl = domaine_Cl_VEF.les_conditions_limites(n_bord);
779 const Front_VF& le_bord = ref_cast(Front_VF,la_cl->frontiere_dis());
780 int num1 = le_bord.num_premiere_face();
781 int num2 = num1 + le_bord.nb_faces();
782 if (sub_type(Periodique,la_cl.valeur()))
783 {
784 const Periodique& la_cl_perio = ref_cast(Periodique,la_cl.valeur());
785 int fac_asso;
786 // only iterate over half the periodic faces
787 // the result will be copied to the associated face at the end..
788 int num2b=num1+le_bord.nb_faces()/2;
789 for (num_face=num1; num_face<num2b; num_face++)
790 {
791 elem1 = face_voisins(num_face,0);
792 elem2 = face_voisins(num_face,1);
793 fac_asso = la_cl_perio.face_associee(num_face-num1)+num1;
794 for (i=0; i<nb_faces_elem; i++)
795 {
796 if ( (j=elem_faces(elem1,i)) > num_face )
797 {
798 for(int c1=0; c1<nb_comp; c1++)
799 for(int c2=0; c2<nb_comp; c2++)
800 {
801
802 int diffusivity_index = c1*nb_comp + c2;
803 int start_id = elem1*nb_cols_nu+diffusivity_index*dimension*dimension;
804 ArrOfDouble diffu_c1_c2_elem;
805 diffu_c1_c2_elem.ref_array(nu, start_id ,dimension*dimension);
806 val = viscA(num_face,j,elem1,diffu_c1_c2_elem);
807
808 int n0=num_face*nb_comp+c1;
809 int j0=j*nb_comp+c1;
810 int n0b=num_face*nb_comp+c2;
811 int j0b=j*nb_comp+c2;
812
813 matrice(n0,n0b)+=val*porosite_eventuelle(num_face);
814 matrice(n0,j0b)-=val*porosite_eventuelle(j);
815 matrice(j0,n0b)-=val*porosite_eventuelle(num_face);
816 matrice(j0,j0b)+=val*porosite_eventuelle(j);
817
818
819 }
820 }
821 if (elem2!=-1)
822 if ( (j=elem_faces(elem2,i)) > num_face )
823 {
824 for (int nc=0; nc<nb_comp; nc++)
825 {
826 for(int c1=0; c1<nb_comp; c1++)
827 for(int c2=0; c2<nb_comp; c2++)
828 {
829
830 int diffusivity_index = c1*nb_comp + c2;
831 int start_id = elem1*nb_cols_nu+diffusivity_index*dimension*dimension;
832 ArrOfDouble diffu_c1_c2_elem;
833 diffu_c1_c2_elem.ref_array(nu, start_id ,dimension*dimension);
834 val = viscA(num_face,j,elem1,diffu_c1_c2_elem);
835
836 int n0=num_face*nb_comp+c1;
837 int j0=j*nb_comp+c1;
838 int n0b=num_face*nb_comp+c2;
839 int j0b=j*nb_comp+c2;
840
841 matrice(n0,n0b)+=val*porosite_eventuelle(num_face);
842 matrice(n0,j0b)-=val*porosite_eventuelle(j);
843 matrice(j0,n0b)-=val*porosite_eventuelle(num_face);
844 matrice(j0,j0b)+=val*porosite_eventuelle(j);
845
846 int n0periob=fac_asso*nb_comp+c2;
847 matrice(j0,n0periob)-=val*porosite_eventuelle(num_face);
848 }
849 }
850 }
851 }
852 }
853 }
854 else
855 {
856 for (num_face=num1; num_face<num2; num_face++)
857 {
858 elem1 = face_voisins(num_face,0);
859 for (i=0; i<nb_faces_elem; i++)
860 {
861 if ( (j= elem_faces(elem1,i)) > num_face )
862 {
863 for(int c1=0; c1<nb_comp; c1++)
864
865 for(int c2=0; c2<nb_comp; c2++)
866 {
867
868 int diffusivity_index = c1*nb_comp + c2;
869 int start_id = elem1*nb_cols_nu+diffusivity_index*dimension*dimension;
870 ArrOfDouble diffu_c1_c2_elem;
871 diffu_c1_c2_elem.ref_array(nu, start_id ,dimension*dimension);
872 val = viscA(num_face,j,elem1,diffu_c1_c2_elem);
873
874 int n0=num_face*nb_comp+c1;
875 int j0=j*nb_comp+c1;
876 int n0b=num_face*nb_comp+c2;
877 int j0b=j*nb_comp+c2;
878
879 matrice(n0,n0b)+=val*porosite_eventuelle(num_face);
880 matrice(n0,j0b)-=val*porosite_eventuelle(j);
881 matrice(j0,n0b)-=val*porosite_eventuelle(num_face);
882 matrice(j0,j0b)+=val*porosite_eventuelle(j);
883
884 }
885 }
886 }
887 }
888 }
889 }
890 for (num_face=domaine_VEF.premiere_face_int(); num_face<n1; num_face++)
891 {
892 elem1 = face_voisins(num_face,0);
893 elem2 = face_voisins(num_face,1);
894
895 for (i=0; i<nb_faces_elem; i++)
896 {
897 if ( (j=elem_faces(elem1,i)) > num_face )
898 {
899 for(int c1=0; c1<nb_comp; c1++)
900 for(int c2=0; c2<nb_comp; c2++)
901 {
902 int diffusivity_index = c1*nb_comp + c2;
903 int start_id = elem1*nb_cols_nu+diffusivity_index*dimension*dimension;
904 ArrOfDouble diffu_c1_c2_elem;
905 diffu_c1_c2_elem.ref_array(nu, start_id ,dimension*dimension);
906 val = viscA(num_face,j,elem1,diffu_c1_c2_elem);
907
908 int n0=num_face*nb_comp+c1;
909 int j0=j*nb_comp+c1;
910 int n0b=num_face*nb_comp+c2;
911 int j0b=j*nb_comp+c2;
912
913 matrice(n0,n0b)+=val*porosite_eventuelle(num_face);
914 matrice(n0,j0b)-=val*porosite_eventuelle(j);
915 matrice(j0,n0b)-=val*porosite_eventuelle(num_face);
916 matrice(j0,j0b)+=val*porosite_eventuelle(j);
917
918
919 }
920 }
921 if (elem2!=-1)
922 if ( (j=elem_faces(elem2,i)) > num_face )
923 {
924 for(int c1=0; c1<nb_comp; c1++)
925 for(int c2=0; c2<nb_comp; c2++)
926 {
927 int diffusivity_index = c1*nb_comp + c2;
928 int start_id = elem2*nb_cols_nu+diffusivity_index*dimension*dimension;
929 ArrOfDouble diffu_c1_c2_elem;
930 diffu_c1_c2_elem.ref_array(nu, start_id ,dimension*dimension);
931 val = viscA(num_face,j,elem2,diffu_c1_c2_elem);
932
933 int n0=num_face*nb_comp+c1;
934 int j0=j*nb_comp+c1;
935 int n0b=num_face*nb_comp+c2;
936 int j0b=j*nb_comp+c2;
937
938 matrice(n0,n0b)+=val*porosite_eventuelle(num_face);
939 matrice(n0,j0b)-=val*porosite_eventuelle(j);
940 matrice(j0,n0b)-=val*porosite_eventuelle(num_face);
941 matrice(j0,j0b)+=val*porosite_eventuelle(j);
942
943 }
944 }
945 }
946 }
947 modifier_matrice_pour_periodique_apres_contribuer(matrice,equation());
948}
949
950void Op_Diff_VEF_Anisotrope_Face::contribue_au_second_membre(DoubleTab& resu ) const
951{
952 const Domaine_Cl_VEF& domaine_Cl_VEF = la_zcl_vef.valeur();
953 const Domaine_VEF& domaine_VEF = le_dom_vef.valeur();
954 int nb_comp = resu.line_size();
955 int nb_bords=domaine_VEF.nb_front_Cl();
956
957 // Partie imposee :
958 for (int n_bord=0; n_bord<nb_bords; n_bord++)
959 {
960 const Cond_lim& la_cl = domaine_Cl_VEF.les_conditions_limites(n_bord);
961 if (sub_type(Neumann_paroi,la_cl.valeur()))
962 {
963 const Neumann_paroi& la_cl_paroi = ref_cast(Neumann_paroi, la_cl.valeur());
964 const Front_VF& le_bord = ref_cast(Front_VF,la_cl->frontiere_dis());
965 int ndeb = le_bord.num_premiere_face();
966 int nfin = ndeb + le_bord.nb_faces();
967 for (int face=ndeb; face<nfin; face++)
968 for (int comp=0; comp<nb_comp; comp++)
969 resu(face,comp) += la_cl_paroi.flux_impose(face-ndeb,comp)*domaine_VEF.surface(face);
970 }
971 }
972}
973
974void Op_Diff_VEF_Anisotrope_Face::verifier() const
975{
976 static int testee=0;
977 if(testee)
978 return;
979 testee=1;
980 const Domaine_VEF& domaine_VEF = le_dom_vef.valeur();
981 // const Domaine_Cl_VEF& domaine_Cl_VEF = la_zcl_vef.valeur();
982 // const Conds_lim& les_cl = domaine_Cl_VEF.les_conditions_limites();
983 const DoubleVect& volumes_entrelaces = domaine_VEF.volumes_entrelaces();
984
985 const DoubleTab& xv=domaine_VEF.xv();
986 DoubleTab vit(equation().inconnue().valeurs());
987 DoubleTab resu(vit);
988 int i, comp;
989 if(dimension==2)
990 {
991 const int nbf = vit.dimension(0);
992 Cerr << " Verification of delta(x,0) " << finl;
993 for(i=0; i<nbf; i++)
994 {
995 vit(i,0)=xv(i,0);
996 vit(i,1)=0;
997 }
998 calculer(vit, resu);
999 for(i=0; i<nbf; i++)
1000 for(comp=0; comp<dimension; comp++)
1001 resu(i,comp)/=(volumes_entrelaces(i));
1002 for(i=0; i<nbf; i++)
1003 {
1004 if(std::fabs(resu(i,0))>1.e-10)
1005 {
1006 Cerr << " delta(x,0) ("<<i<<") = "
1007 << resu(i,0);
1008 Cerr << finl;
1009 }
1010 }
1011 Cerr << " Verification of delta(y(1-y),0) " << finl;
1012 for(i=0; i<nbf; i++)
1013 {
1014 vit(i,0)=xv(i,1)*(1-xv(i,1));
1015 vit(i,1)=0;
1016 }
1017 calculer(vit, resu);
1018 for(i=0; i<nbf; i++)
1019 for(comp=0; comp<dimension; comp++)
1020 resu(i,comp)/=(volumes_entrelaces(i));
1021 for(i=0; i<nbf; i++)
1022 {
1023 if(std::fabs(2-resu(i,0))>1.e-10)
1024 {
1025 Cerr << " delta(y(1-y),0) ("<<i<<") = "
1026 << resu(i,0);
1027 Cerr << finl;
1028 }
1029 }
1030 }
1031}
Champ_Inc_base::valeurs
DoubleTab & valeurs() override
Returns the array of field values at the current time.
Definition Champ_Inc_base.h:77
Champ_base
class Champ_base This class is the base of the fields hierarchy.
Definition Champ_base.h:43
Cond_lim
class Cond_lim Generic class used to represent any class
Definition Cond_lim.h:31
Domaine_32_64::nb_faces_elem
int nb_faces_elem(int=0) const
Returns the number of faces of type i of the geometric elements that make up the domain.
Definition Domaine.h:484
Domaine_Cl_VEF
Definition Domaine_Cl_VEF.h:38
Domaine_Cl_dis_base::les_conditions_limites
const Cond_lim & les_conditions_limites(int) const
Returns the i-th boundary condition.
Definition Domaine_Cl_dis_base.cpp:386
Domaine_VEF
class Domaine_VEF
Definition Domaine_VEF.h:53
Domaine_VF::face_surfaces
virtual const DoubleVect & face_surfaces() const
Definition Domaine_VF.h:51
Domaine_VF::nb_faces
int nb_faces() const
Returns the total number of 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
Returns the index of the i-th face of element num_elem; the face numbering convention is.
Definition Domaine_VF.h:542
Domaine_VF::premiere_face_int
int premiere_face_int() const
A face is internal if and only if it separates two elements.
Definition Domaine_VF.h:463
Domaine_VF::face_voisins
int face_voisins(int num_face, int i) const
Returns the neighbouring element of num_face in direction i.
Definition Domaine_VF.h:418
Domaine_VF::nb_faces_bord
int nb_faces_bord() const
Returns the number of faces on which boundary conditions are applied:
Definition Domaine_VF.h:512
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: This class represents the special case of the class.
Definition Echange_externe_impose.h:46
Echange_externe_radiatif
Echange_externe_radiatif: Combines radiative (sigma * eps * (T^4 - T_ext^4)) and convective (h * (T -...
Definition Echange_externe_radiatif.h:31
Echange_impose_base::h_imp
virtual double h_imp(int num) const
Returns the value of the imposed heat exchange coefficient on the i-th component.
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
Returns the value of the imposed temperature on the i-th component of the boundary field.
Definition Echange_impose_base.cpp:76
Echange_impose_base::emissivite
double emissivite(int num) const
Returns the value of the imposed emissivity on the i-th component.
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
Matrice_Morse class - Represents a (sparse) matrix M, not necessarily square,.
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
Returns the reference to the equation pointed to by MorEqn::mon_equation.
Definition MorEqn.h:62
Neumann_homogene
Classe Neumann_homogene This class is the base class of the hierarchy of homogeneous Neumann-type bou...
Definition Neumann_homogene.h:31
Neumann_paroi
Classe Neumann_paroi This boundary condition corresponds to an imposed flux for the.
Definition Neumann_paroi.h:29
Neumann_sortie_libre
Neumann_sortie_libre This class represents an open boundary without imposed velocity.
Definition Neumann_sortie_libre.h:34
Neumann::flux_impose
virtual double flux_impose(int i) const
Returns the value of the imposed flux on the i-th component of the field representing the flux at the...
Definition Neumann.cpp:35
Objet_U::dimension
static int dimension
Definition Objet_U.h:94
Objet_U::que_suis_je
const Nom & que_suis_je() const
Returns the string identifying the class.
Definition Objet_U.cpp:104
Objet_U::readOn
virtual Entree & readOn(Entree &)
Reads an Objet_U from an input stream. Virtual method to override.
Definition Objet_U.cpp:289
Objet_U::printOn
virtual Sortie & printOn(Sortie &) const
Writes the object to an output stream. Virtual method to override.
Definition Objet_U.cpp:278
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:264
Op_Diff_VEF_Anisotrope_Face::ajouter
DoubleTab & ajouter(const DoubleTab &, DoubleTab &) const override
Definition Op_Diff_VEF_Anisotrope_Face.cpp:493
Op_Diff_VEF_Anisotrope_Face::associer_diffusivite
void associer_diffusivite(const Champ_base &) override
Associate the diffusivity field.
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:533
Op_Diff_VEF_Anisotrope_Face::verifier
void verifier() const
Definition Op_Diff_VEF_Anisotrope_Face.cpp:974
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:252
Op_Diff_VEF_Anisotrope_Face::completer
void completer() override
Associates the operator with the domaine_dis, the domaine_Cl_dis, and the unknown of its 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:527
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:736
Op_Diff_VEF_Anisotrope_Face::contribue_au_second_membre
void contribue_au_second_membre(DoubleTab &) const
Definition Op_Diff_VEF_Anisotrope_Face.cpp:950
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
Determine whether to compute div(phi nu grad Psi) or div(nu grad 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
Sums the 2 rows of the associated periodic faces, allowing computations in the code without needing t...
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
Divides the coefficients on the periodic face rows by 2 in preparation for applying modifier_matrice_...
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()
Associates the operator with the domaine_dis, the domaine_Cl_dis, and the unknown of its equation.
Definition Operateur_base.cpp:89
Periodique
class Periodique This class represents a periodic boundary condition.
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)
Exit routine for TRUST within a Kokkos region.
Definition Process.cpp:466
Sortie
Base class for output streams.
Definition Sortie.h:52
Symetrie
Symetrie On symmetry faces, the following properties hold:
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