TrioCFD 1.9.8
TrioCFD documentation
Loading...
Searching...
No Matches
Prepro_IBM_Ponderation.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 <Prepro_IBM_Ponderation.h>
17#include <Connectivite_som_elem.h>
18
19Implemente_instanciable( Prepro_IBM_Ponderation,"Prepro_IBM_Ponderation|methode_IBM_ponderation",Prepro_IBM_base );
20
21Sortie& Prepro_IBM_Ponderation::printOn(Sortie& os) const { return Prepro_IBM_base::printOn(os); }
22// XD Prepro_IBM_Ponderation Prepro_IBM_base methode_IBM_ponderation BRACE To perform the intersection of an IB
23// XD_CONT (Lagrange mesh) in a MED-format file .med with the Euler computional mesh.
24
25void Prepro_IBM_Ponderation::set_param(Param& param) const
26{
27 Prepro_IBM_base::set_param(param);
28 param.ajouter("type_de_ponderation",&pond_,Param::OPTIONAL); // XD_ADD_P entier
29 // XD_CONT choix de la methode de ponderation
30}
31
32Entree& Prepro_IBM_Ponderation::readOn(Entree& is)
33{
34 Prepro_IBM_base::readOn(is);
35 Param param(que_suis_je());
36 set_param(param);
37 param.lire_avec_accolades_depuis(is);
38
39 if(pond_==1)
40 Cout<<"Weighting method = arimethic weight"<<finl;
41 else if(pond_==2)
42 Cout<<"Weighting method = area weight"<<finl;
43 else if(pond_==3)
44 Cout<<"Weighting method = inverse distance weight"<<finl;
45 else if(pond_==4)
46 Cout<<"Weighting method = area and inverse distance weight"<<finl;
47 else
48 {
49 Cerr<<"Prepro_IBM_ponderation : Type_de_ponderation : invalide argument = "<<pond_<<finl;
50 Process::exit();
51 }
52 return is;
53}
54
55void Prepro_IBM_Ponderation::associer_pb(const Probleme_base& pb)
56{
57 Prepro_IBM_base::associer_pb(pb);
58 compute_solid_fluid(0);
59
60 // Ecriture eventuelle
61 if( save_prepro_ == 1) Save_Med_File();
62}
63
64void Prepro_IBM_Ponderation::compute_solid_fluid(int maj_from_ext)
65{
66 if (verbose_) Cerr<<"Prepro_IBM_Ponderation:: Computing arrays..."<<finl;
67
68 int dim_esp = Objet_U::dimension;
69 DoubleTab& normalArray = champ_normal_->valeurs();
70 DoubleTab& aireArray = champ_aire_->valeurs();
71 DoubleTab& isNodeDirichletArray = isNodeDirichlet_->valeurs();
72 DoubleTab& rotationArray = champ_rotation_->valeurs();
73 int nbElemVol = rotationArray.dimension(0); // Nombre de cellules du maillage volumique
74
75 //mise a jour eventuelle de la normal par element et des noeuds Dirichlet a partir de champ_aire_ et champ_rotation_
76 const Domaine_dis_base& le_dom_dis = mon_pb_->domaine_dis();
77 const IntTab& elems = le_dom_dis.domaine().les_elems();
78 if (maj_from_ext == 1)
79 {
80 isNodeDirichletArray = -1.;
81 normalArray = 0.;
82 for (int elem = 0; elem <nbElemVol; elem++)
83 {
84 if (aireArray(elem) > 0.)
85 {
86 for (int k = 0; k <dim_esp; k++) normalArray(elem,k) = rotationArray(elem,3*k+(dim_esp-1));
87 for (int l = 0; l < le_dom_dis.domaine().nb_som_elem(); l++)
88 {
89 isNodeDirichletArray(elems(elem,l)) = 1.0 ;
90 }
91 }
92 }
93 normalArray.echange_espace_virtuel();
94 isNodeDirichletArray.echange_espace_virtuel();
95 }
96
97 // calcul des noeuds voisins a un noeud donne
98 int nb_niveau = 1;
99 compute_NeighNode(nb_niveau);
100
101 // calcul des distances caractéristiques
102 compute_h_max_elem();
103
104 //Projection solide : calcul des points solides projetes et des contributions ponderees
105 projectSolidPoints();
106
107 //Projection fluide : en utilisant les projections solides et normales, on calcule les points fluides
108 projectFluidPoints();
109
110// //Mise à jour de la matrice de rotation elementaire avec les normales nodales
111 // for (int elem = 0; elem <nbElemVol; elem++)
112 // {
113 // computeLocalFrame(normalArray, t1Arr, t2Arr, elem);
114 // computeMatRot(normalArray, t1Arr, t2Arr, elem);
115 // }
116}
117
118void Prepro_IBM_Ponderation::projectSolidPoints()
119{
120 const DoubleTab& normalArray = champ_normal_->valeurs(); // Normales aux faces
121 const DoubleTab& aireArray = champ_aire_->valeurs();
122 const DoubleTab& baryArray = champ_bary_->valeurs(); // Barycentres des faces surfaciques
123 DoubleTab& solideArray = solid_points_->valeurs(); // Tableau des projections solides
124 const DoubleTab& isNodeDirichletArray = isNodeDirichlet_->valeurs();
125 DoubleTab& solid_elemsArray = solid_elems_->valeurs();
126 solideArray=0.0;
127 solid_elemsArray = -2.;
128
129 Cout << "============================================================================"<<finl;
130 Cout<<"prepro_IBM::projectSolidPoints - Weighting method = "<<pond_<<finl;
131
132 const Domaine_dis_base& le_dom_dis = mon_pb_->domaine_dis();// contient maillage TRUST
133 const Domaine& le_dom = le_dom_dis.domaine();
134 const int nb_elem = le_dom.nb_elem();
135 const int nb_som = le_dom.nb_som();
136 const int nb_som_elem =le_dom.nb_som_elem();
137 const IntTab& connectDom = le_dom.les_elems() ;// connectivité elements-noeuds
138 const DoubleTab coordsDom3D = le_dom.coord_sommets(); // coordonnées des noeuds TRUST
139 const int dim_esp=Objet_U::dimension;
140 assert(dim_esp == 3);
141
142 DoubleTab x(dim_esp);
143 DoubleTrav sumContribProjSolidArray(nb_som);
144 sumContribProjSolidArray = 0.;
145 IntLists elemPerNeighbor(nb_som);
146 for (int e=0; e<nb_elem; e++)
147 {
148 if (aireArray(e) > eps_effec_)
149 {
150 //////////////////////////////////////////
151 //calcul de la projection solide pour e
152 //////////////////////////////////////////
153
154 //Parcourt des noeuds de l'element
155 for (int noeud=0; noeud<nb_som_elem; noeud++)
156 {
157 int sommet = connectDom(e,noeud);
158 if(dimTab_(0))
159 x(0) = coordsDom3D(sommet,0) - baryArray(e,0);
160 else
161 x(0) = 0.0;
162 if(dimTab_(1))
163 x(1) = coordsDom3D(sommet,1) - baryArray(e,1);
164 else
165 x(1) = 0.0;
166 if(dimTab_(2))
167 x(2) = coordsDom3D(sommet,2) - baryArray(e,2);
168 else
169 x(2) = 0.0;
170 // for (int d=0; d<dim_esp; d++) Cerr<<x(d)<<" ";
171 // Cerr<<finl;
172 // for (int d=0; d<dim_esp; d++) Cerr<<coordsDom3D(sommet,d)<<" ";
173 // Cerr<<finl;
174
175 double distance=0.0 , distance_normale=0.0;
176 for (int d=0; d<dim_esp; d++)
177 {
178 distance_normale += x(d)*normalArray(e,d);
179 distance += x(d)*x(d);
180 }
181 distance = sqrt(distance);
182 // Cerr<<"distance_normale : "<<distance_normale<<" distance : "<<distance<<finl;
183
184 // Ponderation type 1 à 4
185 double pond;
186 switch (pond_)
187 {
188 case 1:
189 pond = 1.0;
190 break;
191 case 2:
192 pond = aireArray(e);
193 break;
194 case 3:
195 pond = (distance>eps_effec_)? (1.0/distance) : 1.0;
196 break;
197 case 4:
198 pond = (distance>eps_effec_)? (aireArray(e)/distance) : aireArray(e);
199 break;
200 default:
201 pond = 1.0;
202 break;
203 }
204
205 //calcul de la projection solide pour les noeuds de l'element e
206 for (int d=0; d<dim_esp; d++) solideArray(sommet,d) += pond * (coordsDom3D(sommet,d)- distance_normale*normalArray(e,d));
207 sumContribProjSolidArray(sommet) += pond;
208
209 /////////////////////////////////////////////////////////
210 //calcul de la projection solide pour les voisins de e
211 /////////////////////////////////////////////////////////
212 //calcul de la projection solide pour les voisins des noeuds de l'element e
213 IntList& voisins = sommets_voisins_[sommet];
214 int taille = 0;
215 if (!(voisins.est_vide())) taille = voisins.size();
216 // Cerr<<"taille : "<<taille<<finl;
217 // Cerr<<"isNodeDirichletArray : "<<isNodeDirichletArray(voisins[0])<<" elemPerNeighbor[num_som_v]: "<<elemPerNeighbor[voisins[0]].contient(e)<<finl;
218 for (int l=0; l<taille; l++)
219 {
220 int num_som_v= voisins[l];
221 if ( isNodeDirichletArray(num_som_v)<0 && !(elemPerNeighbor[num_som_v].contient(e)) )
222 {
223 // Ajout de l'élément e pour ce voisin
224 // Cerr<<"isNodeDirichletArray = "<<isNodeDirichletArray(num_som_v)<<" elemPerNeighbor[num_som_v]: "<<elemPerNeighbor[num_som_v].contient(e)<<finl;
225 elemPerNeighbor[num_som_v].add(e);
226 // Calcul du vecteur voisin -> barycentre
227 double dx = coordsDom3D(num_som_v, 0) - baryArray(e, 0);
228 double dy = coordsDom3D(num_som_v, 1) - baryArray(e, 1);
229 double dz = coordsDom3D(num_som_v, 2) - baryArray(e, 2);
230
231 double distance_normale_v = dx * normalArray(e, 0) + dy * normalArray(e, 1) + dz * normalArray(e, 2);
232 double d1 = sqrt(dx * dx + dy * dy + dz * dz);
233
234 // pondération
235 double pond_v;
236 if (d1 > eps_effec_)
237 {
238 switch (pond_)
239 {
240 case 3:
241 pond_v = fabs(1.0 / d1);
242 break;
243 case 4:
244 pond_v = fabs(aireArray(e) / d1);
245 break;
246 default:
247 pond_v = 1.0;
248 break;
249 }
250 }
251 else
252 {
253 Cerr << "DIST_PROB : d1 ~ 0 for neighbor" << num_som_v << " of the element " << e << finl;
254 pond_v = (pond_ == 4) ? aireArray(e) : 1.0;
255 }
256
257 // Contribution pondérée
258 solideArray(num_som_v, 0) += pond_v * (coordsDom3D(num_som_v, 0) - distance_normale_v * normalArray(e, 0));
259 solideArray(num_som_v, 1) += pond_v * (coordsDom3D(num_som_v, 1) - distance_normale_v * normalArray(e, 1));
260 solideArray(num_som_v, 2) += pond_v * (coordsDom3D(num_som_v, 2) - distance_normale_v * normalArray(e, 2));
261
262 sumContribProjSolidArray(num_som_v) += pond_v;
263 }
264 }
265 }
266 }
267 }
268
269 for(int sommet=0; sommet<nb_som; sommet++)
270 {
271 if (sumContribProjSolidArray(sommet))
272 {
273 for (int d=0; d<dim_esp; d++) solideArray(sommet,d) /= sumContribProjSolidArray(sommet);
274 int interSoElem = le_dom.chercher_elements(solideArray(sommet,0),solideArray(sommet,1),solideArray(sommet,2));
275 if (interSoElem == -1)
276 solid_elemsArray(sommet) = -1.;
277 else
278 solid_elemsArray(sommet) = float(interSoElem);
279
280 // Cerr<<"projection point solide sommet : "<<sommet<<" : ";
281 // for (int d=0; d<dim_esp; d++) Cerr<<solideArray(sommet,d)<<" ";
282 // Cerr<<";element solide = "<<solid_elemsArray(sommet)<<" ";
283 // Cerr<<finl;
284 }
285 }
286}
287
288void Prepro_IBM_Ponderation::projectFluidPoints()
289{
290 const DoubleTab& aire = champ_aire_->valeurs(); // Aire
291 DoubleTab& normalArray = champ_normal_->valeurs(); // Normales aux faces
292 DoubleTab& fluide = fluid_points_->valeurs(); // Tableau des projections fluides
293 const DoubleTab& dirichlet = isNodeDirichlet_->valeurs();
294 const DoubleTab& hmax_node = h_max_node_->valeurs();
295 DoubleVect& elem_fluide = fluid_elems_->valeurs();;
296
297
298 const Domaine_dis_base& le_dom_dis = mon_pb_->domaine_dis();
299 const Domaine& le_dom = le_dom_dis.domaine();
300 const DoubleTab& coordsDom3D = le_dom.coord_sommets();
301 const IntTab& connect = le_dom.les_elems();
302 const int nb_som_elem = le_dom.nb_som_elem();
303 const int nb_som = le_dom.nb_som();
304 const int nb_sommets_tot = le_dom.nb_som_tot();
305 const int nb_elem = le_dom.nb_elem();
306 int dim_esp = Objet_U::dimension;
307 assert(dim_esp == 3);
308
309 DoubleTab normale_som(nb_som,dim_esp); // Normales nodales
310 double fact = 1.1;
311 double x, y, z, xp, yp, zp, norme;
312
313 int interFlElem;
314
315 for (int som = 0; som < nb_som; som++)
316 {
317 if (dirichlet(som) == 1.)
318 {
319 //////////////////////////////////////////
320 //calcul de la projection fluide pour som
321 //////////////////////////////////////////
322 x = coordsDom3D(som, 0);
323 y = coordsDom3D(som, 1);
324 z = coordsDom3D(som, 2);
325 xp = solid_points_->valeurs()(som, 0);
326 yp = solid_points_->valeurs()(som, 1);
327 zp = solid_points_->valeurs()(som, 2);
328 norme = sqrt((x - xp)*(x - xp) + (y - yp)*(y - yp) + (z - zp)*(z - zp));
329
330 if (norme < eps_effec_)
331 {
332 elem_fluide(som) = -3; //O(h) because the projection and node are located at the same position (i.e. the node is already on the immersed boundary)
333 for (int d = 0; d < dim_esp; d++)
334 {
335 fluide(som, d) = coordsDom3D(som, d);
336 normale_som(som, d) = 0.0;
337 }
338 }
339 else
340 {
341 for (int d = 0; d < dim_esp; d++)
342 {
343 normale_som(som, d) = (coordsDom3D(som, d) - solid_points_->valeurs()(som, d)) / norme;
344 fluide(som, d) = dimTab_(d) ? coordsDom3D(som, d) + fact * hmax_node(som) * normale_som(som, d) : coordsDom3D(som, d);
345 }
346 interFlElem = le_dom.chercher_elements(fluide(som,0),fluide(som,1),fluide(som,2));
347 if (interFlElem == -1) // element non trouve
348 elem_fluide(som) = -3.;
349 else
350 {
351 elem_fluide(som) = float(interFlElem);
352 if (aire(interFlElem) > 0.0)
353 elem_fluide(som) = -1.; // O(h) element traverse par IBC
354 else
355 {
356 bool flag = false;
357 for (int j = 0; j < nb_som_elem; j++)
358 {
359 int s = connect(interFlElem, j);
360 if (dirichlet(s) == 1.0) flag = true; // element ayant un som. dirichlet
361 }
362 if (flag) elem_fluide(som) = -1.0; // pour Mean Gradient
363 }
364 }
365 }
366
367 // Si on n'a pas trouve d'elements fluide, on etend la zone aux elements voisins en tenant compte du coefficient c_prepro_
368 if (c_prepro_ > 0 && elem_fluide(som) == -1)
369 {
370 fact += c_prepro_;
371 for (int d = 0; d < dim_esp; d++)
372 fluide(som, d) = dimTab_(d) ? coordsDom3D(som, d) + fact * hmax_node(som) * normale_som(som, d) : coordsDom3D(som, d);
373 interFlElem = le_dom.chercher_elements(fluide(som,0),fluide(som,1),fluide(som,2));
374 if (interFlElem == -1) // element non trouve
375 elem_fluide(som) = -3.;
376 else
377 {
378 elem_fluide(som) = float(interFlElem);
379 if (aire(interFlElem) > 0.0)
380 elem_fluide(som) = -1.; // O(h) element traverse par IBC
381 else
382 {
383 bool flag = false;
384 for (int j = 0; j < nb_som_elem; j++)
385 {
386 int s = connect(interFlElem, j);
387 if (dirichlet(s) == 1.0) flag = true; // element ayant un som. dirichlet
388 }
389 if (flag) elem_fluide(som) = -1.0; // pour Mean Gradient
390 }
391 }
392 fact -= c_prepro_;
393 }
394
395 ///////////////////////////////////////////////////////
396 //calcul de la projection fluide pour les voisins de som
397 ///////////////////////////////////////////////////////
398 IntList& voisins = sommets_voisins_[som];
399 int taille = 0;
400 if (!(voisins.est_vide())) taille = voisins.size();
401 // Cerr<<"taille : "<<taille<<finl;
402 // Cerr<<"dirichlet : "<<dirichlet(voisins[0])<<finl;
403 for (int l=0; l<taille; l++)
404 {
405 int num_som_v= voisins[l];
406 if ( dirichlet(num_som_v)<0 )
407 {
408 x = coordsDom3D(num_som_v, 0);
409 y = coordsDom3D(num_som_v, 1);
410 z = coordsDom3D(num_som_v, 2);
411 xp = solid_points_->valeurs()(num_som_v, 0);
412 yp = solid_points_->valeurs()(num_som_v, 1);
413 zp = solid_points_->valeurs()(num_som_v, 2);
414 norme = sqrt((x - xp)*(x - xp) + (y - yp)*(y - yp) + (z - zp)*(z - zp));
415
416 if (norme < eps_effec_)
417 {
418 elem_fluide(num_som_v) = -3; //O(h) because the projection and node are located at the same position (i.e. the node is already on the immersed boundary)
419 for (int d = 0; d < dim_esp; d++)
420 {
421 fluide(num_som_v, d) = coordsDom3D(som, d);
422 normale_som(num_som_v, d) = 0.0;
423 }
424 }
425 else
426 {
427 for (int d = 0; d < dim_esp; d++)
428 {
429 normale_som(num_som_v, d) = (coordsDom3D(num_som_v, d) - solid_points_->valeurs()(num_som_v, d)) / norme;
430 fluide(num_som_v, d) = dimTab_(d) ? coordsDom3D(num_som_v, d) + fact * hmax_node(num_som_v) * normale_som(num_som_v, d) : coordsDom3D(num_som_v, d);
431 }
432 interFlElem = le_dom.chercher_elements(fluide(num_som_v,0),fluide(num_som_v,1),fluide(num_som_v,2));
433 if (interFlElem == -1) // element non trouve
434 elem_fluide(num_som_v) = -3.;
435 else
436 {
437 elem_fluide(num_som_v) = float(interFlElem);
438 if (aire(interFlElem) > 0.0)
439 elem_fluide(num_som_v) = -1.; // O(h) element traverse par IBC
440 else
441 {
442 bool flag = false;
443 for (int j = 0; j < nb_som_elem; j++)
444 {
445 int s = connect(interFlElem, j);
446 if (dirichlet(s) == 1.0) flag = true; // element ayant un som. dirichlet
447 }
448 if (flag) elem_fluide(num_som_v) = -1.0; // pour Mean Gradient
449 }
450 }
451 }
452
453 // Si on n'a pas trouve d'elements fluide, on etend la zone aux elements voisins en tenant compte du coefficient c_prepro_
454 if (c_prepro_ > 0 && elem_fluide(num_som_v) == -1)
455 {
456 fact += c_prepro_;
457 for (int d = 0; d < dim_esp; d++)
458 fluide(num_som_v, d) = dimTab_(d) ? coordsDom3D(num_som_v, d) + fact * hmax_node(num_som_v) * normale_som(num_som_v, d) : coordsDom3D(num_som_v, d);
459 interFlElem = le_dom.chercher_elements(fluide(num_som_v,0),fluide(num_som_v,1),fluide(num_som_v,2));
460 if (interFlElem == -1) // element non trouve
461 elem_fluide(num_som_v) = -3.;
462 else
463 {
464 elem_fluide(num_som_v) = float(interFlElem);
465 if (aire(interFlElem) > 0.0)
466 elem_fluide(num_som_v) = -1.; // O(h) element traverse par IBC
467 else
468 {
469 bool flag = false;
470 for (int j = 0; j < nb_som_elem; j++)
471 {
472 int s = connect(interFlElem, j);
473 if (dirichlet(s) == 1.0) flag = true; // element ayant un som. dirichlet
474 }
475 if (flag) elem_fluide(num_som_v) = -1.0; // pour Mean Gradient
476 }
477 }
478 fact -= c_prepro_;
479 }
480 }
481 }
482 }
483 }
484
485 // On modifie la matrice rotation IBC via les normales nodales
486 // ROTATION MATRIX
487
488 Static_Int_Lists connectivite_som_elem;
489 construire_connectivite_som_elem(nb_sommets_tot, connect, connectivite_som_elem, 1 /* include virtual elements */);
490
491 DoubleTrav normalWeighArray(nb_elem);
492 for (int som = 0; som < nb_som; som++)
493 {
494 double n0 = normale_som(som,0);
495 double n1 = normale_som(som,1);
496 double n2 = normale_som(som,2);
497 norme = sqrt(n0*n0+n1*n1+n2*n2);
498 if (norme > eps_effec_)
499 {
500 int sz = connectivite_som_elem.get_list_size(som);
501 for (int j = 0; j <sz ; j++)
502 {
503 int numElem = connectivite_som_elem(som,j);
504
505 if (aire(numElem) < eps_effec_)
506 {
507 normalArray(numElem,0) += n0;
508 normalArray(numElem,1) += n1;
509 normalArray(numElem,2) += n2;
510 normalWeighArray(numElem) += 1.0;
511 }
512 }
513 }
514 }
515
516 DoubleTrav t1Arr(nb_elem, dim_esp), t2Arr(nb_elem, dim_esp);
517 for (int e=0; e<nb_elem; e++)
518 {
519 if (normalWeighArray(e) > eps_effec_)
520 {
521 norme = sqrt(normalArray(e,0)*normalArray(e,0)+normalArray(e,1)*normalArray(e,1)+normalArray(e,2)*normalArray(e,2));
522 if (norme > eps_effec_)
523 {
524 for (int d = 0; d < dim_esp; d++) normalArray(e,d) /= norme;
525 // calcul de la matrice de rotation
526 computeLocalFrame(normalArray, t1Arr, t2Arr, e);
527 computeMatRot(normalArray, t1Arr, t2Arr, e);
528 }
529 }
530 }
531
532}
533
Domaine_32_64::nb_som_elem
int nb_som_elem() const
Renvoie le nombre de sommets des elements geometriques constituants le domaine.
Definition Domaine.h:474
Domaine_32_64::chercher_elements
SmallArrOfTID_t & chercher_elements(const DoubleTab &pos, SmallArrOfTID_t &elem, int reel=0) const
Recherche des elements contenant les points dont les coordonnees sont specifiees.
Definition Domaine.cpp:405
Domaine_32_64::les_elems
IntTab_t & les_elems()
Definition Domaine.h:129
Domaine_32_64::nb_elem
int_t nb_elem() const
Definition Domaine.h:131
Domaine_32_64::coord_sommets
const DoubleTab_t & coord_sommets() const
Definition Domaine.h:112
Domaine_32_64::nb_som_tot
int_t nb_som_tot() const
Renvoie le nombre total de sommets du domaine i.e. le nombre de sommets reels et virtuels sur le proc...
Definition Domaine.h:123
Domaine_32_64::nb_som
int_t nb_som() const
Renvoie le nombre de sommets du domaine.
Definition Domaine.h:121
Domaine_dis_base
classe Domaine_dis_base Cette classe est la base de la hierarchie des domaines discretisees.
Definition Domaine_dis_base.h:39
Domaine_dis_base::domaine
const Domaine & domaine() const
Definition Domaine_dis_base.h:46
Entree
Class defining operators and methods for all reading operation in an input flow (file,...
Definition Entree.h:42
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
Param
Helper class to factorize the readOn method of Objet_U classes.
Definition Param.h:112
Param::ajouter
void ajouter(const char *keyword, const int *value, Param::Nature nat=Param::OPTIONAL)
Register an integer parameter.
Definition Param.cpp:364
Param::OPTIONAL
@ OPTIONAL
Definition Param.h:115
Param::lire_avec_accolades_depuis
int lire_avec_accolades_depuis(Entree &is)
Parse the parameter block { ... } from is.
Definition Param.cpp:32
Prepro_IBM_Ponderation
Definition Prepro_IBM_Ponderation.h:22
Prepro_IBM_Ponderation::compute_solid_fluid
void compute_solid_fluid(int) override
Definition Prepro_IBM_Ponderation.cpp:64
Prepro_IBM_Ponderation::associer_pb
void associer_pb(const Probleme_base &) override
Definition Prepro_IBM_Ponderation.cpp:55
Prepro_IBM_base
Definition Prepro_IBM_base.h:35
Prepro_IBM_base::verbose_
int verbose_
Definition Prepro_IBM_base.h:106
Prepro_IBM_base::c_prepro_
double c_prepro_
Definition Prepro_IBM_base.h:82
Prepro_IBM_base::computeLocalFrame
void computeLocalFrame(const DoubleTab &, DoubleTab &, DoubleTab &, int)
Definition Prepro_IBM_base.cpp:278
Prepro_IBM_base::champ_aire_
champ_aire_
Definition Prepro_IBM_base.h:88
Prepro_IBM_base::dimTab_
IntTab dimTab_
Definition Prepro_IBM_base.h:83
Prepro_IBM_base::compute_h_max_elem
void compute_h_max_elem()
Definition Prepro_IBM_base.cpp:1220
Prepro_IBM_base::save_prepro_
bool save_prepro_
Definition Prepro_IBM_base.h:84
Prepro_IBM_base::compute_NeighNode
void compute_NeighNode(int)
Definition Prepro_IBM_base.cpp:1294
Prepro_IBM_base::eps_effec_
double eps_effec_
Definition Prepro_IBM_base.h:81
Prepro_IBM_base::set_param
void set_param(Param &) const override
Definition Prepro_IBM_base.cpp:39
Prepro_IBM_base::computeMatRot
void computeMatRot(const DoubleTab &, DoubleTab &, DoubleTab &, int)
Definition Prepro_IBM_base.cpp:336
Prepro_IBM_base::associer_pb
virtual void associer_pb(const Probleme_base &)
Definition Prepro_IBM_base.cpp:168
Prepro_IBM_base::Save_Med_File
void Save_Med_File()
Definition Prepro_IBM_base.cpp:1124
Prepro_IBM_base::sommets_voisins_
IntLists sommets_voisins_
Definition Prepro_IBM_base.h:102
Probleme_base
classe Probleme_base C'est un Probleme_U qui n'est pas un couplage.
Definition Probleme_base.h:55
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
Static_Int_Lists_32_64::get_list_size
int_t get_list_size(int_t i_liste) const
renvoie le nombre d'elements de la liste i
Definition Static_Int_Lists.h:102
TRUSTListElem::est_vide
int est_vide() const
Definition TRUSTListElem.h:40
TRUSTList::size
int size() const
Definition TRUSTList.h:68
TRUSTTab::dimension
_SIZE_ dimension(int d) const
Definition TRUSTTab.tpp:133
TRUSTVect::echange_espace_virtuel
virtual void echange_espace_virtuel(IsExchangeBlocking exchange_type=IsExchangeBlocking::DefaultBlocking, const std::string kernel_name="noname")
Definition TRUSTVect.tpp:282