Arcane  v3.14.10.0
Documentation développeur
Chargement...
Recherche...
Aucune correspondance
HyodaMix.cc
1// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
2//-----------------------------------------------------------------------------
3// Copyright 2000-2022 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
4// See the top-level COPYRIGHT file for details.
5// SPDX-License-Identifier: Apache-2.0
6//-----------------------------------------------------------------------------
7// ****************************************************************************
8// * HyodaMix.cc (C) 2000-2013 *
9// ****************************************************************************
10#include "arcane/IMesh.h"
11#include "arcane/IApplication.h"
12#include "arcane/IParallelMng.h"
13#include "arcane/IVariableMng.h"
14#include "arcane/ISubDomain.h"
15#include "arcane/utils/ITraceMng.h"
16#include "arcane/IVariableAccessor.h"
17#include "arcane/ServiceBuilder.h"
18#include "arcane/SharedVariable.h"
19#include "arcane/MeshVariable.h"
20#include "arcane/VariableRefArray.h"
21#include "arcane/VariableTypes.h"
22#include "arcane/utils/ScopedPtr.h"
23#include "arcane/AbstractService.h"
24#include "arcane/VariableCollection.h"
25#include "arcane/utils/ArcaneGlobal.h"
26#include "arcane/utils/IOnlineDebuggerService.h"
27#include "arcane/ITransferValuesParallelOperation.h"
28
29#include "arcane/IVariableAccessor.h"
30#include "arcane/datatype/ArrayVariant.h"
31
32#include <arcane/hyoda/Hyoda.h>
33#include <arcane/hyoda/HyodaArc.h>
34#include <arcane/hyoda/HyodaIceT.h>
35#include <arcane/hyoda/HyodaMix.h>
36#include <arcane/hyoda/IHyodaPlugin.h>
37
38#include <IceTGL.h>
39
40/*---------------------------------------------------------------------------*/
41/*---------------------------------------------------------------------------*/
42
43ARCANE_BEGIN_NAMESPACE
44
45/*---------------------------------------------------------------------------*/
46/*---------------------------------------------------------------------------*/
47
48
49// ****************************************************************************
50// * INLINE STATICS OpenGL stuffs
51// ****************************************************************************
52inline static Real3 Perp(Real3 v){
53 return Real3(v.y,-v.x,0.0);
54}
55
56static inline void glVertex(Real3 p){
57 glVertex2d(p.x,p.y);
58}
59
60inline static Real3 iColor(Int32 i){
61 if (i==0) return Real3(1.0, 0.0, 0.0);
62 if (i==1) return Real3(1.0, 1.0, 0.0);
63 if (i==2) return Real3(0.0, 1.0, 1.0);
64 if (i==3) return Real3(0.0, 0.0, 1.0);
65 return Real3(0.0, 0.0, 0.0);
66}
67
68inline static int glBorders(Real3 p0, Real3 p1, Real3 p2, Real3 p3, Real3 rgb){
69 glColor3d(rgb.x, rgb.y, rgb.z);
70 glBegin(GL_LINE_LOOP);
71 glVertex(p0);
72 glVertex(p1);
73 glVertex(p2);
74 glVertex(p3);
75 glEnd();
76 return 0;
77}
78
79inline static int glTri(Real3 p0, Real3 p1, Real3 p2, Real3 rgb){
80 glBegin(GL_LINES);
81 glColor3d(1.0,1.0,1.0);
82 glVertex(p0);
83 glVertex(p1);
84 glColor3d(rgb.x, rgb.y, rgb.z);
85 glVertex(p1);
86 glVertex(p2);
87 glVertex(p2);
88 glVertex(p0);
89 glEnd();
90 glBegin(GL_POLYGON);
91 glVertex(p0);
92 glVertex(p1);
93 glVertex(p2);
94 glEnd();
95 return 0;
96}
97
98inline static int glQuad(Real3 p0, Real3 p1, Real3 p2, Real3 p3, Real3 rgb){
99 glBegin(GL_LINES);
100 glColor3d(1.0,1.0,1.0);
101 glVertex(p0);
102 glVertex(p1);
103 glColor3d(rgb.x, rgb.y, rgb.z);
104 glVertex(p1);
105 glVertex(p2);
106 glVertex(p2);
107 glVertex(p3);
108 glVertex(p3);
109 glVertex(p0);
110 glEnd();
111 glBegin(GL_POLYGON);
112 glVertex(p0);
113 glVertex(p1);
114 glVertex(p2);
115 glVertex(p3);
116 glEnd();
117 return 0;
118}
119inline static int glQuadFull(Real3 p0, Real3 p1, Real3 p2, Real3 p3, Real3 rgb){
120 glColor3d(rgb.x, rgb.y, rgb.z);
121 glBegin(GL_LINES);
122 glVertex(p0);
123 glVertex(p1);
124 glVertex(p1);
125 glVertex(p2);
126 glVertex(p2);
127 glVertex(p3);
128 glVertex(p3);
129 glVertex(p0);
130 glEnd();
131 glBegin(GL_POLYGON);
132 glVertex(p0);
133 glVertex(p1);
134 glVertex(p2);
135 glVertex(p3);
136 glEnd();
137 return 0;
138}
139
140inline static int glPenta(Real3 p0, Real3 p1, Real3 p2, Real3 p3, Real3 p4, Real3 rgb){
141 glBegin(GL_LINES);
142 glColor3d(1.0,1.0,1.0);
143 glVertex(p0);
144 glVertex(p1);
145 glColor3d(rgb.x, rgb.y, rgb.z);
146 glVertex(p1);
147 glVertex(p2);
148 glVertex(p2);
149 glVertex(p3);
150 glVertex(p3);
151 glVertex(p4);
152 glVertex(p4);
153 glVertex(p0);
154 glEnd();
155 glBegin(GL_POLYGON);
156 glVertex(p0);
157 glVertex(p1);
158 glVertex(p2);
159 glVertex(p3);
160 glVertex(p4);
161 glEnd();
162 return 0;
163}
164
165inline static int glHexa(Real3 p0, Real3 p1, Real3 p2, Real3 p3, Real3 p4, Real3 p5, Real3 rgb){
166 glBegin(GL_LINES);
167 glColor3d(1.0,1.0,1.0);
168 glVertex(p0);
169 glVertex(p1);
170 glColor3d(rgb.x, rgb.y, rgb.z);
171 glVertex(p1);
172 glVertex(p2);
173 glVertex(p2);
174 glVertex(p3);
175 glVertex(p3);
176 glVertex(p4);
177 glVertex(p4);
178 glVertex(p5);
179 glVertex(p5);
180 glVertex(p0);
181 glEnd();
182 glBegin(GL_POLYGON);
183 glVertex(p0);
184 glVertex(p1);
185 glVertex(p2);
186 glVertex(p3);
187 glVertex(p4);
188 glVertex(p5);
189 glEnd();
190 return 0;
191}
192
193inline static int glInterface(Real3 p0, Real3 p1){
194 glColor3d(1.0f, 1.0f, 1.0f);
195 glBegin(GL_LINES);
196 glVertex(p0);
197 glVertex(p1);
198 glEnd();
199 return 0;
200}
201
202
203// ****************************************************************************
204// * HyodaMix
205// * InterfaceNormal
206// * InterfaceDistance2 materiaux
207// * InterfaceDistance2_env milieux
208// ****************************************************************************
209HyodaMix::HyodaMix(Hyoda *hd,
210 ISubDomain *subDomain,
211 ITraceMng *tm):TraceAccessor(tm),
212 m_hyoda(hd),
213 m_hPlgMats(NULL),
214 m_hPlgEnvs(NULL),
215 m_sub_domain(subDomain),
216 m_default_mesh(subDomain->defaultMesh()),
217 m_interface_normal(VariableBuildInfo(m_default_mesh, "InterfaceNormal")),
218 m_interface_distance(VariableBuildInfo(m_default_mesh, "InterfaceDistance2ForEnv",
219 IVariable::PNoDump|IVariable::PNoRestore)),
220 coords(m_default_mesh->nodesCoordinates()),
221 m_i_origine(VariableBuildInfo(m_default_mesh, "OriginOffset")),
222 m_x_codes(VariableBuildInfo(m_default_mesh, "IntersectionCodes"))
223
224{
225 ServiceBuilder<IHyodaPlugin> serviceBuilder(m_sub_domain);
226 m_hPlgMats = serviceBuilder.createInstance("HyodaMats", SB_AllowNull);
227 m_hPlgEnvs = serviceBuilder.createInstance("HyodaEnvs", SB_AllowNull);
228 if (m_hPlgMats){
229 debug() << "\33[7m[HyodaMix::HyodaMix] Hyoda materials plugin loaded\33[m";
230 m_hPlgMats->setHyodaMix(m_hyoda,this);
231 }else{
232 debug() << "\33[7m[HyodaMix::HyodaMix] NULL Hyoda materials plugin\33[m";
233 }
234 if (m_hPlgEnvs){
235 debug() << "\33[7m[HyodaMix::HyodaMix] Hyoda environments plugin loaded\33[m";
236 m_hPlgEnvs->setHyodaMix(m_hyoda,this);
237 }else{
238 debug() << "\33[7m[HyodaMix::HyodaMix] NULL Hyoda environments plugin\33[m";
239 }
240 // Les points d'intersection sont ceux possibles par coté
241 // Il semble qu'on ait trois interfaces possibles au maximum
242 m_p.resize(4);
243 m_x.resize(12);
244}
245
246
247// ****************************************************************************
248// * getCellOrigin & Outils
249// ****************************************************************************
250typedef struct Real_Int32{
251 Real dot;
252 Int32 idx;
253}Real_Int32;
254static inline int comparOrigins(const void *one, const void *two){
255 const Real_Int32 *frst=(Real_Int32*)one;
256 const Real_Int32 *scnd=(Real_Int32*)two;
257 if (frst->dot == scnd->dot) return 0;
258 if (frst->dot < scnd->dot) return -1;
259 return +1;
260}
261void HyodaMix::setCellOrigin(Cell cell){
262 struct Real_Int32 rtn[cell->nbNode()];
263 // on profite qu'on cherche la nouvelle origine pour flusher le tableau des coordonnées des intersections
264 Real3 flush(0.,0.,0.);
265 m_p.fill(flush);
266 m_x.fill(flush);
267 //debug()<<"\t[getCellOrigin] normal="<<m_interface_normal[cell];
268 for(Int32 i=0,iMx=cell->nbNode();i<iMx;i+=1){
269 //debug()<<"\t[getCellOrigin] node#"<<i<<":"<< m_default_mesh->nodesCoordinates()[cell->node(i)];
270 rtn[i].idx=i;
271 rtn[i].dot=math::scaMul(m_interface_normal[cell], coords[cell->node(i)]);
272 }
273 qsort(rtn,cell->nbNode(),sizeof(Real_Int32),comparOrigins);
274 // On sauve l'origine de cette maille
275 m_i_origine[cell]=rtn[0].idx;
276 //return m_i_origine[cell];
277}
278
279
280// ****************************************************************************
281// * xNrmDstSgmt2Point
282// * Input: l'"origine", le vecteur normal, une distance et le segment
283// * Output: màj du point d'intersection s'il existe et 0||1 pour l'indiquer
284// ****************************************************************************
285int HyodaMix::xNrmDstSgmt2Point(Real3 p0, Real3 d0, Real3 p1, Real3 p2, Real3 &xPoint){
286 Real3 d1=p2-p1;
287 Real3 delta=p1-p0;
288 Real d0pd1=math::scaMul(d0,Perp(d1));
289 debug()<<"\t\t[xNrmDstSgmt2Point] p0"<<p0<<", d0"<<d0;
290 debug()<<"\t\t[xNrmDstSgmt2Point] Segment "<<p1<<p2;//<<", delta="<<delta<<", d0pd1="<<d0pd1;
291 if (d0pd1==0.0){
292 if (math::scaMul(delta,d0)==0.0){
293 debug()<<"\t\t[xNrmDstSgmt2Point] The're the same";
294 }else{
295 debug()<<"\t\t[xNrmDstSgmt2Point] The lines are nonintersecting and parallel";
296 }
297 return 0;
298 }
299 Real inv_d0pd1=1.0/d0pd1;
300 //Real s=Dot(delta,Perp(d1))*inv_d0pd1;
301 Real t=math::scaMul(delta,Perp(d0))*inv_d0pd1;
302 //debug()<<"\t\t[xNrmDstSgmt2Point] s="<<s;
303 //debug()<<"\t\t[xNrmDstSgmt2Point] t="<<t;
304 //debug()<<"\t\t[xNrmDstSgmt2Point] d1.abs()="<<d1.abs();
305 if ((t>=0.0) && (t<=1.0)){
306 debug()<<"\t\t[xNrmDstSgmt2Point] T Intersection here!";
307 xPoint=p1+t*d1;
308 return 1;
309 }
310 debug()<<"\t\t[xNrmDstSgmt2Point] No intersection here!";
311 return 0;
312}
313
314
315// *****************************************************************************
316// * xCellPoints
317// * Input: l'"origine", le vecteur normal, une distance et le segment
318// * Output: màj du point d'intersection s'il existe et 0||1 pour l'indiquer
319// ****************************************************************************
320Int32 HyodaMix::xCellPoints(Cell c,
321 Real3 normale,
322 Real distance,
323 Int32 order){
324 Int32 iOrg=m_i_origine[c];
325 Int32 xCode=0;
326 Real3 d0=Perp(normale);
327 Real3 p0=distance*normale; // Le vecteur d0 porte la droite
328 m_p[0]=coords[c->node(iOrg)];
329 m_p[1]=coords[c->node((iOrg+1)%4)];
330 m_p[2]=coords[c->node((iOrg+2)%4)];
331 m_p[3]=coords[c->node((iOrg+3)%4)];
332 if (order>2) fatal()<<"[HyodaMix::xCellPoints] order>2";
333 if (xNrmDstSgmt2Point(p0,d0,m_p[1],m_p[0],m_x[4*order+iOrg])==1) xCode|=1;
334 if (xNrmDstSgmt2Point(p0,d0,m_p[2],m_p[1],m_x[4*order+((iOrg+1)%4)])==1) xCode|=2;
335 if (xNrmDstSgmt2Point(p0,d0,m_p[3],m_p[2],m_x[4*order+((iOrg+2)%4)])==1) xCode|=4;
336 if (xNrmDstSgmt2Point(p0,d0,m_p[0],m_p[3],m_x[4*order+((iOrg+3)%4)])==1) xCode|=8;
337 // On sauve les codes
338 m_x_codes[c]|=xCode<<(order<<2);
339 return xCode;
340}
341
342
343// *****************************************************************************
344// * xCellDrawInterface
345// *****************************************************************************
346void HyodaMix::xCellDrawInterface(Cell c, Int32 order){
347 Int32 iOrg=m_i_origine[c];
348 Int32 xCode=(m_x_codes[c]>>(order<<2))&0xFul;
349 //debug()<<"HyodaMix::xCellDrawInterface xCode="<<xCode;
350 if (order>2) fatal()<<"xCellDrawInterface order>2";
351 // On dessine les interfaces
352 if (xCode==0x0) return;
353 if (xCode==0xF) return;
354 if (xCode==0x3) {glInterface(m_x[4*order+iOrg], m_x[4*order+((iOrg+1)%4)]); return;}
355 if (xCode==0x5) {glInterface(m_x[4*order+iOrg], m_x[4*order+((iOrg+2)%4)]); return;}
356 if (xCode==0x6) {glInterface(m_x[4*order+((iOrg+1)%4)], m_x[4*order+((iOrg+2)%4)]); return;}
357 if (xCode==0x9) {glInterface(m_x[4*order+iOrg], m_x[4*order+((iOrg+3)%4)]); return;}
358 if (xCode==0xA) {glInterface(m_x[4*order+((iOrg+1)%4)], m_x[4*order+((iOrg+3)%4)]); return;}
359 if (xCode==0xC) {glInterface(m_x[4*order+((iOrg+2)%4)], m_x[4*order+((iOrg+3)%4)]); return;}
360 fatal()<<"HyodaMix::xCellDrawInterface Unknown! (xCode="<<xCode<<")";
361}
362
363
364// *****************************************************************************
365// * xCellBorders
366// * hypothèses de dessin: xCodes(order)!=0 car testé avant
367// *****************************************************************************
368int HyodaMix::xCellBorders(Cell cell,
369 Real min, Real max,
370 Real val){
371 Real3 rgb;
372 // On récupère la couleur selon val et par rapport à min & max
373 m_hyoda->meshIceT()->setColor(min,max,val,rgb);
374 // On dessine les contours
375 glBorders(coords[cell->node(0)], coords[cell->node(1)],
376 coords[cell->node(2)], coords[cell->node(3)], rgb);
377 return 0;
378}
379
380
381// *****************************************************************************
382// * xCellFill
383// * hypothèses de dessin: xCodes(order)!=0 car testé avant
384// *****************************************************************************
385int HyodaMix::xCellFill(Cell cell,
386 Int32Array& xCodes,
387 Real min, Real max,
388 Real val,
389 Int32 order,
390 Int32 nbMilieux){
391 Int32 iOrg=m_i_origine[cell];
392 // On va chercher la couleur de notre valeure
393 Real3 rgb;
394 Real3 p[4];
395 Real3 x[12];
396
397 debug() << "\t\t[HyodaMix::xCellFill] #"<<cell.uniqueId()
398 << ": nbMilieux=" << nbMilieux
399 << ", order=" << order << ", xCodes=" << xCodes;
400
401 if (val<min) warning()<<"[HyodaMix::xCellFill] val<min " << val <<" < " << min;
402 if (val>max) warning()<<"[HyodaMix::xCellFill] val>max " << val <<" > " << max;
403
404 // On récupère la couleur selon val et par rapport à min & max
405 m_hyoda->meshIceT()->setColor(min,max,val,rgb);
406 m_hyoda->meshIceT()->checkOglError();
407
408 //if (cell.uniqueId()==49) rgb=Real3(1.0,1.0,1.0);
409
410 // On récupère les points dans l'ordre
411 p[0]=m_p[0];
412 p[1]=m_p[1];
413 p[2]=m_p[2];
414 p[3]=m_p[3];
415
416 // On récupère les intersections dans l'ordre
417 x[0] = m_x[4*0+iOrg];
418 x[1] = m_x[4*0+((iOrg+1)%4)];
419 x[2] = m_x[4*0+((iOrg+2)%4)];
420 x[3] = m_x[4*0+((iOrg+3)%4)];
421 x[4] = m_x[4*1+iOrg];
422 x[5] = m_x[4*1+((iOrg+1)%4)];
423 x[6] = m_x[4*1+((iOrg+2)%4)];
424 x[7] = m_x[4*1+((iOrg+3)%4)];
425 x[8] = m_x[4*2+iOrg];
426 x[9] = m_x[4*2+((iOrg+1)%4)];
427 x[10]= m_x[4*2+((iOrg+2)%4)];
428 x[11]= m_x[4*2+((iOrg+3)%4)];
429
430 if (order>2) fatal()<<"[HyodaMix::xCellFill] order>2";
431
432 // Cas d'un seul milieu
433 if ((nbMilieux==1 && order==0)
434 || (nbMilieux==1 && xCodes[0]==0xF))
435 return glQuadFull(coords[cell->node(0)], coords[cell->node(1)],
436 coords[cell->node(2)], coords[cell->node(3)], rgb);
437
438 // Cas de deux milieux
439 if (nbMilieux==2 && order==0) return xCellFill_i2_o0(cell,p,x,xCodes,rgb);
440 if (nbMilieux==2 && order==1) return xCellFill_i2_o1(cell,p,x,xCodes,rgb);
441
442 // Cas de trois milieux
443 if (nbMilieux==3 && order==0) return xCellFill_i3_o0(cell,p,x,xCodes,rgb);
444 if (nbMilieux==3 && order==1) return xCellFill_i3_o1(cell,p,x,xCodes,rgb);
445 if (nbMilieux==3 && order==2) return xCellFill_i3_o2(cell,p,x,xCodes,rgb);
446
447 fatal() << "[HyodaMix::xCellFill] Unknown"
448 << ", nbMilieux=" << nbMilieux
449 << ", order=" << order
450 << ", with codes=" << xCodes;
451
452 // CC : pour respecter le prototype
453 return -1;
454}
455
456
457
458// *****************************************************************************
459// * xCellFill_i2_o0 - Cas de 2 milieux et d'ordre 0
460// *****************************************************************************
461int HyodaMix::xCellFill_i2_o0(Cell c, Real3 p[4], Real3 x[12], Int32Array& xCodes, Real3 rgb){
462 Int32 xCode0=xCodes.at(0);
463 Int32 xCode1=xCodes.at(1);
464
465 debug() << "\33[7m[xCellFill_i2_o0] xCode0="<<xCode0 <<", xCode1="<<xCode1<<"\33[m";
466
467 // Si les deux sont vides, c'est pas normale
468 if (xCode0==0x0 && xCode1==0x0)
469 warning() << "HyodaMix: #" << c.uniqueId()
470 << ": Case of 2 empty medium!";
471
472 // Je m'impose par défaut
473 if (xCode0==0xF ||(xCode0==0x0 && xCode1==0x0))
474 return glQuadFull(coords[c->node(0)],
475 coords[c->node(1)],
476 coords[c->node(2)],
477 coords[c->node(3)], rgb);
478
479 // Si je suis vide, je laisse la place
480 if (xCode0==0x0) return 0;
481
482 // Si le prochain est vide, on remplit l'espace
483 //if (xCode1==0x0) return glQuadFull(coords[c->node(0)],coords[c->node(1)],coords[c->node(2)],coords[c->node(3)], rgb);
484
485 // Sinon, on prend notre partie
486 if (xCode0==0x3) return glPenta(x[0],x[1],p[2],p[3],p[0],rgb);
487 if (xCode0==0x5) return glQuad(x[0],x[2],p[3],p[0],rgb);
488 if (xCode0==0x6) return glPenta(x[1],x[2],p[3],p[0],p[1],rgb);
489 if (xCode0==0x9) return glTri(x[0],x[3],p[0],rgb);
490 if (xCode0==0xA) return glQuad(x[1],x[3],p[0],p[1],rgb);
491 if (xCode0==0xC) return glPenta(x[2],x[3],p[0],p[1],p[2],rgb);
492 warning()<<"HyodaMix::xCellFill_i2_o0 #"<<c.uniqueId()
493 << "Unknown!";
494 return 0;
495}
496
497
498// *****************************************************************************
499// * xCellFill_i2_o1 - Cas de 2 milieux et d'ordre 1
500// *****************************************************************************
501int HyodaMix::xCellFill_i2_o1(Cell c, Real3 p[4], Real3 x[12], Int32Array& xCodes, Real3 rgb){
502 Int32 xCode0=xCodes.at(0);
503 Int32 xCode1=xCodes.at(1);
504
505 debug() << "\33[7m[xCellFill_i2_o1] xCode0="<<xCode0 <<", xCode1="<<xCode1<<"\33[m";
506
507 // Si les deux sont pleins, on laisse
508 if (xCode0==0xF) return 0;
509
510 // Si 0 vide mais pas moi, je prends
511 if (xCode0==0x0 && xCode1!=0x0) return glQuadFull(coords[c->node(0)],
512 coords[c->node(1)],
513 coords[c->node(2)],
514 coords[c->node(3)],rgb);
515
516 //if (xCode0==0x3 && xCode1==0x3) return glQuad(x[0],m_x[c][4+iOrg],m_x[c][4+((iOrg+1)%4)],x[1],rgb);
517 //if (xCode0==0x3 && xCode1==0xF) return glTri(x[0],p[1],x[1],rgb);
518 if (xCode0==0x3) return glTri(x[1],x[0],p[1],rgb);
519
520 //if (xCode0==0x5 && xCode1==0x5) return glQuad(x[0],m_x[c][4+iOrg],x[6],x[2],rgb);
521 //if (xCode0==0x5 && xCode1==0x3) return glPenta(x[0],m_x[c][4+iOrg],m_x[c][4+((iOrg+1)%4)],p[2],x[2],rgb);
522 //if (xCode0==0x5 && xCode1==0x6) return glPenta(x[0],p[1],m_x[c][4+((iOrg+1)%4)],x[6],x[2],rgb);
523 //if (xCode0==0x5 && xCode1==0xF) return glQuad(x[0],p[1],p[2],x[2],rgb);
524 if (xCode0==0x5) return glQuad(x[2],x[0],p[1],p[2],rgb);
525
526 //if (xCode0==0x6 && xCode1==0x6) return glQuad(x[1],m_x[c][4+((iOrg+1)%4)],x[6],x[2],rgb);
527 //if (xCode0==0x6 && xCode1==0xF) return glTri(x[1],p[2],x[2],rgb);
528 if (xCode0==0x6) return glTri(x[2],x[1],p[2],rgb);
529
530 //if (xCode0==0x9 && xCode1==0x3) return glHexa(x[0],m_x[c][4+iOrg],m_x[c][4+((iOrg+1)%4)],p[2],p[3],x[3],rgb);
531 //if (xCode0==0x9 && xCode1==0x5) return glPenta(x[0],m_x[c][4+iOrg],x[6],p[3],x[3],rgb);
532 //if (xCode0==0x9 && xCode1==0x6) return glHexa(x[0],p[1],m_x[c][4+((iOrg+1)%4)],x[6],p[3],x[3],rgb);
533 //if (xCode0==0x9 && xCode1==0x9) return glQuad(x[0],m_x[c][4+iOrg],x[7],x[3],rgb);
534 //if (xCode0==0x9 && xCode1==0xA) return glPenta(x[0],p[1],m_x[c][4+((iOrg+1)%4)],x[7],x[3],rgb);
535 //if (xCode0==0x9 && xCode1==0xC) return glHexa(x[0],p[1],p[2],x[6],x[7],x[3],rgb);
536 //if (xCode0==0x9 && xCode1==0xF) return glPenta(x[0],p[1],p[2],p[3],x[3],rgb);
537 if (xCode0==0x9) return glPenta(x[3],x[0],p[1],p[2],p[3],rgb);
538
539 //if (xCode0==0xA && xCode1==0xA) return glQuad(x[1],m_x[c][4+((iOrg+1)%4)],x[7],x[3],rgb);
540 //if (xCode0==0xA && xCode1==0x6) return glPenta(x[1],m_x[c][4+((iOrg+1)%4)],x[6],p[3],x[3],rgb);
541 //if (xCode0==0xA && xCode1==0xC) return glPenta(x[1],p[2],x[6],x[7],x[3],rgb);
542 //if (xCode0==0xA && xCode1==0xF) return glQuad(x[1],p[2],p[3],x[3],rgb);
543 if (xCode0==0xA) return glQuad(x[3],x[1],p[2],p[3],rgb);
544
545 //if (xCode0==0xC && xCode1==0xC) return glQuad(x[6],x[2],x[3],x[7],rgb);
546 //if (xCode0==0xC && xCode1==0xF) return glPenta(x[3],p[0],p[1],p[2],x[2],rgb);
547 if (xCode0==0xC) return glPenta(x[2],x[3],p[0],p[1],p[2],rgb);
548
549 warning()<<"HyodaMix::xCellFill_i2_o1 #"<<c.uniqueId()
550 << ": Unknown!";
551 return 0;
552}
553
554
555// *****************************************************************************
556// * xCellFill_i3_o0 - Cas de 3 milieux et d'ordre 0
557// *****************************************************************************
558int HyodaMix::xCellFill_i3_o0(Cell c, Real3 p[4], Real3 x[12], Int32Array& xCodes, Real3 rgb){
559 Int32 x0=xCodes.at(0);
560 Int32 x1=xCodes.at(1);
561 Int32 x2=xCodes.at(2);
562
563 //debug()<<"\tHyodaMix::xCellFill_i3_o0 " << xCodes;
564
565 // Si les 3 sont vides, c'est pas normal
566 if (x0==0x0 && x1==0x0 && x2==0x0)
567 warning()<<"xCellFill_i3_o0 #"<<c.uniqueId()
568 << ": 0x0 && 0x0!";
569
570 // Je m'impose par défaut
571 if (x0==0xF) return glQuadFull(coords[c->node(0)],
572 coords[c->node(1)],
573 coords[c->node(2)],
574 coords[c->node(3)],rgb);
575
576 // Si je suis vide, je laisse la place
577 if (x0==0x0) return 0;
578
579 // Si les prochains sont vides, on remplit l'espace
580 if (x1==0x0 && x2==0x0) return glQuadFull(coords[c->node(0)],
581 coords[c->node(1)],
582 coords[c->node(2)],
583 coords[c->node(3)],rgb);
584
585 // Sinon, on prend notre partie
586 if (x0==0x3) return glPenta(x[0],x[1],p[2],p[3],p[0],rgb);
587 if (x0==0x5) return glQuad(x[0],x[2],p[3],p[0],rgb);
588 if (x0==0x6) return glPenta(x[1],x[2],p[3],p[0],p[1],rgb);
589 if (x0==0x9) return glTri(x[0],x[3],p[0],rgb);
590 if (x0==0xA) return glQuad(x[1],x[3],p[0],p[1],rgb);
591 if (x0==0xC) return glPenta(x[2],x[3],p[0],p[1],p[2],rgb);
592 warning()<<"HyodaMix::xCellFill_i3_o0 #"<<c.uniqueId()
593 << "Unknown!";
594 return 0;
595}
596
597
598// *****************************************************************************
599// * xCellFill_i3_o1 - Cas de 3 milieux et d'ordre 1
600// *****************************************************************************
601int HyodaMix::xCellFill_i3_o1(Cell c, Real3 p[4], Real3 x[12], Int32Array& xCodes, Real3 rgb){
602 Int32 x0=xCodes.at(0);
603 Int32 x1=xCodes.at(1);
604 Int32 x2=xCodes.at(2);
605
606 //debug()<<"\tHyodaMix::xCellFill_i3_o1 " << xCodes;
607
608 // Si les 3 sont pleins, on laisse
609 if (x0==0xF && x1==0xF && x2==0xF) return 0;
610
611 // Si 0&1 vide mais pas moi, je prends
612 if (x0==0x0 && x1==0x0) return glQuadFull(coords[c->node(0)],
613 coords[c->node(1)],
614 coords[c->node(2)],
615 coords[c->node(3)],rgb);
616
617 if (x0==0x0 && x1==0x5) return glQuad(x[4],x[6],p[3],p[0],rgb);
618 if (x0==0x0 && x1==0x6) return glPenta(x[5],x[6],p[3],p[0],p[1],rgb);
619 if (x0==0x0 && x1==0xA) return glQuad(x[5],x[7],p[0],p[1],rgb);
620
621 if (x0==0x3 && x1==0x3) return glQuad(x[1],x[0],x[4],x[5],rgb);
622 if (x0==0x3 && x1==0xF) return glTri(x[1],x[0],p[1],rgb);
623
624 if (x0==0x5 && x1==0x5) return glQuad(x[4],x[6],x[2],x[0],rgb);
625 if (x0==0x5 && x1==0x3) return glPenta(x[4],x[5],p[2],x[2],x[0],rgb);
626 if (x0==0x5 && x1==0x6) return glPenta(x[5],x[6],x[2],x[0],p[1],rgb);
627 if (x0==0x5 && x1==0xF) return glQuad(x[2],x[0],p[1],p[2],rgb);
628
629 if (x0==0x6 && x1==0x6) return glQuad(x[5],x[6],x[2],x[1],rgb);
630 if (x0==0x6 && x1==0xF) return glTri(x[2],x[1],p[2],rgb);
631
632 if (x0==0x9 && x1==0x3) return glHexa(x[4],x[5],p[2],p[3],x[3],x[0],rgb);
633 if (x0==0x9 && x1==0x5) return glPenta(x[4],x[6],p[3],x[3],x[0],rgb);
634 if (x0==0x9 && x1==0x6) return glHexa(x[5],x[6],p[3],x[3],x[0],p[1],rgb);
635 if (x0==0x9 && x1==0x9) return glQuad(x[4],x[7],x[3],x[0],rgb);
636 if (x0==0x9 && x1==0xA) return glPenta(x[5],x[7],x[3],x[0],p[1],rgb);
637 if (x0==0x9 && x1==0xC) return glHexa(x[6],x[7],x[3],x[0],p[1],p[2],rgb);
638 if (x0==0x9 && x1==0xF) return glPenta(x[3],x[0],p[1],p[2],p[3],rgb);
639
640 if (x0==0xA && x1==0xA) return glQuad(x[5],x[7],x[3],x[1],rgb);
641 if (x0==0xA && x1==0x6) return glPenta(x[5],x[6],p[3],x[3],x[1],rgb);
642 if (x0==0xA && x1==0xC) return glPenta(x[6],x[7],x[3],x[1],p[2],rgb);
643 if (x0==0xA && x1==0xF) return glQuad(x[3],x[1],p[2],p[3],rgb);
644
645 if (x0==0xC && x1==0xC) return glQuad(x[7],x[6],x[2],x[3],rgb);
646 if (x0==0xC && x1==0xF) return glPenta(x[2],x[3],p[0],p[1],p[2],rgb);
647
648 warning() << "\33[7m[HyodaEnvs::xCellFill_i3_o1] #"<<c.uniqueId()
649 << ": unhandled " << xCodes <<"\33[m";
650 return 0;
651}
652
653
654// *****************************************************************************
655// * xCellFill_i3_o2 - Cas de 3 milieux et d'ordre 2
656// *****************************************************************************
657int HyodaMix::xCellFill_i3_o2(Cell c, Real3 p[4], Real3 x[12], Int32Array& xCodes, Real3 rgb){
658 Int32 x0=xCodes.at(0);
659 Int32 x1=xCodes.at(1);
660 Int32 x2=xCodes.at(2);
661
662 //debug()<<"\tHyodaMix::xCellFill_i3_o2 " << xCodes;
663
664 // 0||1 ont déjà tout pris
665 if (x0==0xF || x1==0xF) return 0;
666
667 // 2 premiers vides et pas moi = je prends tout
668 if (x0==0x0 && x1==0x0 && x2!=0x0) return glQuadFull(coords[c->node(0)],
669 coords[c->node(1)],
670 coords[c->node(2)],
671 coords[c->node(3)],rgb);
672
673 if (x0==0x0 && x1==0x5 && x2==0x6) return glPenta(x[9],x[10],x[6],x[4],p[1],rgb);
674 if (x0==0x0 && x1==0x6 && x2==0x6) return glQuad(x[9],x[10],x[6],x[5],rgb);
675 if (x0==0x0 && x1==0x6 && x2==0xF) return glTri(x[6],x[5],p[2],rgb);
676 if (x0==0x0 && x1==0xA && x2==0xF) return glQuad(x[7],x[5],p[2],p[3],rgb);
677
678 if (x0==0x5 && x1==0x5 && x2==0x5) return glQuad(x[8],x[10],x[6],x[4],rgb);
679 if (x0==0x5 && x1==0x5 && x2==0x6) return glPenta(x[9],x[10],x[6],x[4],p[1],rgb);
680 if (x0==0x5 && x1==0x5 && x2==0xF) return glQuad(x[6],x[4],p[1],p[2],rgb);
681 if (x0==0x5 && x1==0x6 && x2==0x6) return glQuad(x[9],x[10],x[6],x[5],rgb);
682 if (x0==0x5 && x1==0x6 && x2==0xF) return glTri(x[6],x[5],p[2],rgb);
683
684 if (x0==0x6 && x1==0x6 && x2==0x6) return glQuad(x[9],x[10],x[6],x[5],rgb);
685 if (x0==0x6 && x1==0x6 && x2==0xF) return glTri(x[6],x[5],p[2],rgb);
686
687 if (x0==0x9 && x1==0x5 && x2==0x5) return glQuad(x[8],x[10],x[6],x[4],rgb);
688 if (x0==0x9 && x1==0x5 && x2==0xF) return glQuad(x[6],x[4],p[1],p[2],rgb);
689 if (x0==0x9 && x1==0x5 && x2==0x6) return glPenta(x[9],x[10],x[6],x[4],p[1],rgb);
690 if (x0==0x9 && x1==0x6 && x2==0x6) return glQuad(x[9],x[10],x[6],x[5],rgb);
691 if (x0==0x9 && x1==0x6 && x2==0xF) return glTri(x[6],x[5],p[2],rgb);
692 if (x0==0x9 && x1==0x9 && x2==0x6) return glHexa(x[9],x[10],p[3],x[7],x[4],p[1],rgb);
693 if (x0==0x9 && x1==0x9 && x2==0xF) return glPenta(x[7],x[4],p[1],p[2],p[3],rgb);
694 if (x0==0x9 && x1==0xA && x2==0x6) return glPenta(x[9],x[10],p[3],x[7],x[5],rgb);
695 if (x0==0x9 && x1==0xA && x2==0xF) return glQuad(x[7],x[5],p[2],p[3],rgb);
696
697 if (x0==0xA && x1==0x6 && x2==0x6) return glQuad(x[9],x[10],x[6],x[5],rgb);
698 if (x0==0xA && x1==0x6 && x2==0xF) return glTri(x[6],x[5],p[2],rgb);
699 if (x0==0xA && x1==0xA && x2==0x6) return glPenta(x[9],x[10],p[3],x[7],x[5],rgb);
700 if (x0==0xA && x1==0xA && x2==0xA) return glQuad(x[9],x[11],x[7],x[5],rgb);
701 if (x0==0xA && x1==0xA && x2==0xF) return glQuad(x[7],x[5],p[2],p[3],rgb);
702 if (x0==0xA && x1==0xC && x2==0xF) return glPenta(x[6],x[7],p[0],p[1],p[2],rgb);
703 warning() << "\33[7m[HyodaEnvs::xCellFill_i3_o2] #"<< c.uniqueId()
704 << ": unhandled " << xCodes <<"\33[m";
705 return 0;
706}
707
708
709// *****************************************************************************
710// * xLine2Cell
711// * On devrait vérifier que la distance considérée est bien >0.0 et < diagonale
712// * depuis l'"origine"
713// ****************************************************************************
714void HyodaMix::xLine2Cell(int plugin, IVariable *variable, Real min, Real max){
715 // Si QHyoda réclame les globals, c'est pas normal ici
716 if (plugin==0)
717 fatal() << "\33[7m[HyodaEnvs::xLine2Cell] plugin==0\33[m";
718
719 // Si QHyoda réclame les 'environments', on les lui affiche depuis le plugin HyodaEnvs
720 if (plugin==1){
721 if (m_hPlgEnvs!=NULL){
722 if (variable->itemKind()!=IK_Cell)
723 throw FatalErrorException("[HyodaMix::xLine2Cell] QHyoda 'env' plugin only support IK_Cell!");
724 m_hPlgEnvs->draw(variable,min,max);
725 }else
726 debug()<<"\t\33[7m[xLine2Cell] plugin==2 & Null m_hPlgEnvs!\33[m";
727 }
728
729 // Si QHyoda réclame les 'materials', on les lui affiche depuis le plugin HyodaMats
730 if (plugin==2){
731 if (m_hPlgMats!=NULL)
732 m_hPlgMats->draw(variable,min,max);
733 else
734 debug()<<"\t\33[7m[xLine2Cell] plugin==1 & Null m_hPlgMats!\33[m";
735 }
736
737
738}
739
740
741// *****************************************************************************
742// * xCellDrawNormal
743// *****************************************************************************
744void HyodaMix::
745xCellDrawNormal(Cell c, Real3 p[4], Int32 iDst)
746{
747 ARCANE_UNUSED(iDst);
748 if (m_interface_normal[c].abs()==0.0)
749 return;
750 // Maille en cours
751 glBegin(GL_POINTS);
752 glColor3d(1.0, 1.0, 1.0); glVertex(p[0]);
753 glColor3d(1.0, 0.0, 0.0); glVertex(p[1]);
754 glColor3d(0.0, 1.0, 0.0); glVertex(p[2]);
755 glColor3d(0.0, 0.0, 1.0); glVertex(p[3]);
756 glEnd();
757 // Vecteur org à org+normale
758 glColor3d(1.0, 1.0, 1.0);
759 glBegin(GL_LINES);
760 glVertex(p[0]);
761 glVertex(p[0]+m_interface_normal[c]);
762 glEnd();
763}
764
765
766/*---------------------------------------------------------------------------*/
767/*---------------------------------------------------------------------------*/
768
769ARCANE_END_NAMESPACE
770
771/*---------------------------------------------------------------------------*/
772/*---------------------------------------------------------------------------*/
ArcaneGlobal.h
Fichier de configuration d'Arcane.
Arcane::LimaWrapper
Lecteur des fichiers de maillage via la bibliothèque LIMA.
Definition Lima.cc:120
Arcane::math::max
T max(const T &a, const T &b, const T &c)
Retourne le maximum de trois éléments.
Definition MathUtils.h:392
Arcane::math::min
ARCCORE_HOST_DEVICE Real2 min(Real2 a, Real2 b)
Retourne le minimum de deux Real2.
Definition MathUtils.h:336
Real_Int32
Definition HyodaMix.cc:250