TRUST 1.9.8
HPC thermohydraulic platform
Loading...
Searching...
No Matches
Op_Diff_VEF_Face_Q1.cpp
1/****************************************************************************
2* Copyright (c) 2026, 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_Q1.h>
17#include <Champ_P1NC.h>
18#include <Champ_Q1NC.h>
19#include <Champ_Uniforme.h>
20#include <Periodique.h>
21#include <Neumann_paroi.h>
22#include <Echange_externe_impose.h>
23
24Implemente_instanciable(Op_Diff_VEF_Face_Q1,"Op_Diff_VEF_Q1NC",Op_Diff_VEF_base);
25
26Sortie& Op_Diff_VEF_Face_Q1::printOn(Sortie& s ) const
27{
28 return s << que_suis_je() ;
29}
30
31Entree& Op_Diff_VEF_Face_Q1::readOn(Entree& s )
32{
33 return s ;
34}
35
36/*! @brief associe le champ de diffusivite
37 *
38 */
39void Op_Diff_VEF_Face_Q1::associer_diffusivite(const Champ_base& diffu)
40{
41 diffusivite_ = diffu;
42}
43
48
49
50const Champ_base& Op_Diff_VEF_Face_Q1::diffusivite() const
51{
52 return diffusivite_.valeur();
53}
54
55double Op_Diff_VEF_Face_Q1::calculer_dt_stab() const
56{
57 // La diffusivite est constante dans le domaine donc
58 //
59 // dt_diff = h*h/diffusivite
60 remplir_nu(nu_);
61 double dt_stab;
62 const Domaine_VEF& domaine_VEF = le_dom_vef.valeur();
63 double alpha = local_max_vect((diffusivite_pour_pas_de_temps().valeurs()));
64 if (alpha==0)
65 dt_stab = DMAXFLOAT;
66 else
67 dt_stab = 0.5*domaine_VEF.carre_pas_du_maillage()/(2.*dimension*alpha);
68 return dt_stab;
69}
70
71// Fonction utile visc_Q1
72
73double visc_Q1(const Domaine_VEF& le_dom,const Domaine_Cl_VEF& zcl, int num_face,int num2,
74 int num_elem,int dimension,DoubleTab& nu)
75{
76 double constante = nu(num_elem)/le_dom.volumes(num_elem)*zcl.equation().milieu().porosite_elem(num_elem);
77 double Valeur=0;
78
79 if(dimension==2)
80 {
81 Valeur=le_dom.face_normales(num_face,0)*
82 le_dom.face_normales(num2,1) -
83 le_dom.face_normales(num_face,1)*le_dom.face_normales(num2,0);
84 Valeur=constante*std::fabs(Valeur)*(zcl.equation().milieu().porosite_face(num_face)* zcl.equation().milieu().porosite_face(num2));
85 }
86 else if (dimension == 3)
87 {
88 Valeur=(le_dom.face_normales(num_face,1)*le_dom.face_normales(num2,2) -
89 le_dom.face_normales(num_face,2)*le_dom.face_normales(num2,1)) +
90 (le_dom.face_normales(num_face,2)*le_dom.face_normales(num2,0) -
91 le_dom.face_normales(num_face,0)*le_dom.face_normales(num2,2)) +
92 (le_dom.face_normales(num_face,0)*le_dom.face_normales(num2,1) -
93 le_dom.face_normales(num_face,1)*le_dom.face_normales(num2,0));
94 Valeur=constante*std::fabs(Valeur)*(zcl.equation().milieu().porosite_face(num_face)* zcl.equation().milieu().porosite_face(num2));
95 }
96 // Cerr << "Valeur " << Valeur << finl;
97 return Valeur;
98}
99
100DoubleTab& Op_Diff_VEF_Face_Q1::ajouter(const DoubleTab& inconnue, DoubleTab& resu) const
101{
102 remplir_nu(nu_);
103 const Domaine_Cl_VEF& domaine_Cl_VEF = la_zcl_vef.valeur();
104 const Domaine_VEF& domaine_VEF = le_dom_vef.valeur();
105 const IntTab& elem_faces = domaine_VEF.elem_faces();
106 const IntTab& face_voisins = domaine_VEF.face_voisins();
107 int n1 = domaine_VEF.nb_faces();
108 int nb_comp = 1;
109 int nb_dim = resu.nb_dim();
110 if(nb_dim==2)
111 nb_comp=resu.dimension(1);
112
113 int i,j,num_face;
114 int elem1,elem2;
115 int nb_faces_elem = domaine_VEF.domaine().nb_faces_elem();
116 double val;
117
118 // On traite les faces bord
119 for (int n_bord=0; n_bord<domaine_VEF.nb_front_Cl(); n_bord++)
120 {
121 const Cond_lim& la_cl = domaine_Cl_VEF.les_conditions_limites(n_bord);
122
123 const Front_VF& le_bord = ref_cast(Front_VF,la_cl->frontiere_dis());
124 int num1 = le_bord.num_premiere_face();
125 int num2 = num1 + le_bord.nb_faces();
126
127 if (sub_type(Periodique,la_cl.valeur()))
128 {
129 const Periodique& la_cl_perio = ref_cast(Periodique,la_cl.valeur());
130 int fac_asso;
131 for (num_face=num1; num_face<num2; num_face++)
132 {
133 elem1 = face_voisins(num_face,0);
134 fac_asso = la_cl_perio.face_associee(num_face-num1)+num1;
135 for (i=0; i<nb_faces_elem; i++)
136 {
137 if ( ( (j= elem_faces(elem1,i)) > num_face ) && (j != fac_asso ) )
138 {
139 val = visc_Q1(domaine_VEF,domaine_Cl_VEF,num_face,j,elem1,dimension,nu_);
140
141 for (int nc=0; nc<nb_comp; nc++)
142 {
143 resu(num_face,nc)+=val*inconnue(j,nc);
144 resu(num_face,nc)-=val*inconnue(num_face,nc);
145 resu(j,nc)+=0.5*val*inconnue(num_face,nc);
146 resu(j,nc)-=0.5*val*inconnue(j,nc);
147 }
148 }
149 }
150 elem2 = face_voisins(num_face,1);
151 for (i=0; i<nb_faces_elem; i++)
152 {
153 if ( ( (j= elem_faces(elem2,i)) > num_face ) && (j != fac_asso ) )
154 {
155 val = visc_Q1(domaine_VEF,domaine_Cl_VEF,num_face,j,elem2,dimension,nu_);
156 for (int nc=0; nc<nb_comp; nc++)
157 {
158 resu(num_face,nc)+=val*inconnue(j,nc);
159 resu(num_face,nc)-=val*inconnue(num_face,nc);
160 resu(j,nc)+=0.5*val*inconnue(num_face,nc);
161 resu(j,nc)-=0.5*val*inconnue(j,nc);
162 }
163 }
164 }
165 }
166 }
167 else
168 {
169 for (num_face=num1; num_face<num2; num_face++)
170 {
171 elem1 = face_voisins(num_face,0);
172 for (i=0; i<nb_faces_elem; i++)
173 {
174 if ( (j= elem_faces(elem1,i)) > num_face )
175 {
176 val = visc_Q1(domaine_VEF,domaine_Cl_VEF,num_face,j,elem1,dimension,nu_);
177 for (int nc=0; nc<nb_comp; nc++)
178 {
179 resu(num_face,nc)+=val*inconnue(j,nc);
180 resu(num_face,nc)-=val*inconnue(num_face,nc);
181 resu(j,nc)+=val*inconnue(num_face,nc);
182 resu(j,nc)-=val*inconnue(j,nc);
183 }
184 }
185 }
186 }
187 }
188 }
189
190 // On traite les faces internes
191 for (num_face=domaine_VEF.premiere_face_int(); num_face<n1; num_face++)
192 {
193 elem1 = face_voisins(num_face,0);
194 elem2 = face_voisins(num_face,1);
195
196 for (i=0; i<nb_faces_elem; i++)
197 {
198 if ( (j=elem_faces(elem1,i)) > num_face )
199 {
200 val = visc_Q1(domaine_VEF,domaine_Cl_VEF,num_face,j,elem1,dimension,nu_);
201 for (int nc=0; nc<nb_comp; nc++)
202 {
203 resu(num_face,nc)+=val*inconnue(j,nc);
204 resu(num_face,nc)-=val*inconnue(num_face,nc);
205 resu(j,nc)+=val*inconnue(num_face,nc);
206 resu(j,nc)-=val*inconnue(j,nc);
207 }
208
209 }
210 if ( (j=elem_faces(elem2,i)) > num_face )
211 {
212 val = visc_Q1(domaine_VEF,domaine_Cl_VEF,num_face,j,elem2,dimension,nu_);
213 for (int nc=0; nc<nb_comp; nc++)
214 {
215 resu(num_face,nc)+=val*inconnue(j,nc);
216 resu(num_face,nc)-=val*inconnue(num_face,nc);
217 resu(j,nc)+=val*inconnue(num_face,nc);
218 resu(j,nc)-=val*inconnue(j,nc);
219 }
220 }
221 }
222 }
223
224 // Partie imposee :
225 int nbcomp = resu.dimension(1);
226 for (int n_bord=0; n_bord<domaine_VEF.nb_front_Cl(); n_bord++)
227 {
228 const Cond_lim& la_cl = domaine_Cl_VEF.les_conditions_limites(n_bord);
229
230 if (sub_type(Neumann_paroi,la_cl.valeur()))
231 {
232 const Neumann_paroi& la_cl_paroi = ref_cast(Neumann_paroi, la_cl.valeur());
233 const Front_VF& le_bord = ref_cast(Front_VF,la_cl->frontiere_dis());
234 int ndeb = le_bord.num_premiere_face();
235 int nfin = ndeb + le_bord.nb_faces();
236 for (int face=ndeb; face<nfin; face++)
237 for (int comp=0; comp<nbcomp; comp++)
238 resu(face,comp) += la_cl_paroi.flux_impose(face-ndeb,comp)*domaine_VEF.surface(face);
239 }
240 else if (sub_type(Echange_externe_impose,la_cl.valeur()))
241 {
242 const Echange_externe_impose& la_cl_paroi = ref_cast(Echange_externe_impose, la_cl.valeur());
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 for (int comp=0; comp<nbcomp; comp++)
248 resu(face,comp) += la_cl_paroi.h_imp(face-ndeb,comp)*(la_cl_paroi.T_ext(face-ndeb)-inconnue(face,comp))*domaine_VEF.surface(face);
249 }
250 }
251
252 modifier_flux(*this);
253 return resu;
254}
255
256DoubleTab& Op_Diff_VEF_Face_Q1::calculer(const DoubleTab& inconnue, DoubleTab& resu) const
257{
258 resu = 0;
259 return ajouter(inconnue,resu);
260}
261
262
263
264/////////////////////////////////////////
265// Methode pour l'implicite
266/////////////////////////////////////////
267
268void Op_Diff_VEF_Face_Q1::ajouter_contribution(const DoubleTab& transporte, Matrice_Morse& matrice ) const
269{
270 remplir_nu(nu_);
271 const Domaine_Cl_VEF& domaine_Cl_VEF = la_zcl_vef.valeur();
272 const Domaine_VEF& domaine_VEF = le_dom_vef.valeur();
273 const IntTab& elem_faces = domaine_VEF.elem_faces();
274 const IntTab& face_voisins = domaine_VEF.face_voisins();
275 int n1 = domaine_VEF.nb_faces();
276 const int nb_comp = transporte.line_size();
277
278 int i,j,num_face,elem1,elem2;
279 int nb_faces_elem = domaine_VEF.domaine().nb_faces_elem();
280 // DoubleTab val= 0;
281 double val;
282 auto& tab1 = matrice.get_set_tab1();
283 auto& tab2 = matrice.get_set_tab2();
284 auto& coeff = matrice.get_set_coeff();
285
286 // On traite les faces bord
287 for (int n_bord=0; n_bord<domaine_VEF.nb_front_Cl(); n_bord++)
288 {
289 const Cond_lim& la_cl = domaine_Cl_VEF.les_conditions_limites(n_bord);
290
291 const Front_VF& le_bord = ref_cast(Front_VF,la_cl->frontiere_dis());
292 int num1 = le_bord.num_premiere_face();
293 int num2 = num1 + le_bord.nb_faces();
294
295 if (sub_type(Periodique,la_cl.valeur()))
296 {
297 const Periodique& la_cl_perio = ref_cast(Periodique,la_cl.valeur());
298 int fac_asso;
299 for (num_face=num1; num_face<num2; num_face++)
300 {
301 elem1 = face_voisins(num_face,0);
302 fac_asso = la_cl_perio.face_associee(num_face-num1)+num1;
303 for (i=0; i<nb_faces_elem; i++)
304 {
305 if ( ( (j= elem_faces(elem1,i)) > num_face ) && (j != fac_asso ) )
306 {
307 val = visc_Q1(domaine_VEF,domaine_Cl_VEF,num_face,j,elem1,dimension,nu_);
308 for (int nc=0; nc<nb_comp; nc++)
309 {
310 for (auto k=tab1[num_face*nb_comp+nc]-1; k<tab1[num_face*nb_comp+nc+1]-1; k++)
311 {
312 if (tab2[k]-1==num_face*nb_comp+nc)
313 coeff(k)+=val;
314 if (tab2[k]-1==j*nb_comp+nc)
315 coeff(k)-=0.5;
316 }
317 for (auto k=tab1[j*nb_comp+nc]-1; k<tab1[j*nb_comp+nc+1]-1; k++)
318 {
319 if (tab2[k]-1==num_face*nb_comp+nc)
320 coeff(k)-=val;
321 if (tab2[k]-1==j*nb_comp+nc)
322 coeff(k)+=0.5*val;
323 }
324 }
325 }
326 }
327 elem2 = face_voisins(num_face,1);
328 for (i=0; i<nb_faces_elem; i++)
329 {
330 if ( ( (j= elem_faces(elem2,i)) > num_face ) && (j != fac_asso ) )
331 {
332 val = visc_Q1(domaine_VEF,domaine_Cl_VEF,num_face,j,elem2,dimension,nu_);
333 for (int nc=0; nc<nb_comp; nc++)
334 {
335 for (auto k=tab1[num_face*nb_comp+nc]-1; k<tab1[num_face*nb_comp+nc+1]-1; k++)
336 {
337 if (tab2[k]-1==num_face*nb_comp+nc)
338 coeff(k)+=val;
339 if (tab2[k]-1==j*nb_comp+nc)
340 coeff(k)-=0.5*val;
341 }
342 for (auto k=tab1[j*nb_comp+nc]-1; k<tab1[j*nb_comp+nc+1]-1; k++)
343 {
344 if (tab2[k]-1==num_face*nb_comp+nc)
345 coeff(k)-=val;
346 if (tab2[k]-1==j*nb_comp+nc)
347 coeff(k)+=0.5*val;
348 }
349 }
350 }
351 }
352 }
353 }
354 else
355 {
356 for (num_face=num1; num_face<num2; num_face++)
357 {
358 elem1 = face_voisins(num_face,0);
359 for (i=0; i<nb_faces_elem; i++)
360 {
361 if ( (j= elem_faces(elem1,i)) > num_face )
362 {
363 val = visc_Q1(domaine_VEF,domaine_Cl_VEF,num_face,j,elem1,dimension,nu_);
364 for (int nc=0; nc<nb_comp; nc++)
365 {
366 for (auto k=tab1[num_face*nb_comp+nc]-1; k<tab1[num_face*nb_comp+nc+1]-1; k++)
367 {
368 if (tab2[k]-1==num_face*nb_comp+nc)
369 coeff(k)+=val;
370 if (tab2[k]-1==j*nb_comp+nc)
371 coeff(k)-=val;
372 }
373 for (auto k=tab1[j*nb_comp+nc]-1; k<tab1[j*nb_comp+nc+1]-1; k++)
374 {
375 if (tab2[k]-1==num_face*nb_comp+nc)
376 coeff(k)-=val;
377 if (tab2[k]-1==j*nb_comp+nc)
378 coeff(k)+=val;
379 }
380
381 }
382 }
383 }
384 }
385 }
386 }
387
388 // On traite les faces internes
389 for (num_face=domaine_VEF.premiere_face_int(); num_face<n1; num_face++)
390 {
391 elem1 = face_voisins(num_face,0);
392 elem2 = face_voisins(num_face,1);
393
394 for (i=0; i<nb_faces_elem; i++)
395 {
396 if ( (j=elem_faces(elem1,i)) > num_face )
397 {
398 val = visc_Q1(domaine_VEF,domaine_Cl_VEF,num_face,j,elem1,dimension,nu_);
399 for (int nc=0; nc<nb_comp; nc++)
400 {
401 for (auto k=tab1[num_face*nb_comp+nc]-1; k<tab1[num_face*nb_comp+nc+1]-1; k++)
402 {
403 if (tab2[k]-1==num_face*nb_comp+nc)
404 coeff(k) += val;
405 if (tab2[k]-1==j*nb_comp+nc)
406 coeff(k) -= val;
407 }
408 for (auto k=tab1[j*nb_comp+nc]-1; k<tab1[j*nb_comp+nc+1]-1; k++)
409 {
410 if (tab2[k]-1==num_face*nb_comp+nc)
411 coeff(k) -= val;
412 if (tab2[k]-1==j*nb_comp+nc)
413 coeff(k) += val;
414 }
415 }
416 }
417 if ( (j=elem_faces(elem2,i)) > num_face )
418 {
419 // E Saikali : can not factorize more
420 if (nb_comp == 1)
421 {
422 for (int nc=0; nc<nb_comp; nc++)
423 {
424 val = visc_Q1(domaine_VEF,domaine_Cl_VEF,num_face,j,elem2,dimension,nu_);
425 for (auto k=tab1[num_face*nb_comp+nc]-1; k<tab1[num_face*nb_comp+nc+1]-1; k++)
426 {
427 if (tab2[k]-1==num_face*nb_comp+nc)
428 coeff(k)+=val;
429 if (tab2[k]-1==j*nb_comp+nc)
430 coeff(k)-=val;
431 }
432 for (auto k=tab1[j]-1; k<tab1[j+1]-1; k++)
433 {
434 if (tab2[k]-1==num_face*nb_comp+nc)
435 coeff(k)-=val;
436 if (tab2[k]-1==j*nb_comp+nc)
437 coeff(k)+=val;
438 }
439 }
440 }
441 else
442 {
443 val= visc_Q1(domaine_VEF,domaine_Cl_VEF,num_face,j,elem1,dimension,nu_);
444 for (int nc=0; nc<nb_comp; nc++)
445 {
446 for (auto k=tab1[num_face*nb_comp+nc]-1; k<tab1[num_face*nb_comp+nc+1]-1; k++)
447 {
448 if (tab2[k]-1==num_face*nb_comp+nc)
449 coeff(k)+=val;
450 if (tab2[k]-1==j*nb_comp+nc)
451 coeff(k)-=val;
452 }
453 for (auto k=tab1[j*nb_comp+nc]-1; k<tab1[j*nb_comp+nc+1]-1; k++)
454 {
455 if (tab2[k]-1==num_face*nb_comp+nc)
456 coeff(k)-=val;
457 if (tab2[k]-1==j*nb_comp+nc)
458 coeff(k)+=val;
459 }
460 }
461 }
462
463 }
464 }
465 }
466
467}
468
469void Op_Diff_VEF_Face_Q1::contribue_au_second_membre(DoubleTab& resu ) const
470{
471 const Domaine_Cl_VEF& domaine_Cl_VEF = la_zcl_vef.valeur();
472 const Domaine_VEF& domaine_VEF = le_dom_vef.valeur();
473 const int nb_comp=resu.line_size();
474
475 // Partie imposee :
476 for (int n_bord=0; n_bord<domaine_VEF.nb_front_Cl(); n_bord++)
477 {
478 const Cond_lim& la_cl = domaine_Cl_VEF.les_conditions_limites(n_bord);
479
480 if (sub_type(Neumann_paroi,la_cl.valeur()))
481 {
482 const Neumann_paroi& la_cl_paroi = ref_cast(Neumann_paroi, la_cl.valeur());
483 const Front_VF& le_bord = ref_cast(Front_VF,la_cl->frontiere_dis());
484 int ndeb = le_bord.num_premiere_face();
485 int nfin = ndeb + le_bord.nb_faces();
486 for (int face=ndeb; face<nfin; face++)
487 for (int comp=0; comp<nb_comp; comp++)
488 resu(face,comp) += la_cl_paroi.flux_impose(face-ndeb,comp)*domaine_VEF.surface(face);
489 }
490 }
491}
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_VEF::carre_pas_du_maillage
double carre_pas_du_maillage() const
Definition Domaine_VEF.h:82
Domaine_VF::nb_faces
int nb_faces() const
renvoie le nombre global de faces.
Definition Domaine_VF.h:471
Domaine_VF::face_normales
virtual double face_normales(int face, int comp) const
Definition Domaine_VF.h:47
Domaine_VF::volumes
double volumes(int i) const
Definition Domaine_VF.h:113
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_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
Matrice_Morse
Classe Matrice_Morse Represente une matrice M (creuse), non necessairement carree.
Definition Matrice_Morse.h:50
Matrice_Morse::get_set_tab2
auto & get_set_tab2()
Definition Matrice_Morse.h:103
Matrice_Morse::get_set_coeff
auto & get_set_coeff()
Definition Matrice_Morse.h:108
Matrice_Morse::get_set_tab1
auto & get_set_tab1()
Definition Matrice_Morse.h:98
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_paroi
Classe Neumann_paroi Cette condition limite correspond a un flux impose pour l'equation de.
Definition Neumann_paroi.h:29
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_Q1
class Op_Diff_VEF_Face_Q1_Q1 Cette classe represente l'operateur de diffusion
Definition Op_Diff_VEF_Face_Q1.h:29
Op_Diff_VEF_Face_Q1::diffusivite
const Champ_base & diffusivite() const override
Definition Op_Diff_VEF_Face_Q1.cpp:50
Op_Diff_VEF_Face_Q1::associer_diffusivite
void associer_diffusivite(const Champ_base &) override
associe le champ de diffusivite
Definition Op_Diff_VEF_Face_Q1.cpp:39
Op_Diff_VEF_Face_Q1::calculer_dt_stab
double calculer_dt_stab() const override
Calcul dt_stab.
Definition Op_Diff_VEF_Face_Q1.cpp:55
Op_Diff_VEF_Face_Q1::contribue_au_second_membre
void contribue_au_second_membre(DoubleTab &) const
Definition Op_Diff_VEF_Face_Q1.cpp:469
Op_Diff_VEF_Face_Q1::calculer
DoubleTab & calculer(const DoubleTab &, DoubleTab &) const override
Definition Op_Diff_VEF_Face_Q1.cpp:256
Op_Diff_VEF_Face_Q1::ajouter_contribution
void ajouter_contribution(const DoubleTab &, Matrice_Morse &) const
Definition Op_Diff_VEF_Face_Q1.cpp:268
Op_Diff_VEF_Face_Q1::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_Q1.cpp:44
Op_Diff_VEF_Face_Q1::ajouter
DoubleTab & ajouter(const DoubleTab &, DoubleTab &) const override
Definition Op_Diff_VEF_Face_Q1.cpp:100
Op_Diff_VEF_base
class Op_Diff_VEF_base
Definition Op_Diff_VEF_base.h:39
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_VEF_Face::modifier_flux
void modifier_flux(const Operateur_base &) const
Definition Op_VEF_Face.cpp:338
Operateur_Diff_base::diffusivite_pour_pas_de_temps
virtual const Champ_base & diffusivite_pour_pas_de_temps() const
Renvoie le champ_don correspondant a la vraie diffusivite du milieu qui sert pour le calcul du pas de...
Definition Operateur_Diff_base.cpp:64
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
Sortie
Classe de base des flux de sortie.
Definition Sortie.h:52
TRUSTTab::nb_dim
int nb_dim() const
Definition TRUSTTab.h:199
TRUSTTab::dimension
_SIZE_ dimension(int d) const
Definition TRUSTTab.tpp:133
TRUSTVect::line_size
int line_size() const
Definition TRUSTVect.tpp:67