MAGiC  V5.0
Mailleurs Automatiques de Géometries intégrés à la Cao
mg_file.cpp
Aller à la documentation de ce fichier.
1 //####//------------------------------------------------------------
2 //####//------------------------------------------------------------
3 //####// MAGiC
4 //####// Jean Christophe Cuilliere et Vincent FRANCOIS
5 //####// Departement de Genie Mecanique - UQTR
6 //####//------------------------------------------------------------
7 //####// MAGIC est un projet de recherche de l equipe ERICCA
8 //####// du departement de genie mecanique de l Universite du Quebec a Trois Rivieres
9 //####// http://www.uqtr.ca/ericca
10 //####// http://www.uqtr.ca/
11 //####//------------------------------------------------------------
12 //####//------------------------------------------------------------
13 //####//
14 //####// mg_file.cpp
15 //####//
16 //####//------------------------------------------------------------
17 //####//------------------------------------------------------------
18 //####// COPYRIGHT 2000-2024
19 //####// jeu 13 jun 2024 11:58:53 EDT
20 //####//------------------------------------------------------------
21 //####//------------------------------------------------------------
22 
23 
24 #include "gestionversion.h"
25 
26 #pragma hdrstop
27 
28 #include <string.h>
29 #include "mg_file.h"
30 #include "mg_sommet_noeud.h"
31 #include "mg_arete_element.h"
32 #include "mg_face_element.h"
33 #include "mg_volume_element.h"
34 #include "mg_coque_element.h"
35 #include "mg_poutre_element.h"
36 #include "pars_argument.h"
37 #include "parse.h"
38 #include "ot_chaine.h"
39 #ifdef BREP_STEP
40 #include "step_surface.h"
41 #include "step_courbe.h"
42 #include "step_point.h"
43 #endif
44 #ifdef BREP_SAT
45 #include "acis_surface.h"
46 #include "acis_courbe.h"
47 #include "acis_point.h"
48 #endif
49 #include "lc_point.h"
50 #include "fem_segment2.h"
51 #include "fem_mini_segment2.h"
52 #include "fem_segment3.h"
53 #include "fem_triangle3.h"
54 #include "fem_triangle6.h"
55 #include "fem_quadrangle4.h"
56 #include "fem_quadrangle8.h"
57 #include "fem_tetra4.h"
58 #include "xfem_segment2.h"
59 #include "xfem_triangle3.h"
60 #include "xfem_tetra4.h"
61 #include "fem_tetra10.h"
62 #include "fem_hexa8.h"
63 #include "fem_hexa20.h"
64 #include "fem_penta6.h"
65 #include "fem_penta15.h"
66 #ifdef BREP_OCC
67 #include "occ_surface.h"
68 #include "occ_point.h"
69 #include "occ_courbe.h"
70 #include "occ_fonction.h"
71 #include "TopoDS_Shape.hxx"
72 #include "TopoDS.hxx"
73 #include "occ_sommet.h"
74 #endif
75 #ifdef CSG_OCC
76 #include "mg_assemblage.h"
77 #include "mg_primitive_boite.h"
78 #include "mg_primitive_sphere.h"
79 #include "mg_primitive_ellipsoide_revolution.h"
80 #include "mg_primitive_cylindre.h"
81 #include "mg_primitive_cone.h"
82 #include "mg_primitive_tore.h"
83 #include "mg_primitive_complexe.h"
84 #include "mg_operateur_boolean_union.h"
85 #include "mg_operateur_boolean_difference.h"
86 #include "mg_operateur_boolean_intersection.h"
87 
88 #endif
89 #include "occ_fonction_v2017.h"
90 #include "mg_cg_forme.h"
91 #include "mg_cg_forme_arete_droite.h"
92 #include "mg_cg_forme_volume_boite.h"
93 #include "mg_cg_forme_volume_sphere.h"
94 #include "mg_cg_forme_volume_ellipsoide.h"
95 #include "mg_cg_forme_volume_cylindre.h"
96 #include "mg_cg_forme_volume_cone.h"
97 #include "mg_cg_forme_volume_tore.h"
98 #include "mg_cg_forme_multiple.h"
99 #include "mg_cg_forme_multi_volume.h"
100 #include "mg_cg_op_bool_union.h"
101 #include "mg_cg_op_bool_difference.h"
102 #include "mg_cg_op_bool_intersection.h"
103 #include "mg_cg_op_bool_fragment.h"
104 #include "mg_cg_op_inclusion_matrice.h"
105 #include "mg_cg_op_transf_rotation.h"
106 #include "mg_cg_op_transf_translation.h"
107 #include "mg_cg_op_transf_echelle.h"
108 #include "mg_cg_op_transf_decallage.h"
109 #include "mg_cg_modele.h"
110 #include "mg_cg_assemblage.h"
111 #include "mg_cg_op_bool_union.h"
112 #include "mg_cg.h"
113 #include "mg_sous_geometrie.h"
114 #include "mg_cg_info.h"
115 #include "mg_cg_groupe_forme.h"
116 
117 #ifdef WINDOWS_VERSION
118 #include "CAD4FE_MCEdge.h"
119 #include "CAD4FE_MCFace.h"
120 #include "CAD4FE_MCVertex.h"
121 #include "CAD4FE_PolySurface.h"
122 #include "CAD4FE_PolyCurve.h"
123 #include "CAD4FE_MCNode.h"
124 #include "CAD4FE_MCSegment.h"
125 #include "CAD4FE_MCTriangle.h"
126 #include "CAD4FE_m3d_MCTriangle.h"
127 #endif
128 
129 
130 #pragma package(smart_init)
131 
132 
133 MG_FILE::MG_FILE(char* chemin):MG_GESTIONNAIRE()
134 {
135  std::setlocale(LC_NUMERIC, "C");
136  str_dossier ="";
137  code_de_lecture=lire(chemin);
138 }
139 
140 MG_FILE::MG_FILE():MG_GESTIONNAIRE()
141 {
142 std::setlocale(LC_NUMERIC, "C");
143 }
144 
145 MG_FILE::~MG_FILE()
146 {
147 }
148 
149 int MG_FILE::get_code_de_lecture(void)
150 {
151  return code_de_lecture;
152 }
153 
154 long MG_FILE::cid(std::string str)
155 {
156  const char *p=str.c_str();
157  if (*p=='$') return atol(p+1);
158  return -1;
159 }
160 
161 
162 void MG_FILE::lire_contrainte(int numparam,class PARS_ARGUMENT (&param)[100],MG_ELEMENT_TOPOLOGIQUE *ele)
163  {
164  int nb=param[numparam].argument.size();
165  for (int i=0;i<nb;i++)
166  {
167  double val=atoi(param[numparam].argument[i].c_str());
168  ele->ajouter_contrainte(val);
169  }
170  }
171 
172 
173 void MG_FILE::lire_ccf(double version,int nb,int numparam,class PARSE& parse,class PARS_ARGUMENT (&param)[100],MG_ELEMENT_TOPOLOGIQUE *ele)
174 {
175 if (version<2.0)
176 {
177  for (int i=0;i<nb;i++)
178  {
179  parse.decode(param[numparam].argument[i].c_str(),"(@,@)",param+numparam+1);
180  char nom[3];
181  strcpy(nom,param[numparam+1].argument[0].c_str());
182  if (strcmp(nom,"CM")==0)
183  {
184  unsigned long val;
185  val=atol(param[numparam+2].argument[0].c_str());
186  ele->ajouter_ccf(nom,val);
187  }
188  else
189  {
190  double val;
191  val=atof(param[numparam+2].argument[0].c_str());
192  ele->ajouter_ccf(nom,val);
193  }
194  }
195 }
196 else if (version<2.1)
197 {
198  for (int i=0;i<nb;i++)
199  {
200  char test[500];
201  strcpy(test,param[numparam].argument[i].c_str());
202  parse.decode(param[numparam].argument[i].c_str(),"(@,@,@)",param+numparam+1);
203  char formulation[10];
204  strcpy(formulation,param[numparam+1].argument[0].c_str());
205  char nom[3];
206  strcpy(nom,param[numparam+2].argument[0].c_str());
207  if (formulation[0]=='N')
208  {
209  double val;
210  val=atof(param[numparam+3].argument[0].c_str());
211  ele->ajouter_ccf(nom,val);
212  }
213  if (formulation[0]=='I')
214  {
215  unsigned long val;
216  val=atol(param[numparam+3].argument[0].c_str());
217  ele->ajouter_ccf(nom,val);
218  }
219  if (formulation[0]=='F')
220  {
221  parse.decode(param[numparam].argument[i].c_str(),"(@,@,@,@,(@))",param+numparam+1);
222  char formule[500];
223  strcpy(formule,param[numparam+3].argument[0].c_str());
224  char variable[500];
225  strcpy(variable,param[numparam+5].argument[0].c_str());
226  OT_CHAINE ot;
227  std::vector<std::string> listvariable=ot.split(variable,',');
228  ele->ajouter_ccf(nom,formule,listvariable);
229  }
230  }
231 }
232 else
233 {
234  for (int i=0;i<nb;i++)
235  {
236  char test[500];
237  strcpy(test,param[numparam].argument[i].c_str());
238  parse.decode(param[numparam].argument[i].c_str(),"(@,@,@,@)",param+numparam+1);
239  char formulation[10];
240  strcpy(formulation,param[numparam+1].argument[0].c_str());
241  char nom[3];
242  strcpy(nom,param[numparam+2].argument[0].c_str());
243  char suiv[10];
244  strcpy(suiv,param[numparam+3].argument[0].c_str());
245  if (formulation[0]=='N')
246  {
247  double val;
248  val=atof(param[numparam+4].argument[0].c_str());
249  ele->ajouter_ccf(nom,val,suiv);
250  }
251  if (formulation[0]=='I')
252  {
253  unsigned long val;
254  val=atol(param[numparam+4].argument[0].c_str());
255  ele->ajouter_ccf(nom,val,suiv);
256  }
257  if (formulation[0]=='F')
258  {
259  parse.decode(param[numparam].argument[i].c_str(),"(@,@,@,@,@,(@))",param+numparam+1);
260  char formule[500];
261  strcpy(formule,param[numparam+4].argument[0].c_str());
262  char variable[500];
263  strcpy(variable,param[numparam+6].argument[0].c_str());
264  OT_CHAINE ot;
265  std::vector<std::string> listvariable=ot.split(variable,',');
266  ele->ajouter_ccf(nom,formule,listvariable,suiv);
267  }
268  }
269 }
270 }
271 
272 void MG_FILE::lire_NOEUD(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data,MG_MAILLAGE *mgmai,MG_GEOMETRIE *mggeo)
273 {
274 parse.decode(data.c_str(),"@,@,@,@,@",param+2);
275 long idtopo=cid(param[2].argument[0]);
276 double x=atof(param[3].argument[0].c_str());
277 double y=atof(param[4].argument[0].c_str());
278 double z=atof(param[5].argument[0].c_str());
279 sscanf(param[3].argument[0].c_str(),"%lf",&x);
280 int ori=atoi(param[6].argument[0].c_str());
281 MG_ELEMENT_TOPOLOGIQUE* topo;
282 if (idtopo>-1)
283  {
284  topo=mggeo->get_mg_sommetid(idtopo);
285  if (topo==NULL) topo=mggeo->get_mg_areteid(idtopo);
286  if (topo==NULL) topo=mggeo->get_mg_faceid(idtopo);
287  if (topo==NULL) topo=mggeo->get_mg_volumeid(idtopo);
288  }
289 else topo=NULL;
290 MG_NOEUD* noeud=new MG_NOEUD(id,topo,x,y,z,ori);
291 mgmai->ajouter_mg_noeud(noeud);
292 }
293 
294 void MG_FILE::lire_SEGMENT(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data,MG_MAILLAGE *mgmai,MG_GEOMETRIE *mggeo)
295 {
296 parse.decode(data.c_str(),"@,@,@,@",param+2);
297 long idtopo=cid(param[2].argument[0]);
298 long idn1=cid(param[3].argument[0]);
299 long idn2=cid(param[4].argument[0]);
300 int ori=atoi(param[5].argument[0].c_str());
301 MG_NOEUD* noeud1=mgmai->get_mg_noeudid(idn1);
302 MG_NOEUD* noeud2=mgmai->get_mg_noeudid(idn2);
303 MG_ELEMENT_TOPOLOGIQUE* topo;
304 if (idtopo>-1)
305  {
306  topo=mggeo->get_mg_areteid(idtopo);
307  if (topo==NULL) topo=mggeo->get_mg_faceid(idtopo);
308  if (topo==NULL) topo=mggeo->get_mg_volumeid(idtopo);
309  if (topo==NULL) topo=mggeo->get_mg_poutreid(idtopo);
310  }
311 else topo=NULL;
312 MG_SEGMENT* seg=new MG_SEGMENT(id,topo,noeud1,noeud2,ori);
313 mgmai->ajouter_mg_segment(seg);
314 }
315 
316 
317 void MG_FILE::lire_TRIANGLE(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data,MG_MAILLAGE *mgmai,MG_GEOMETRIE *mggeo)
318 {
319 parse.decode(data.c_str(),"@,@,@,@,@",param+2);
320 long idtopo=cid(param[2].argument[0]);
321 long idn1=cid(param[3].argument[0]);
322 long idn2=cid(param[4].argument[0]);
323 long idn3=cid(param[5].argument[0]);
324 int ori=atoi(param[6].argument[0].c_str());
325 MG_NOEUD* noeud1=mgmai->get_mg_noeudid(idn1);
326 MG_NOEUD* noeud2=mgmai->get_mg_noeudid(idn2);
327 MG_NOEUD* noeud3=mgmai->get_mg_noeudid(idn3);
328 MG_ELEMENT_TOPOLOGIQUE* topo=NULL;
329 if (idtopo>-1)
330  {
331  topo=mggeo->get_mg_faceid(idtopo);
332  if (topo==NULL) topo=mggeo->get_mg_volumeid(idtopo);
333  }
334 mgmai->ajouter_mg_triangle(topo,noeud1,noeud2,noeud3,ori,id);
335 }
336 
337 void MG_FILE::lire_QUADRANGLE(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data,MG_MAILLAGE *mgmai,MG_GEOMETRIE *mggeo)
338 {
339 parse.decode(data.c_str(),"@,@,@,@,@,@",param+2);
340 long idtopo=cid(param[2].argument[0]);
341 long idn1=cid(param[3].argument[0]);
342 long idn2=cid(param[4].argument[0]);
343 long idn3=cid(param[5].argument[0]);
344 long idn4=cid(param[6].argument[0]);
345 int ori=atoi(param[7].argument[0].c_str());
346 MG_NOEUD* noeud1=mgmai->get_mg_noeudid(idn1);
347 MG_NOEUD* noeud2=mgmai->get_mg_noeudid(idn2);
348 MG_NOEUD* noeud3=mgmai->get_mg_noeudid(idn3);
349 MG_NOEUD* noeud4=mgmai->get_mg_noeudid(idn4);
350 MG_ELEMENT_TOPOLOGIQUE* topo;
351 if (idtopo>-1)
352  {
353  topo=mggeo->get_mg_faceid(idtopo);
354  if (topo==NULL) topo=mggeo->get_mg_volumeid(idtopo);
355  }
356 else topo=NULL;
357 mgmai->ajouter_mg_quadrangle(topo,noeud1,noeud2,noeud3,noeud4,ori,id);
358 }
359 
360 
361 void MG_FILE::lire_TETRA(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data,MG_MAILLAGE *mgmai,MG_GEOMETRIE *mggeo)
362 {
363 parse.decode(data.c_str(),"@,@,@,@,@,@",param+2);
364 long idtopo=cid(param[2].argument[0]);
365 long idn1=cid(param[3].argument[0]);
366 long idn2=cid(param[4].argument[0]);
367 long idn3=cid(param[5].argument[0]);
368 long idn4=cid(param[6].argument[0]);
369 int ori=atoi(param[7].argument[0].c_str());
370 MG_NOEUD* noeud1=mgmai->get_mg_noeudid(idn1);
371 MG_NOEUD* noeud2=mgmai->get_mg_noeudid(idn2);
372 MG_NOEUD* noeud3=mgmai->get_mg_noeudid(idn3);
373 MG_NOEUD* noeud4=mgmai->get_mg_noeudid(idn4);
374 MG_ELEMENT_TOPOLOGIQUE* topo;
375 if (idtopo>-1) topo=mggeo->get_mg_volumeid(idtopo);
376 else topo=NULL;
377 if (noeud1&&noeud2&&noeud3&&noeud4) mgmai->ajouter_mg_tetra(topo,noeud1,noeud2,noeud3,noeud4,ori,id);
378 }
379 
380 void MG_FILE::lire_HEXA(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data,MG_MAILLAGE *mgmai,MG_GEOMETRIE *mggeo)
381 {
382 parse.decode(data.c_str(),"@,@,@,@,@,@,@,@,@,@",param+2);
383 long idtopo=cid(param[2].argument[0]);
384 long idn1=cid(param[3].argument[0]);
385 long idn2=cid(param[4].argument[0]);
386 long idn3=cid(param[5].argument[0]);
387 long idn4=cid(param[6].argument[0]);
388 long idn5=cid(param[7].argument[0]);
389 long idn6=cid(param[8].argument[0]);
390 long idn7=cid(param[9].argument[0]);
391 long idn8=cid(param[10].argument[0]);
392 int ori=atoi(param[11].argument[0].c_str());
393 MG_NOEUD* noeud1=mgmai->get_mg_noeudid(idn1);
394 MG_NOEUD* noeud2=mgmai->get_mg_noeudid(idn2);
395 MG_NOEUD* noeud3=mgmai->get_mg_noeudid(idn3);
396 MG_NOEUD* noeud4=mgmai->get_mg_noeudid(idn4);
397 MG_NOEUD* noeud5=mgmai->get_mg_noeudid(idn5);
398 MG_NOEUD* noeud6=mgmai->get_mg_noeudid(idn6);
399 MG_NOEUD* noeud7=mgmai->get_mg_noeudid(idn7);
400 MG_NOEUD* noeud8=mgmai->get_mg_noeudid(idn8);
401 MG_ELEMENT_TOPOLOGIQUE* topo;
402 if (idtopo>-1) topo=mggeo->get_mg_volumeid(idtopo);
403 else topo=NULL;
404 mgmai->ajouter_mg_hexa(topo,noeud1,noeud2,noeud3,noeud4,noeud5,noeud6,noeud7,noeud8,ori,id);
405 }
406 
407 
408 void MG_FILE::lire_PENTA(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data,MG_MAILLAGE *mgmai,MG_GEOMETRIE *mggeo)
409 {
410 parse.decode(data.c_str(),"@,@,@,@,@,@,@,@",param+2);
411 long idtopo=cid(param[2].argument[0]);
412 long idn1=cid(param[3].argument[0]);
413 long idn2=cid(param[4].argument[0]);
414 long idn3=cid(param[5].argument[0]);
415 long idn4=cid(param[6].argument[0]);
416 long idn5=cid(param[7].argument[0]);
417 long idn6=cid(param[8].argument[0]);
418 int ori=atoi(param[9].argument[0].c_str());
419 MG_NOEUD* noeud1=mgmai->get_mg_noeudid(idn1);
420 MG_NOEUD* noeud2=mgmai->get_mg_noeudid(idn2);
421 MG_NOEUD* noeud3=mgmai->get_mg_noeudid(idn3);
422 MG_NOEUD* noeud4=mgmai->get_mg_noeudid(idn4);
423 MG_NOEUD* noeud5=mgmai->get_mg_noeudid(idn5);
424 MG_NOEUD* noeud6=mgmai->get_mg_noeudid(idn6);
425 MG_ELEMENT_TOPOLOGIQUE* topo;
426 if (idtopo>-1) topo=mggeo->get_mg_volumeid(idtopo);
427 else topo=NULL;
428 mgmai->ajouter_mg_penta(topo,noeud1,noeud2,noeud3,noeud4,noeud5,noeud6,ori,id);
429 }
430 
431 void MG_FILE::lire_PYRAMIDE(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data,MG_MAILLAGE *mgmai,MG_GEOMETRIE *mggeo)
432 {
433 parse.decode(data.c_str(),"@,@,@,@,@,@,@",param+2);
434 long idtopo=cid(param[2].argument[0]);
435 long idn1=cid(param[3].argument[0]);
436 long idn2=cid(param[4].argument[0]);
437 long idn3=cid(param[5].argument[0]);
438 long idn4=cid(param[6].argument[0]);
439 long idn5=cid(param[7].argument[0]);
440 int ori=atoi(param[8].argument[0].c_str());
441 MG_NOEUD* noeud1=mgmai->get_mg_noeudid(idn1);
442 MG_NOEUD* noeud2=mgmai->get_mg_noeudid(idn2);
443 MG_NOEUD* noeud3=mgmai->get_mg_noeudid(idn3);
444 MG_NOEUD* noeud4=mgmai->get_mg_noeudid(idn4);
445 MG_NOEUD* noeud5=mgmai->get_mg_noeudid(idn5);
446 MG_ELEMENT_TOPOLOGIQUE* topo;
447 if (idtopo>-1) topo=mggeo->get_mg_volumeid(idtopo);
448 else topo=NULL;
449 mgmai->ajouter_mg_pyramide(topo,noeud1,noeud2,noeud3,noeud4,noeud5,ori,id);
450 }
451 
452 
453 void MG_FILE::lire_MG_SOUS_GEOMETRIE(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data)
454 {
455  // PARAM # 2 3 4 5 6 7
456  parse.decode(data.c_str(),"@,@,@,@,@,@,",param+2);
457  long id_mg_geometrie = cid(param[2].argument[0]);
458  long id_parent = cid(param[3].argument[0]);
459  std::string type_geo = param[4].argument[0];
460  std::string nom_fichier = param[5].argument[0];
461  double precision = atof(param[6].argument[0].c_str());
462  double valeur_unitee = atof(param[7].argument[0].c_str());
463  MG_GEOMETRIE* mg_construction = get_mg_constructionid(id_mg_geometrie);
464  MG_SOUS_GEOMETRIE* mg_sous_geometrie;
465  if(type_geo=="MGCG_ASS")
466  {
467  MG_CG_ASSEMBLAGE* mgcg_assemblage;
468  LISTE_MGCG_MODELE::iterator it_modele;
469  bool trouve=false;
470  it_modele=lst_mgcg_modele.begin();
471  while(trouve==false && it_modele!=lst_mgcg_modele.end())
472  {
473  MG_CG_MODELE* mgcg_modele = it_modele->second;
474  if(mgcg_modele->get_mgcg_assemblageid(id_parent)!=NULL)
475  {
476  mgcg_assemblage = mgcg_modele->get_mgcg_assemblageid(id_parent);
477  trouve=true;
478  }
479  }
480  mg_sous_geometrie=new MG_SOUS_GEOMETRIE(mg_construction,id_parent,(char*)type_geo.c_str(),id,(char*)nom_fichier.c_str(),valeur_unitee,precision);
481  mgcg_assemblage->change_mg_sous_geometrie(mg_sous_geometrie);
482  mgcg_assemblage->actualiser_mg_sous_geometrie();
483  ajouter_mg_geometrie(mg_sous_geometrie);
484  }
485 }
486 
487 
488 
489 void MG_FILE::lire_MG_VOLUME(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data,MG_GEOMETRIE *mggeo,std::vector<unsigned long> &volumemince)
490 {
491  if (version_fichier<2)
492  {
493  parse.decode(data.c_str(),"@,@,@,@,(&)",param+2);
494  MG_VOLUME* mgvol=new MG_VOLUME(param[2].argument[0],id);
495  mggeo->ajouter_mg_volume(mgvol);
496  int nummat=atoi((char*)param[4].argument[0].c_str());
497  mgvol->change_num_materiau(nummat);
498  int nb=atoi(param[5].argument[0].c_str());
499  if (nb!=0) lire_ccf(version_fichier,nb,6,parse,param,mgvol);
500  }
501  else if (version_fichier<2.3)
502  {
503  parse.decode(data.c_str(),"@,@,@,(&)",param+2);
504  MG_VOLUME* mgvol=new MG_VOLUME(param[2].argument[0],id);
505  mggeo->ajouter_mg_volume(mgvol);
506  int nb=atoi(param[4].argument[0].c_str());
507  if (nb!=0) lire_ccf(version_fichier,nb,5,parse,param,mgvol);
508  }
509  else
510  {
511  parse.decode(data.c_str(),"@,@,@,@",param+2);
512  MG_VOLUME* mgvol;
513 #ifdef ALL_OCC
514  if(strcmp(mggeo->get_type_geometrie(),"OCCV2017")==0)
515  {
516  TopoDS_Solid topods_solid;
517  OCC_FONCTION_V2017* occ_fonction_v2017 = (OCC_FONCTION_V2017*)&mggeo->get_occ_fonction();
518  topods_solid=occ_fonction_v2017->get_TopoDS_Solid_id(atol(param[2].argument[0].c_str()));
519  mgvol = new OCC_VOLUME(param[2].argument[0],id,topods_solid,&mggeo->get_occ_fonction());
520  occ_fonction_v2017->ajouter_OCC_VOLUME((OCC_VOLUME*)mgvol);
521  }
522  else mgvol=new MG_VOLUME(param[2].argument[0],id);
523 #else
524  mgvol=new MG_VOLUME(param[2].argument[0],id);
525 #endif
526  mggeo->ajouter_mg_volume(mgvol);
527  int mince=atoi(param[4].argument[0].c_str());
528  if (mince==0)
529  {
530  std::string data2=param[5].argument[0];
531  parse.decode(data2.c_str(),"@,(&)",param+5);
532  int nb=atoi(param[5].argument[0].c_str());
533  if (nb!=0) lire_ccf(version_fichier,nb,6,parse,param,mgvol);
534  }
535  else
536  {
537  std::string data2=param[5].argument[0];
538  parse.decode(data2.c_str(),"(&),@,(&)",param+5);
539  int nb_face=param[5].argument.size();
540  for (int i=0;i<nb_face;i=i+2)
541  {
542  unsigned long idn1=cid(param[5].argument[i]);
543  unsigned long idn2=cid(param[5].argument[i+1]);
544  volumemince.push_back(id);
545  volumemince.push_back(idn1);
546  volumemince.push_back(idn2);
547  }
548  int nb=atoi(param[6].argument[0].c_str());
549  if (nb!=0) lire_ccf(version_fichier,nb,7,parse,param,mgvol);
550  }
551  }
552 }
553 
554 void MG_FILE::lire_MG_COQUILLE(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data,MG_GEOMETRIE *mggeo)
555 {
556  bool import_occ_2017=false;
557 #ifdef ALL_OCC
558  if(strcmp(mggeo->get_type_geometrie(),"OCCV2017")==0)
559  {
560  import_occ_2017=true;
561  parse.decode(data.c_str(),"@,@,@",param+2);
562  long ident=cid(param[2].argument[0]);
563  long idori = stol(param[3].argument[0]);
564  TopoDS_Shell topods_shell;
565  OCC_COQUILLE* occ_coquille;
566  OCC_FONCTION_V2017* occ_fonction_v2017 = (OCC_FONCTION_V2017*)&mggeo->get_occ_fonction();
567  topods_shell=occ_fonction_v2017->get_TopoDS_Shell_id(idori);
568  if(idori!=-1)
569  {
570  MG_VOLUME* mgvol=mggeo->get_mg_volumeid(ident);
571  MG_COQUE* mgcoq=mggeo->get_mg_coqueid(ident);
572  if (mgvol!=NULL)
573  {
574  OCC_COQUILLE* occ_coquille = new OCC_COQUILLE(param[3].argument[0],id,mgvol,topods_shell,&mggeo->get_occ_fonction());
575  mggeo->ajouter_mg_coquille(occ_coquille,mgvol);
576  occ_fonction_v2017->ajouter_OCC_COQUILLE(occ_coquille);
577  }
578  if (mgcoq!=NULL)
579  {
580  OCC_COQUILLE* occ_coquille = new OCC_COQUILLE(param[3].argument[0],id,mgcoq,topods_shell,&mggeo->get_occ_fonction());
581  mggeo->ajouter_mg_coquille(occ_coquille,mgcoq);
582  occ_fonction_v2017->ajouter_OCC_COQUILLE(occ_coquille);
583  }
584  }
585  else
586  {
587  OCC_COQUILLE* occ_coquille = new OCC_COQUILLE(param[3].argument[0],id,topods_shell,&mggeo->get_occ_fonction());
588  mggeo->ajouter_mg_coquille(occ_coquille);
589  occ_fonction_v2017->ajouter_OCC_COQUILLE(occ_coquille);
590  }
591  }
592 #endif
593  if(!import_occ_2017)
594  {
595  parse.decode(data.c_str(),"@,@",param+2);
596  long ident=cid(param[2].argument[0]);
597  MG_VOLUME* mgvol=mggeo->get_mg_volumeid(ident);
598  MG_COQUE* mgcoq=mggeo->get_mg_coqueid(ident);
599  if(mgvol!=NULL)
600  {
601  MG_COQUILLE* mgcoq=new MG_COQUILLE(id,mgvol);
602  mggeo->ajouter_mg_coquille(mgcoq,mgvol);
603  }
604  if(mgcoq!=NULL)
605  {
606  MG_COQUILLE* mgcoquille=new MG_COQUILLE(id,mgcoq);
607  mggeo->ajouter_mg_coquille(mgcoquille,mgcoq);
608  }
609  }
610 }
611 
612 void MG_FILE::lire_MG_FACE(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data,MG_GEOMETRIE *mggeo)
613 {
614  if (version_fichier<2.2) parse.decode(data.c_str(),"@,@,(@),@,@,(&)",param+2);
615  else parse.decode(data.c_str(),"@,@,(@),@,@,@,(&)",param+2);
616  long idsurf=cid(param[3].argument[0]);
617  int sens=atoi(param[5].argument[0].c_str());
618  MG_SURFACE* mgsurf=mggeo->get_mg_surfaceid(idsurf);
619  MG_FACE* mgface;
620 #ifdef ALL_OCC
621  if(strcmp(mggeo->get_type_geometrie(),"OCCV2017")==0)
622  {
623  TopoDS_Face topods_face;
624  OCC_FONCTION_V2017* occ_fonction_v2017 = (OCC_FONCTION_V2017*)&mggeo->get_occ_fonction();
625  topods_face=occ_fonction_v2017->get_TopoDS_Face_id(atol(param[2].argument[0].c_str()));
626  mgface = new OCC_FACE(param[2].argument[0],id,mgsurf,sens,topods_face,&mggeo->get_occ_fonction());
627  occ_fonction_v2017->ajouter_OCC_FACE((OCC_FACE*)mgface);
628  }
629  else mgface=new MG_FACE(param[2].argument[0],id,mgsurf,sens);
630 #else
631  mgface=new MG_FACE(param[2].argument[0],id,mgsurf,sens);
632 #endif
633  mggeo->ajouter_mg_face(mgface);
634  int argccf=7;
635  if (version_fichier>2.1)
636  {
637  argccf=8;
638  int nbpole=atoi(param[6].argument[0].c_str());
639  mgface->change_nb_pole(nbpole);
640  }
641  int nb=atoi(param[argccf-1].argument[0].c_str());
642  if (nb!=0) lire_ccf(version_fichier,nb,argccf,parse,param,mgface);
643 }
644 
645 void MG_FILE::lire_MG_BOUCLE(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data,MG_GEOMETRIE *mggeo)
646 {
647  bool import_occ_2017=false;
648  MG_BOUCLE* mgbou;
649 #ifdef ALL_OCC
650  if(strcmp(mggeo->get_type_geometrie(),"OCCV2017")==0)
651  {
652  import_occ_2017=true;
653  parse.decode(data.c_str(),"@,@,(@)",param+2);
654  long ident=cid(param[2].argument[0]);
655  long idori=stol(param[3].argument[0]);
656  TopoDS_Wire topods_wire;
657  OCC_FONCTION_V2017* occ_fonction_v2017 = (OCC_FONCTION_V2017*)&mggeo->get_occ_fonction();
658  topods_wire=occ_fonction_v2017->get_TopoDS_Wire_id(idori);
659  if(ident!=-1)
660  {
661  MG_FACE* mgface=mggeo->get_mg_faceid(ident);
662  MG_POUTRE* mgpoutre=mggeo->get_mg_poutreid(ident);
663  if (mgface!=NULL)
664  {
665  mgbou=new OCC_BOUCLE(param[3].argument[0],id,mgface,topods_wire,&mggeo->get_occ_fonction());
666  mggeo->ajouter_mg_boucle(mgbou,mgface);
667  occ_fonction_v2017->ajouter_OCC_BOUCLE((OCC_BOUCLE*)mgbou);
668  }
669  if (mgpoutre!=NULL)
670  {
671  mgbou=new OCC_BOUCLE(param[3].argument[0],id,mgpoutre,topods_wire,&mggeo->get_occ_fonction());
672  mggeo->ajouter_mg_boucle(mgbou,mgpoutre);
673  occ_fonction_v2017->ajouter_OCC_BOUCLE((OCC_BOUCLE*)mgbou);
674  }
675  }
676  else
677  {
678  mgbou=new OCC_BOUCLE(param[3].argument[0],id,topods_wire,&mggeo->get_occ_fonction());
679  mggeo->ajouter_mg_boucle(mgbou);
680  occ_fonction_v2017->ajouter_OCC_BOUCLE((OCC_BOUCLE*)mgbou);
681  }
682  }
683 #endif
684  if(!import_occ_2017)
685  {
686  parse.decode(data.c_str(),"@,(@)",param+2);
687  long ident=cid(param[2].argument[0]);
688  MG_FACE* mgface=mggeo->get_mg_faceid(ident);
689  MG_POUTRE* mgpoutre=mggeo->get_mg_poutreid(ident);
690  if (mgface!=NULL)
691  {
692  mgbou=new MG_BOUCLE(id,mgface);
693  mggeo->ajouter_mg_boucle(mgbou,mgface);
694  }
695  if (mgpoutre!=NULL)
696  {
697  mgbou=new MG_BOUCLE(id,mgpoutre);
698  mggeo->ajouter_mg_boucle(mgbou,mgpoutre);
699  }
700  }
701 }
702 
703 void MG_FILE::lire_MG_ARETE(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data,MG_GEOMETRIE *mggeo)
704 {
705  parse.decode(data.c_str(),"@,@,@,@,@,@,(&)",param+2);
706  long idcur=cid(param[3].argument[0]);
707  int sens=atol(param[6].argument[0].c_str());
708  long idori = stoi(param[2].argument[0]);
709  MG_COURBE* mgcur=mggeo->get_mg_courbeid(idcur);
710  MG_ARETE* mgarete;
711 #ifdef ALL_OCC
712  if(strcmp(mggeo->get_type_geometrie(),"OCCV2017")==0)
713  {
714  TopoDS_Edge topods_edge;
715  OCC_FONCTION_V2017* occ_fonction_v2017 = (OCC_FONCTION_V2017*)&mggeo->get_occ_fonction();
716  topods_edge=occ_fonction_v2017->get_TopoDS_Edge_id(idori);
717  mgarete= new OCC_ARETE(param[2].argument[0],id,mgcur,sens,topods_edge,&mggeo->get_occ_fonction());
718  occ_fonction_v2017->ajouter_OCC_ARETE((OCC_ARETE*)mgarete);
719  }
720  else mgarete=new MG_ARETE(param[2].argument[0],id,mgcur,sens);
721 #else
722  mgarete=new MG_ARETE(param[2].argument[0],id,mgcur,sens);
723 #endif
724  mggeo->ajouter_mg_arete(mgarete);
725  int nb=atoi(param[7].argument[0].c_str());
726  if (nb!=0) lire_ccf(version_fichier,nb,8,parse,param,mgarete);
727 }
728 
729 void MG_FILE::lire_MG_SOMMET(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data,MG_GEOMETRIE *mggeo)
730 {
731  if (version_fichier<2.2) parse.decode(data.c_str(),"@,@,@,(&)",param+2);
732  else parse.decode(data.c_str(),"@,@,@,@,(&)",param+2);
733  long idpoint=cid(param[3].argument[0]);
734  long idori = stol(param[2].argument[0]);
735  MG_POINT* mgpt=mggeo->get_mg_pointid(idpoint);
736  MG_SOMMET* mgsom;
737 #ifdef ALL_OCC
738  if(strcmp(mggeo->get_type_geometrie(),"OCCV2017")==0)
739  {
740  TopoDS_Vertex topods_vertex;
741  OCC_FONCTION_V2017* occ_fonction_v2017 = (OCC_FONCTION_V2017*)&mggeo->get_occ_fonction();
742  topods_vertex=occ_fonction_v2017->get_TopoDS_Vertex_id(idori);
743  mgsom = new OCC_SOMMET(param[2].argument[0],id,mgpt,topods_vertex,&mggeo->get_occ_fonction());
744  mggeo->ajouter_mg_sommet(mgsom);
745  occ_fonction_v2017->ajouter_OCC_SOMMET((OCC_SOMMET*)mgsom);
746  }
747  else mgsom=new MG_SOMMET(param[2].argument[0],id,mgpt);
748 #else
749  mgsom=new MG_SOMMET(param[2].argument[0],id,mgpt);
750 #endif
751  mggeo->ajouter_mg_sommet(mgsom);
752  int argccf=5;
753  if (version_fichier>2.1)
754  {
755  argccf=6;
756  int ipole=atoi(param[4].argument[0].c_str());
757  if (ipole==1) mgsom->change_pole(true);
758  }
759  int nb=atoi(param[argccf-1].argument[0].c_str());
760  if (nb!=0) lire_ccf(version_fichier,nb,argccf,parse,param,mgsom);
761 }
762 
763 
764 
765 
766 
767 void MG_FILE::lire_MG_CG_MODELE(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data)
768 {
769 #ifdef ALL_OCC
770  parse.decode(data.c_str(),"@,@,@,@,@",param+2);
771  std::string nom=param[2].argument[0];
772  long id_mg_geometrie = cid((char*)param[3].argument[0].c_str());
773  int fusionner_entite_similaire = atoi((char*)param[4].argument[0].c_str());
774  int importer_triangulation = atoi((char*)param[5].argument[0].c_str());
775  double epsilon_triangulation = atof((char*)param[6].argument[0].c_str());
776  MG_GEOMETRIE* mg_construction = get_mg_constructionid(id_mg_geometrie);
777  MG_CG_MODELE* mgcg_modele=new MG_CG_MODELE(this,nom,mg_construction,id);
778  mgcg_modele->change_fusionner_entite_similaire(fusionner_entite_similaire);
779  mgcg_modele->change_importer_triangulation(importer_triangulation);
780  mgcg_modele->change_epsilon_triangulation(epsilon_triangulation);
781  ajouter_mgcg_modele(mgcg_modele);
782 #endif
783 }
784 
785 void MG_FILE::lire_MG_CG_ASSEMBLAGE(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data)
786 {
787 #ifdef ALL_OCC
788  parse.decode(data.c_str(),"@,@,@,@,(&)",param+2);
789  long id_modele = cid((char*)param[2].argument[0].c_str());
790  std::string nom=param[3].argument[0];
791  long id_mg_sous_geometrie = cid((char*)param[4].argument[0].c_str());
792  long nb_mgcg_forme = atol((char*)param[5].argument[0].c_str());
793  MG_CG_MODELE* mgcg_modele = get_mgcg_modeleid(id_modele);
794  MG_SOUS_GEOMETRIE* mg_sous_geometrie;
795  MG_GEOMETRIE* mg_geometrie = get_mg_geometrieid(id_mg_sous_geometrie);
796  if(mg_geometrie!=NULL) mg_sous_geometrie = (MG_SOUS_GEOMETRIE*)mg_geometrie;
797  else mg_sous_geometrie=NULL;
798  MG_CG_ASSEMBLAGE *mgcg_assemblage=new MG_CG_ASSEMBLAGE(mgcg_modele,id,nom.c_str(),mg_sous_geometrie);
799  for(long i=0;i<nb_mgcg_forme;i++)
800  {
801  unsigned long id2 = cid(param[6].argument[i]);
802  mgcg_assemblage->ajouter_mgcg_forme(mgcg_modele->get_mgcg_formeid(id2),false);
803  }
804  mgcg_modele->ajouter_mgcg_assemblage(mgcg_assemblage);
805 #endif
806 }
807 
808 void MG_FILE::lire_MG_CG_GROUPE_FORME(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data)
809 {
810 #ifdef ALL_OCC
811  // PARAM # 2 3 4 5
812  parse.decode(data.c_str(),"@,@,@,(&)",param+2);
813  long id_mgcg_modele = cid(param[2].argument[0]);
814  std::string nom=param[3].argument[0];
815  long nb_forme = atol(param[4].argument[0].c_str());
816  MG_CG_MODELE *mgcg_modele = get_mgcg_modeleid(id_mgcg_modele);
817  MG_CG_GROUPE_FORME* mgcg_groupe_forme = MG_CG::creer_MG_CG_GROUPE_FORME(mgcg_modele,id,nom);
818  for(long i=0;i<nb_forme;i++)
819  {
820  long id_forme = cid(param[5].argument[i]);
821  MG_CG_FORME* mgcg_forme = mgcg_modele->get_mgcg_formeid(id_forme);
822  mgcg_groupe_forme->ajouter_mgcg_forme(mgcg_forme);
823  }
824 #endif
825 }
826 
827 void MG_FILE::lire_MG_CG_FORME_ARETE(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data)
828 {
829 #ifdef ALL_OCC
830  parse.decode(data.c_str(),"@,@,@,@,@,@,(&)",param+2);
831  long id_modele = cid((char*)param[2].argument[0].c_str());
832  MG_CG_MODELE* mgcg_modele = get_mgcg_modeleid(id_modele);
833  int provenance_forme = atoi((char*)param[3].argument[0].c_str());
834  int etat_forme = atoi((char*)param[4].argument[0].c_str());
835  MG_ARETE* mg_arete;
836  if(etat_forme==MG_CG_FORME::ETAT_FORME::CONSTRUITE || etat_forme==MG_CG_FORME::ETAT_FORME::ATTENTE_RECONSTRUCTION) mg_arete = mgcg_modele->get_mg_geometrie()->get_mg_areteid(cid((char*)param[5].argument[0].c_str()));
837  MG_CG_OPERATEUR* mgcg_operateur_parent = mgcg_modele->get_mgcg_operateurid(cid((char*)param[6].argument[0].c_str()));
838  MG_CG_FORME* forme = MG_CG::creer_MG_CG_FORME_ARETE(mgcg_modele,provenance_forme,etat_forme,id,mg_arete);
839  forme->change_mgcg_operateur_parent(mgcg_operateur_parent);
840  mgcg_operateur_parent->ajouter_mgcg_forme_sortie(forme);
841 #endif
842 }
843 
844 void MG_FILE::lire_MG_CG_FORME_ARETE_DROITE(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data)
845 {
846 #ifdef ALL_OCC
847  parse.decode(data.c_str(),"@,@,@,@,@,@,@,@,@,@,(&)",param+2);
848  long id_modele = cid((char*)param[2].argument[0].c_str());
849  MG_CG_MODELE* mgcg_modele = get_mgcg_modeleid(id_modele);
850  int etat_forme = atoi((char*)param[3].argument[0].c_str());
851  MG_ARETE* mg_arete;
852  if(etat_forme==MG_CG_FORME::ETAT_FORME::CONSTRUITE || etat_forme==MG_CG_FORME::ETAT_FORME::ATTENTE_RECONSTRUCTION) mg_arete = mgcg_modele->get_mg_geometrie()->get_mg_areteid(cid((char*)param[4].argument[0].c_str()));
853  double x1 = atof((char*)param[5].argument[0].c_str());
854  double y1 = atof((char*)param[6].argument[0].c_str());
855  double z1 = atof((char*)param[7].argument[0].c_str());
856  double x2 = atof((char*)param[8].argument[0].c_str());
857  double y2 = atof((char*)param[9].argument[0].c_str());
858  double z2 = atof((char*)param[10].argument[0].c_str());
859  MG_CG_FORME* forme = MG_CG::creer_MG_CG_FORME_ARETE_DROITE(mgcg_modele,etat_forme,id,mg_arete,x1,y1,z1,x2,y2,z2);
860 #endif
861 }
862 
863 void MG_FILE::lire_MG_CG_FORME_VOLUME(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data)
864 {
865 #ifdef ALL_OCC
866  parse.decode(data.c_str(),"@,@,@,@,@,@,(&)",param+2);
867  long id_modele = cid((char*)param[2].argument[0].c_str());
868  MG_CG_MODELE* mgcg_modele = get_mgcg_modeleid(id_modele);
869  int provenance_forme = atoi((char*)param[3].argument[0].c_str());
870  int etat_forme = atoi((char*)param[4].argument[0].c_str());
871  MG_VOLUME* mg_volume;
872  if(etat_forme==MG_CG_FORME::ETAT_FORME::CONSTRUITE || etat_forme==MG_CG_FORME::ETAT_FORME::ATTENTE_RECONSTRUCTION) mg_volume = mgcg_modele->get_mg_geometrie()->get_mg_volumeid(cid((char*)param[5].argument[0].c_str()));
873  MG_CG_OPERATEUR* mgcg_operateur_parent = mgcg_modele->get_mgcg_operateurid(cid((char*)param[6].argument[0].c_str()));
874  MG_CG_FORME* forme = MG_CG::creer_MG_CG_FORME_VOLUME(mgcg_modele,provenance_forme,etat_forme,id,mg_volume);
875  forme->change_mgcg_operateur_parent(mgcg_operateur_parent);
876  if (mgcg_operateur_parent!=NULL) mgcg_operateur_parent->ajouter_mgcg_forme_sortie(forme);
877 #endif
878 }
879 
880 void MG_FILE::lire_MG_CG_FORME_VOLUME_BOITE(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data)
881 {
882 #ifdef ALL_OCC
883  parse.decode(data.c_str(),"@,@,@,@,@,@,@,@,@,@,(&)",param+2);
884  long id_modele = cid((char*)param[2].argument[0].c_str());
885  MG_CG_MODELE* mgcg_modele = get_mgcg_modeleid(id_modele);
886  int etat_forme = atoi((char*)param[3].argument[0].c_str());
887  MG_VOLUME* mg_volume;
888  if(etat_forme==MG_CG_FORME::ETAT_FORME::CONSTRUITE || etat_forme==MG_CG_FORME::ETAT_FORME::ATTENTE_RECONSTRUCTION) mg_volume = mgcg_modele->get_mg_geometrie()->get_mg_volumeid(cid((char*)param[4].argument[0].c_str()));
889  double x1 = atof((char*)param[5].argument[0].c_str());
890  double y1 = atof((char*)param[6].argument[0].c_str());
891  double z1 = atof((char*)param[7].argument[0].c_str());
892  double x2 = atof((char*)param[8].argument[0].c_str());
893  double y2 = atof((char*)param[9].argument[0].c_str());
894  double z2 = atof((char*)param[10].argument[0].c_str());
895  MG_CG_FORME* forme = MG_CG::creer_MG_CG_FORME_VOLUME_BOITE(mgcg_modele,etat_forme,id,mg_volume,x1,y1,z1,x2,y2,z2);
896 #endif
897 }
898 
899 void MG_FILE::lire_MG_CG_FORME_VOLUME_SPHERE(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data)
900 {
901 #ifdef ALL_OCC
902  // PARAM # 2 3 4 5 6 7 8
903  parse.decode(data.c_str(),"@,@,@,@,@,@,@,@,@,@,(&)",param+2);
904  long id_modele = cid((char*)param[2].argument[0].c_str());
905  MG_CG_MODELE* mgcg_modele = get_mgcg_modeleid(id_modele);
906  int etat_forme = atoi((char*)param[3].argument[0].c_str());
907  MG_VOLUME* mg_volume;
908  if(etat_forme==MG_CG_FORME::ETAT_FORME::CONSTRUITE || etat_forme==MG_CG_FORME::ETAT_FORME::ATTENTE_RECONSTRUCTION) mg_volume = mgcg_modele->get_mg_geometrie()->get_mg_volumeid(cid((char*)param[4].argument[0].c_str()));
909  double centre_x = atof((char*)param[5].argument[0].c_str());
910  double centre_y = atof((char*)param[6].argument[0].c_str());
911  double centre_z = atof((char*)param[7].argument[0].c_str());
912  double rayon = atof((char*)param[8].argument[0].c_str());
913  MG_CG_FORME* forme = MG_CG::creer_MG_CG_FORME_VOLUME_SPHERE(mgcg_modele,etat_forme,id,mg_volume,centre_x,centre_y,centre_z,rayon);
914 #endif
915 }
916 
917 void MG_FILE::lire_MG_CG_FORME_VOLUME_ELLIPSOIDE(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data)
918 {
919 #ifdef ALL_OCC
920  // PARAM # 2 3 4 5 6 7 8 9 101112
921  parse.decode(data.c_str(),"@,@,@,@,@,@,@,@,@,@,@,(&)",param+2);
922  long id_modele = cid((char*)param[2].argument[0].c_str());
923  MG_CG_MODELE* mgcg_modele = get_mgcg_modeleid(id_modele);
924  int etat_forme = atoi((char*)param[3].argument[0].c_str());
925  MG_VOLUME* mg_volume;
926  if(etat_forme==MG_CG_FORME::ETAT_FORME::CONSTRUITE || etat_forme==MG_CG_FORME::ETAT_FORME::ATTENTE_RECONSTRUCTION) mg_volume = mgcg_modele->get_mg_geometrie()->get_mg_volumeid(cid((char*)param[4].argument[0].c_str()));
927  double centre_x = atof((char*)param[5].argument[0].c_str());
928  double centre_y = atof((char*)param[6].argument[0].c_str());
929  double centre_z = atof((char*)param[7].argument[0].c_str());
930  double direction_x = atof((char*)param[8].argument[0].c_str());
931  double direction_y = atof((char*)param[9].argument[0].c_str());
932  double direction_z = atof((char*)param[10].argument[0].c_str());
933  double rayon_majeur = atof((char*)param[11].argument[0].c_str());
934  double rayon_mineur = atof((char*)param[12].argument[0].c_str());
935  MG_CG_FORME* forme = MG_CG::creer_MG_CG_FORME_VOLUME_ELLIPSOIDE(mgcg_modele,etat_forme,id,mg_volume,centre_x,centre_y,centre_z,direction_x,direction_y,direction_z,rayon_majeur,rayon_mineur);
936 #endif
937 }
938 
939 void MG_FILE::lire_MG_CG_FORME_VOLUME_CYLINDRE(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data)
940 {
941 #ifdef ALL_OCC
942  // PARAM # 2 3 4 5 6 7 8 9 101112
943  parse.decode(data.c_str(),"@,@,@,@,@,@,@,@,@,@,@,(&)",param+2);
944  long id_modele = cid((char*)param[2].argument[0].c_str());
945  MG_CG_MODELE* mgcg_modele = get_mgcg_modeleid(id_modele);
946  int etat_forme = atoi((char*)param[3].argument[0].c_str());
947  MG_VOLUME* mg_volume;
948  if(etat_forme==MG_CG_FORME::ETAT_FORME::CONSTRUITE || etat_forme==MG_CG_FORME::ETAT_FORME::ATTENTE_RECONSTRUCTION) mg_volume = mgcg_modele->get_mg_geometrie()->get_mg_volumeid(cid((char*)param[4].argument[0].c_str()));
949  double extremite_x = atof((char*)param[5].argument[0].c_str());
950  double extremite_y = atof((char*)param[6].argument[0].c_str());
951  double extremite_z = atof((char*)param[7].argument[0].c_str());
952  double direction_x = atof((char*)param[8].argument[0].c_str());
953  double direction_y = atof((char*)param[9].argument[0].c_str());
954  double direction_z = atof((char*)param[10].argument[0].c_str());
955  double rayon = atof((char*)param[11].argument[0].c_str());
956  double longueur = atof((char*)param[12].argument[0].c_str());
957  MG_CG_FORME* forme = MG_CG::creer_MG_CG_FORME_VOLUME_CYLINDRE(mgcg_modele,etat_forme,id,mg_volume,extremite_x,extremite_y,extremite_z,direction_x,direction_y,direction_z,rayon,longueur);
958 #endif
959 }
960 
961 void MG_FILE::lire_MG_CG_FORME_VOLUME_CONE(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data)
962 {
963 #ifdef ALL_OCC
964  // PARAM # 2 3 4 5 6 7 8 9 101112
965  parse.decode(data.c_str(),"@,@,@,@,@,@,@,@,@,@,@,(&)",param+2);
966  long id_modele = cid((char*)param[2].argument[0].c_str());
967  MG_CG_MODELE* mgcg_modele = get_mgcg_modeleid(id_modele);
968  int etat_forme = atoi((char*)param[3].argument[0].c_str());
969  MG_VOLUME* mg_volume;
970  if(etat_forme==MG_CG_FORME::ETAT_FORME::CONSTRUITE || etat_forme==MG_CG_FORME::ETAT_FORME::ATTENTE_RECONSTRUCTION) mg_volume = mgcg_modele->get_mg_geometrie()->get_mg_volumeid(cid((char*)param[4].argument[0].c_str()));
971  double extremite_x = atof((char*)param[5].argument[0].c_str());
972  double extremite_y = atof((char*)param[6].argument[0].c_str());
973  double extremite_z = atof((char*)param[7].argument[0].c_str());
974  double direction_x = atof((char*)param[8].argument[0].c_str());
975  double direction_y = atof((char*)param[9].argument[0].c_str());
976  double direction_z = atof((char*)param[10].argument[0].c_str());
977  double rayon = atof((char*)param[11].argument[0].c_str());
978  double longueur = atof((char*)param[12].argument[0].c_str());
979  MG_CG_FORME* forme = MG_CG::creer_MG_CG_FORME_VOLUME_CONE(mgcg_modele,etat_forme,id,mg_volume,extremite_x,extremite_y,extremite_z,direction_x,direction_y,direction_z,rayon,longueur);
980 #endif
981 }
982 
983 void MG_FILE::lire_MG_CG_FORME_VOLUME_TORE(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data)
984 {
985 #ifdef ALL_OCC
986  // PARAM # 2 3 4 5 6 7 8 9 1011121314
987  parse.decode(data.c_str(),"@,@,@,@,@,@,@,@,@,@,@,@,@,(&)",param+2);
988  long id_modele = cid((char*)param[2].argument[0].c_str());
989  MG_CG_MODELE* mgcg_modele = get_mgcg_modeleid(id_modele);
990  int etat_forme = atoi((char*)param[3].argument[0].c_str());
991  MG_VOLUME* mg_volume;
992  if(etat_forme==MG_CG_FORME::ETAT_FORME::CONSTRUITE || etat_forme==MG_CG_FORME::ETAT_FORME::ATTENTE_RECONSTRUCTION) mg_volume = mgcg_modele->get_mg_geometrie()->get_mg_volumeid(cid((char*)param[4].argument[0].c_str()));
993  double centre_x = atof((char*)param[5].argument[0].c_str());
994  double centre_y = atof((char*)param[6].argument[0].c_str());
995  double centre_z = atof((char*)param[7].argument[0].c_str());
996  double direction_x = atof((char*)param[8].argument[0].c_str());
997  double direction_y = atof((char*)param[9].argument[0].c_str());
998  double direction_z = atof((char*)param[10].argument[0].c_str());
999  double rayon_cercle = atof((char*)param[11].argument[0].c_str());
1000  double rayon_tore = atof((char*)param[12].argument[0].c_str());
1001  double angle_seg = atof((char*)param[13].argument[0].c_str());
1002  double angle_rotation = atof((char*)param[14].argument[0].c_str());
1003  MG_CG_FORME* forme = MG_CG::creer_MG_CG_FORME_VOLUME_TORE(mgcg_modele,etat_forme,id,mg_volume,centre_x,centre_y,centre_z,direction_x,direction_y,direction_z,rayon_cercle,rayon_tore,angle_seg,angle_rotation);
1004 #endif
1005 }
1006 
1007 void MG_FILE::lire_MG_CG_FORME_MULTIPLE(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data)
1008 {
1009 #ifdef ALL_OCC
1010  // PARAM # 2 3 4 5 6 7 8 9
1011  parse.decode(data.c_str(),"@,@,@,@,(&),@,(&),@",param+2);
1012  long id_modele = cid((char*)param[2].argument[0].c_str());
1013  MG_CG_MODELE* mgcg_modele = get_mgcg_modeleid(id_modele);
1014  int provenance_forme = atoi((char*)param[3].argument[0].c_str());
1015  int etat_forme = atoi((char*)param[4].argument[0].c_str());
1016  std::vector<MG_ELEMENT_TOPOLOGIQUE*> vector_mg_element_topologique;
1017  std::vector<MG_ELEMENT_COTOPOLOGIQUE*> vector_mg_element_cotopologique;
1018  long nb_mg_element_topologique = atol((char*)param[5].argument[0].c_str());
1019  for(long i=0;i<nb_mg_element_topologique;i++)
1020  {
1021  vector_mg_element_topologique.push_back(mgcg_modele->get_mg_geometrie()->get_mg_element_topologiqueid(cid((char*)param[6].argument[i].c_str())));
1022  }
1023  long nb_mg_element_cotopologique = atol((char*)param[7].argument[0].c_str());
1024  for(long i=0;i<nb_mg_element_cotopologique;i++)
1025  {
1026  vector_mg_element_cotopologique.push_back(mgcg_modele->get_mg_geometrie()->get_mg_element_cotopologiqueid(cid((char*)param[8].argument[i].c_str())));
1027  }
1028  MG_CG_OPERATEUR* mgcg_operateur_parent = mgcg_modele->get_mgcg_operateurid(cid((char*)param[9].argument[0].c_str()));
1029  MG_CG_FORME* forme = MG_CG::creer_MG_CG_FORME_MULTIPLE(mgcg_modele,provenance_forme,etat_forme,id,vector_mg_element_topologique,vector_mg_element_cotopologique);
1030  forme->change_mgcg_operateur_parent(mgcg_operateur_parent);
1031 #endif
1032 }
1033 
1034 void MG_FILE::lire_MG_CG_FORME_MULTI_VOLUME(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data)
1035 {
1036 #ifdef ALL_OCC
1037  // PARAM # 2 3 4 5 6 7
1038  parse.decode(data.c_str(),"@,@,@,@,(&),@",param+2);
1039  long id_modele = cid((char*)param[2].argument[0].c_str());
1040  MG_CG_MODELE* mgcg_modele = get_mgcg_modeleid(id_modele);
1041  int provenance_forme = atoi((char*)param[3].argument[0].c_str());
1042  int etat_forme = atoi((char*)param[4].argument[0].c_str());
1043  std::vector<MG_VOLUME*> vector_mg_volume;
1044  long nb_mg_volume = atol((char*)param[5].argument[0].c_str());
1045  for(long i=0;i<nb_mg_volume;i++)
1046  {
1047  vector_mg_volume.push_back(mgcg_modele->get_mg_geometrie()->get_mg_volumeid(cid((char*)param[6].argument[i].c_str())));
1048  }
1049  MG_CG_OPERATEUR* mgcg_operateur_parent = mgcg_modele->get_mgcg_operateurid(cid((char*)param[7].argument[0].c_str()));
1050  MG_CG_FORME* forme = MG_CG::creer_MG_CG_FORME_MULTI_VOLUME(mgcg_modele,provenance_forme,etat_forme,id,vector_mg_volume);
1051  forme->change_mgcg_operateur_parent(mgcg_operateur_parent);
1052 #endif
1053 }
1054 
1055 void MG_FILE::lire_MG_CG_OP_BOOL_UNION(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data)
1056 {
1057 #ifdef ALL_OCC
1058  // PARAM # 2 3 4 5 6 7
1059  parse.decode(data.c_str(),"@,@,@,@,@,@",param+2);
1060  long id_modele = cid((char*)param[2].argument[0].c_str());
1061  MG_CG_MODELE* mgcg_modele = get_mgcg_modeleid(id_modele);
1062  int semantique = atoi((char*)param[3].argument[0].c_str());
1063  int etat_operateur = atoi((char*)param[4].argument[0].c_str());
1064  MG_CG_FORME* mgcg_forme_entree_1=NULL;
1065  MG_CG_FORME* mgcg_forme_entree_2=NULL;
1066  long id_forme_entree_1 = cid((char*)param[5].argument[0].c_str());
1067  if(id_forme_entree_1!=0) mgcg_forme_entree_1=mgcg_modele->get_mgcg_formeid(id_forme_entree_1);
1068  long id_forme_entree_2 = cid((char*)param[6].argument[0].c_str());
1069  if(id_forme_entree_2!=0) mgcg_forme_entree_2=mgcg_modele->get_mgcg_formeid(id_forme_entree_2);
1070  long id_forme_sortie = cid((char*)param[7].argument[0].c_str());
1071  MG_CG_OPERATEUR* mgcg_operateur = MG_CG::creer_MG_CG_OP_BOOL_UNION(mgcg_modele,semantique,etat_operateur,id,mgcg_forme_entree_1,mgcg_forme_entree_2,id_forme_sortie);
1072 #endif
1073 }
1074 
1075 void MG_FILE::lire_MG_CG_OP_BOOL_DIFFERENCE(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data)
1076 {
1077 #ifdef ALL_OCC
1078  // PARAM # 2 3 4 5 6 7
1079  parse.decode(data.c_str(),"@,@,@,@,@,@",param+2);
1080  long id_modele = cid((char*)param[2].argument[0].c_str());
1081  MG_CG_MODELE* mgcg_modele = get_mgcg_modeleid(id_modele);
1082  int semantique = atoi((char*)param[3].argument[0].c_str());
1083  int etat_operateur = atoi((char*)param[4].argument[0].c_str());
1084  MG_CG_FORME* mgcg_forme_entree_1=NULL;
1085  MG_CG_FORME* mgcg_forme_entree_2=NULL;
1086  long id_forme_entree_1 = cid((char*)param[5].argument[0].c_str());
1087  if(id_forme_entree_1!=0) mgcg_forme_entree_1=mgcg_modele->get_mgcg_formeid(id_forme_entree_1);
1088  long id_forme_entree_2 = cid((char*)param[6].argument[0].c_str());
1089  if(id_forme_entree_2!=0) mgcg_forme_entree_2=mgcg_modele->get_mgcg_formeid(id_forme_entree_2);
1090  long id_forme_sortie = cid((char*)param[7].argument[0].c_str());
1091  MG_CG_OPERATEUR* mgcg_operateur = MG_CG::creer_MG_CG_OP_BOOL_DIFFERENCE(mgcg_modele,semantique,etat_operateur,id,mgcg_forme_entree_1,mgcg_forme_entree_2,id_forme_sortie);
1092 #endif
1093 }
1094 
1095 void MG_FILE::lire_MG_CG_OP_BOOL_INTERSECTION(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data)
1096 {
1097 #ifdef ALL_OCC
1098  // PARAM # 2 3 4 5 6 7
1099  parse.decode(data.c_str(),"@,@,@,@,@,@",param+2);
1100  long id_modele = cid((char*)param[2].argument[0].c_str());
1101  MG_CG_MODELE* mgcg_modele = get_mgcg_modeleid(id_modele);
1102  int semantique = atoi((char*)param[3].argument[0].c_str());
1103  int etat_operateur = atoi((char*)param[4].argument[0].c_str());
1104  MG_CG_FORME* mgcg_forme_entree_1=NULL;
1105  MG_CG_FORME* mgcg_forme_entree_2=NULL;
1106  long id_forme_entree_1 = cid((char*)param[5].argument[0].c_str());
1107  if(id_forme_entree_1!=0) mgcg_forme_entree_1=mgcg_modele->get_mgcg_formeid(id_forme_entree_1);
1108  long id_forme_entree_2 = cid((char*)param[6].argument[0].c_str());
1109  if(id_forme_entree_2!=0) mgcg_forme_entree_2=mgcg_modele->get_mgcg_formeid(id_forme_entree_2);
1110  long id_forme_sortie = cid((char*)param[7].argument[0].c_str());
1111  MG_CG_OPERATEUR* mgcg_operateur = MG_CG::creer_MG_CG_OP_BOOL_INTERSECTION(mgcg_modele,semantique,etat_operateur,id,mgcg_forme_entree_1,mgcg_forme_entree_2,id_forme_sortie);
1112 #endif
1113 }
1114 
1115 void MG_FILE::lire_MG_CG_OP_BOOL_FRAGMENT(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data)
1116 {
1117 #ifdef ALL_OCC
1118  // PARAM # 2 3 4 5 6 7
1119  parse.decode(data.c_str(),"@,@,@,@,@,@",param+2);
1120  long id_modele = cid((char*)param[2].argument[0].c_str());
1121  MG_CG_MODELE* mgcg_modele = get_mgcg_modeleid(id_modele);
1122  int semantique = atoi((char*)param[3].argument[0].c_str());
1123  int etat_operateur = atoi((char*)param[4].argument[0].c_str());
1124  MG_CG_FORME* mgcg_forme_entree_1=NULL;
1125  MG_CG_FORME* mgcg_forme_entree_2=NULL;
1126  long id_forme_entree_1 = cid((char*)param[5].argument[0].c_str());
1127  if(id_forme_entree_1!=0) mgcg_forme_entree_1=mgcg_modele->get_mgcg_formeid(id_forme_entree_1);
1128  long id_forme_entree_2 = cid((char*)param[6].argument[0].c_str());
1129  if(id_forme_entree_2!=0) mgcg_forme_entree_2=mgcg_modele->get_mgcg_formeid(id_forme_entree_2);
1130  long id_forme_sortie = cid((char*)param[7].argument[0].c_str());
1131  MG_CG_OPERATEUR* mgcg_operateur = MG_CG::creer_MG_CG_OP_BOOL_FRAGMENT(mgcg_modele,semantique,etat_operateur,id,mgcg_forme_entree_1,mgcg_forme_entree_2,id_forme_sortie);
1132 #endif
1133 }
1134 
1135 void MG_FILE::lire_MG_CG_OP_INCLUSION_MATRICE(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data)
1136 {
1137 #ifdef ALL_OCC
1138  // PARAM # 2 3 4 5 6 7 8
1139  parse.decode(data.c_str(),"@,@,@,@,@,@,@",param+2);
1140  long id_modele = cid((char*)param[2].argument[0].c_str());
1141  MG_CG_MODELE* mgcg_modele = get_mgcg_modeleid(id_modele);
1142  int semantique = atoi((char*)param[3].argument[0].c_str());
1143  int etat_operateur = atoi((char*)param[4].argument[0].c_str());
1144  MG_CG_FORME* mgcg_forme_inclusion_entree=NULL;
1145  MG_CG_FORME* mgcg_forme_matrice_entree=NULL;
1146  long id_forme_inclusion_entree = cid((char*)param[5].argument[0].c_str());
1147  if(id_forme_inclusion_entree!=0) mgcg_forme_inclusion_entree=mgcg_modele->get_mgcg_formeid(id_forme_inclusion_entree);
1148  long id_forme_matrice_entree = cid((char*)param[6].argument[0].c_str());
1149  if(id_forme_matrice_entree!=0) mgcg_forme_matrice_entree=mgcg_modele->get_mgcg_formeid(id_forme_matrice_entree);
1150  long id_forme_inclusion_sortie = cid((char*)param[7].argument[0].c_str());
1151  long id_forme_matrice_sortie = cid((char*)param[8].argument[0].c_str());
1152  MG_CG_OPERATEUR* mgcg_operateur = MG_CG::creer_MG_CG_OP_INCLUSION_MATRICE(mgcg_modele,semantique,etat_operateur,id,mgcg_forme_inclusion_entree,mgcg_forme_matrice_entree,id_forme_inclusion_sortie,id_forme_matrice_sortie);
1153 #endif
1154 }
1155 
1156 void MG_FILE::lire_MG_CG_OP_TRANSF_ROTATION(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data)
1157 {
1158 #ifdef ALL_OCC
1159  // PARAM # 2 3 4 5 6 7 8 9 10 12
1160  // PARAM # 11 13
1161  parse.decode(data.c_str(),"@,@,@,@,@,@,@,@,@,@,@,@",param+2);
1162  long id_modele = cid((char*)param[2].argument[0].c_str());
1163  MG_CG_MODELE* mgcg_modele = get_mgcg_modeleid(id_modele);
1164  int semantique = atoi((char*)param[3].argument[0].c_str());
1165  int etat_operateur = atoi((char*)param[4].argument[0].c_str());
1166  MG_CG_FORME* mgcg_forme_entree=NULL;
1167  long id_forme_entree = cid((char*)param[5].argument[0].c_str());
1168  if(id_forme_entree!=0) mgcg_forme_entree=mgcg_modele->get_mgcg_formeid(id_forme_entree);
1169  long id_forme_sortie = cid((char*)param[6].argument[0].c_str());
1170  MG_CG_OP_TRANSF_ROTATION* mgcg_op_transf_rotation = MG_CG::creer_MG_CG_OP_TRANSF_ROTATION(mgcg_modele,semantique,etat_operateur,id,mgcg_forme_entree,id_forme_sortie);
1171  double x = atof((char*)param[7].argument[0].c_str());
1172  double y = atof((char*)param[8].argument[0].c_str());
1173  double z = atof((char*)param[9].argument[0].c_str());
1174  double w = atof((char*)param[10].argument[0].c_str());
1175  double centre_x = atof((char*)param[11].argument[0].c_str());
1176  double centre_y = atof((char*)param[12].argument[0].c_str());
1177  double centre_z = atof((char*)param[13].argument[0].c_str());
1178  OT_QUATERNION ot_quaternion(x,y,z,w);
1179  mgcg_op_transf_rotation->change_rotation(ot_quaternion);
1180  mgcg_op_transf_rotation->change_centre_rotation(centre_x,centre_y,centre_z);
1181 #endif
1182 }
1183 
1184 void MG_FILE::lire_MG_CG_OP_TRANSF_TRANSLATION(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data)
1185 {
1186 #ifdef ALL_OCC
1187  // PARAM # 2 3 4 5 6 7 8 9
1188  parse.decode(data.c_str(),"@,@,@,@,@,@,@,@,",param+2);
1189  long id_modele = cid((char*)param[2].argument[0].c_str());
1190  MG_CG_MODELE* mgcg_modele = get_mgcg_modeleid(id_modele);
1191  int semantique = atoi((char*)param[3].argument[0].c_str());
1192  int etat_operateur = atoi((char*)param[4].argument[0].c_str());
1193  MG_CG_FORME* mgcg_forme_entree=NULL;
1194  long id_forme_entree = cid((char*)param[5].argument[0].c_str());
1195  if(id_forme_entree!=0) mgcg_forme_entree=mgcg_modele->get_mgcg_formeid(id_forme_entree);
1196  long id_forme_sortie = cid((char*)param[6].argument[0].c_str());
1197  MG_CG_OP_TRANSF_TRANSLATION* mgcg_op_transf_translation = MG_CG::creer_MG_CG_OP_TRANSF_TRANSLATION(mgcg_modele,semantique,etat_operateur,id,mgcg_forme_entree,id_forme_sortie);
1198  double x = atof((char*)param[7].argument[0].c_str());
1199  double y = atof((char*)param[8].argument[0].c_str());
1200  double z = atof((char*)param[9].argument[0].c_str());
1201  mgcg_op_transf_translation->change_translation(x,y,z);
1202 #endif
1203 }
1204 
1205 void MG_FILE::lire_MG_CG_OP_TRANSF_ECHELLE(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data)
1206 {
1207 #ifdef ALL_OCC
1208  // PARAM # 2 3 4 5 6 7 8 9 10
1209  parse.decode(data.c_str(),"@,@,@,@,@,@,@,@,@,",param+2);
1210  long id_modele = cid((char*)param[2].argument[0].c_str());
1211  MG_CG_MODELE* mgcg_modele = get_mgcg_modeleid(id_modele);
1212  int semantique = atoi((char*)param[3].argument[0].c_str());
1213  int etat_operateur = atoi((char*)param[4].argument[0].c_str());
1214  MG_CG_FORME* mgcg_forme_entree=NULL;
1215  long id_forme_entree = cid((char*)param[5].argument[0].c_str());
1216  if(id_forme_entree!=0) mgcg_forme_entree=mgcg_modele->get_mgcg_formeid(id_forme_entree);
1217  long id_forme_sortie = cid((char*)param[6].argument[0].c_str());
1218  MG_CG_OP_TRANSF_ECHELLE* mgcg_op_transf_echelle = MG_CG::creer_MG_CG_OP_TRANSF_ECHELLE(mgcg_modele,semantique,etat_operateur,id,mgcg_forme_entree,id_forme_sortie);
1219  double x = atof((char*)param[7].argument[0].c_str());
1220  double y = atof((char*)param[8].argument[0].c_str());
1221  double z = atof((char*)param[9].argument[0].c_str());
1222  double facteur = atof((char*)param[10].argument[0].c_str());
1223  mgcg_op_transf_echelle->change_centre_echelle(x,y,z);
1224  mgcg_op_transf_echelle->change_facteur_echelle(facteur);
1225 #endif
1226 }
1227 
1228 void MG_FILE::lire_MG_CG_OP_TRANSF_DECALLAGE(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data)
1229 {
1230 #ifdef ALL_OCC
1231  // PARAM # 2 3 4 5 6 7
1232  parse.decode(data.c_str(),"@,@,@,@,@,@,",param+2);
1233  long id_modele = cid((char*)param[2].argument[0].c_str());
1234  MG_CG_MODELE* mgcg_modele = get_mgcg_modeleid(id_modele);
1235  int semantique = atoi((char*)param[3].argument[0].c_str());
1236  int etat_operateur = atoi((char*)param[4].argument[0].c_str());
1237  MG_CG_FORME* mgcg_forme_entree=NULL;
1238  long id_forme_entree = cid((char*)param[5].argument[0].c_str());
1239  if(id_forme_entree!=0) mgcg_forme_entree=mgcg_modele->get_mgcg_formeid(id_forme_entree);
1240  long id_forme_sortie = cid((char*)param[6].argument[0].c_str());
1241  MG_CG_OP_TRANSF_DECALLAGE* mgcg_op_transf_decallage = MG_CG::creer_MG_CG_OP_TRANSF_DECALLAGE(mgcg_modele,semantique,etat_operateur,id,mgcg_forme_entree,id_forme_sortie);
1242  double decallage = atof((char*)param[7].argument[0].c_str());
1243  mgcg_op_transf_decallage->change_decallage(decallage);
1244 #endif
1245 }
1246 
1247 void MG_FILE::lire_MG_CG_INFO_STRING(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data)
1248 {
1249 #ifdef ALL_OCC
1250  // PARAM # 2 3
1251  parse.decode(data.c_str(),"@,@",param+2);
1252  std::string identifiant = param[2].argument[0];
1253  std::string valeur = param[3].argument[0];
1254  MG_IDENTIFICATEUR *mg_id=NULL;
1255  LISTE_MGCG_MODELE::iterator it_modele=lst_mgcg_modele.begin();
1256  while(mg_id==NULL && it_modele!=lst_mgcg_modele.end())
1257  {
1258  MG_CG_MODELE* modele = it_modele->second;
1259  if(modele->get_id()==id)
1260  {
1261  mg_id=modele;
1262  }
1263  else
1264  {
1265  mg_id=modele->get_mg_identificateur(id);
1266  }
1267  it_modele++;
1268  }
1269  if(mg_id!=NULL)
1270  {
1271  MG_CONSTRUCTION_GEOMETRIQUE* mg_constr_geo = (MG_CONSTRUCTION_GEOMETRIQUE*)mg_id;
1272  MG_CG_INFO_STRING* info_str = MG_CG::creer_MG_CG_INFO_STRING(mg_constr_geo,id,identifiant,valeur);
1273  }
1274 #endif
1275 }
1276 
1277 void MG_FILE::lire_MG_CG_INFO_DOUBLE(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data)
1278 {
1279 #ifdef ALL_OCC
1280  // PARAM # 2 3
1281  parse.decode(data.c_str(),"@,@",param+2);
1282  std::string identifiant = param[2].argument[0];
1283  double valeur = atof(param[3].argument[0].c_str());
1284  MG_IDENTIFICATEUR *mg_id=NULL;
1285  LISTE_MGCG_MODELE::iterator it_modele=lst_mgcg_modele.begin();
1286  while(mg_id==NULL && it_modele!=lst_mgcg_modele.end())
1287  {
1288  MG_CG_MODELE* modele = it_modele->second;
1289  if(modele->get_id()==id)
1290  {
1291  mg_id=modele;
1292  }
1293  else
1294  {
1295  mg_id=modele->get_mg_identificateur(id);
1296  }
1297  it_modele++;
1298  }
1299  if(mg_id!=NULL)
1300  {
1301  MG_CONSTRUCTION_GEOMETRIQUE* mg_constr_geo = (MG_CONSTRUCTION_GEOMETRIQUE*)mg_id;
1302  MG_CG_INFO_DOUBLE* info_dbl = MG_CG::creer_MG_CG_INFO_DOUBLE(mg_constr_geo,id,identifiant,valeur);
1303  }
1304 #endif
1305 }
1306 
1307 void MG_FILE::lire_MG_CG_INFO_VCT_DOUBLE(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data)
1308 {
1309 #ifdef ALL_OCC
1310  // PARAM # 2 3 4
1311  parse.decode(data.c_str(),"@,@,(&)",param+2);
1312  std::string identifiant = param[2].argument[0];
1313  long nb_valeur = atol(param[3].argument[0].c_str());
1314  std::vector<double> vector_valeur;
1315  for(long i=0;i<nb_valeur;i++)
1316  {
1317  double valeur = atof(param[4].argument[i].c_str());
1318  vector_valeur.push_back(valeur);
1319  }
1320  MG_IDENTIFICATEUR *mg_id=NULL;
1321  LISTE_MGCG_MODELE::iterator it_modele=lst_mgcg_modele.begin();
1322  while(mg_id==NULL && it_modele!=lst_mgcg_modele.end())
1323  {
1324  MG_CG_MODELE* modele = it_modele->second;
1325  if(modele->get_id()==id)
1326  {
1327  mg_id=modele;
1328  }
1329  else
1330  {
1331  mg_id=modele->get_mg_identificateur(id);
1332  }
1333  it_modele++;
1334  }
1335  if(mg_id!=NULL)
1336  {
1337  MG_CONSTRUCTION_GEOMETRIQUE* mg_constr_geo = (MG_CONSTRUCTION_GEOMETRIQUE*)mg_id;
1338  MG_CG_INFO_VCT_DOUBLE* info_dbl = MG_CG::creer_MG_CG_INFO_VCT_DOUBLE(mg_constr_geo,id,identifiant,vector_valeur);
1339  }
1340 #endif
1341 }
1342 
1343 
1344 int MG_FILE::lire(char* chemin)
1345 {
1346  FILE *in;
1347  //char ligne[3000];
1348  in=fopen(chemin,"rt");
1349  if (in==NULL) return 0;
1350  PARS_ARGUMENT param[100];
1351  PARSE parse;
1352 
1353  MG_GEOMETRIE *mggeo;
1354  MG_ARBRE* arbre;
1355 #ifdef WINDOWS_VERSION
1356  std::multimap<CAD4FE::MCVertex*, unsigned long> mapMergedRefVertices;
1357 #endif
1358  bool updatedMergedRefVertices = false;
1359  version_fichier=1.0;
1360  std::vector<unsigned long> volumemince;
1361  do
1362  {
1363  int ierr;
1364  std::string ligne=parse.lire(in,';',&ierr);
1365  parse.decode(ligne.c_str(),"@;",param);
1366  const char *chaine=param[0].argument[0].c_str();
1367  if ((chaine[0]=='/') && (chaine[1]=='/'))
1368  {
1369  if ((chaine[2]=='*')&&(chaine[3]=='i'))
1370  {
1371  unsigned long id;
1372  sscanf(chaine,"//*i:%lu;",&id);
1373  entiteidmax=id;
1374  }
1375  if ((chaine[2]=='*')&&(chaine[3]=='v'))
1376  sscanf(chaine,"//*v:%lf;",&version_fichier);
1377  }
1378  else if (param[0].argument[0]!="FIN")
1379  {
1380  parse.decode(ligne.c_str(),"%@=@(@);",param);
1381  std::string entite=param[1].argument[0];
1382  long id=atol(param[0].argument[0].c_str());
1383  std::string data=param[2].argument[0] ;
1384  MG_MAILLAGE *mgmai;
1385  FEM_MAILLAGE *femmai;
1386  if (entite=="GEOMETRIE")
1387  {
1388  parse.decode(data.c_str(),"@,@,@,@",param+2);
1389  double unite=atof(param[2].argument[0].c_str());
1390  std::string typegeo=param[3].argument[0];
1391  std::string chemin_geo=param[4].argument[0];
1392  if (typegeo=="VIRTUEL")
1393  {
1394  mggeo=new MG_GEOMETRIE((char*)typegeo.c_str(),id,(char*)chemin_geo.c_str(),unite);
1395  ajouter_mg_geometrie(mggeo);
1396  }
1397 #ifdef BREP_STEP
1398  if (typegeo=="STEP")
1399  {
1400  mggeo=new MG_GEOMETRIE((char*)"STEP",id,(char *)chemin_geo.c_str(),unite);
1401  ajouter_mg_geometrie(mggeo);
1402  }
1403 #endif
1404 #ifdef BREP_SAT
1405  if (typegeo=="ACIS")
1406  {
1407  mggeo=new MG_GEOMETRIE((char*)"ACIS",id,(char *)chemin_geo.c_str(),unite);
1408  ajouter_mg_geometrie(mggeo);
1409  }
1410 #endif
1411 
1412 #ifdef BREP_OCC
1413  if (typegeo=="OCC")
1414  {
1415  mggeo=new MG_GEOMETRIE((char*)"OCC",id,chemin_geo.c_str(),unite);
1416  ajouter_mg_geometrie(mggeo);
1417  }
1418  if (typegeo=="OCCV2015")
1419  {
1420  mggeo=new MG_GEOMETRIE((char*)"OCCV2015",id,chemin_geo.c_str(),unite);
1421  ajouter_mg_geometrie(mggeo);
1422  }
1423 #endif
1424 #ifdef ALL_OCC
1425  if (typegeo=="OCCV2017")
1426  {
1427  mggeo=new MG_GEOMETRIE((char*)"OCCV2017",id,chemin_geo.c_str(),unite);
1428  ajouter_mg_geometrie(mggeo);
1429  OCC_FONCTION_V2017* occ_fonction_v2017 = (OCC_FONCTION_V2017*)&mggeo->get_occ_fonction();
1430  std::string chemin_caf = str_dossier + chemin_geo + ".ocaf";
1431  char* chemin_caf_char = (char*)chemin_caf.c_str();
1432  occ_fonction_v2017->ouvrir_fichier_OCAF(chemin_caf_char);
1433  }
1434 #endif
1435  std::string nommat="";
1436  if (param[5].argument[0]!="")
1437  nommat=param[5].argument[0];
1438  mggeo->change_gest_materiau((char*)nommat.c_str());
1439  }
1440  if (entite=="CONSTRUCTION")
1441  {
1442  MG_GEOMETRIE * mgconstruction;
1443  parse.decode(data.c_str(),"@,@,@,@",param+2);
1444  double unite=atof(param[2].argument[0].c_str());
1445  std::string typegeo=param[3].argument[0];
1446  std::string chemin_geo=param[4].argument[0];
1447 #ifdef ALL_OCC
1448  if (typegeo=="OCCV2017")
1449  {
1450  mgconstruction=new MG_GEOMETRIE((char*)"OCCV2017",id,chemin_geo.c_str(),unite);
1451  mggeo=mgconstruction;
1452  mgconstruction->change_est_construction(true);
1453  ajouter_mg_construction(mgconstruction);
1454  OCC_FONCTION_V2017* occ_fonction_v2017 = (OCC_FONCTION_V2017*)&mgconstruction->get_occ_fonction();
1455  std::string chemin_caf = str_dossier + chemin_geo + ".ocaf";
1456  char* chemin_caf_char = (char*)chemin_caf.c_str();
1457  occ_fonction_v2017->ouvrir_fichier_OCAF(chemin_caf_char);
1458  }
1459 #endif
1460  if (typegeo=="VIRTUEL")
1461  {
1462  mgconstruction=new MG_GEOMETRIE((char*)typegeo.c_str(),id,(char*)chemin_geo.c_str(),unite);
1463  mggeo=mgconstruction;
1464  mggeo->change_est_construction(true);
1465  ajouter_mg_construction(mggeo);
1466  }
1467  std::string nommat="";
1468  if (param[5].argument[0]!="")
1469  nommat=param[5].argument[0];
1470  mgconstruction->change_gest_materiau((char*)nommat.c_str());
1471  }
1472 #ifdef CSG_OCC
1473  if (entite=="ARBRE")
1474  {
1475  parse.decode(data.c_str(),"@",param+2);
1476  std::string nom=param[2].argument[0];
1477  arbre=new MG_ARBRE(id,nom.c_str());
1478  ajouter_mg_arbre(arbre);
1479  }
1480  if (entite == "ASSEMBLAGE")
1481  {
1482  parse.decode(data.c_str(),"@,@,(&)",param+2);
1483  std::string nom=param[2].argument[0];
1484  int nb_primitive = atoi((char*)param[3].argument[0].c_str());
1485  MG_ASSEMBLAGE *mgassembl=new MG_ASSEMBLAGE(id,nom.c_str());
1486  for(int i=0;i<nb_primitive;i++)
1487  {
1488  unsigned long id2 = cid(param[4].argument[i]);
1489  mgassembl->ajouter_mg_primitive(id2);
1490  }
1491  arbre->ajouter_mg_assemblage(mgassembl);
1492  }
1493  if (entite=="BOITE")
1494  {
1495  parse.decode(data.c_str(),"@,@,@,@,@,@",param+2);
1496  double x1=atof((char*)param[2].argument[0].c_str());
1497  double y1=atof((char*)param[3].argument[0].c_str());
1498  double z1=atof((char*)param[4].argument[0].c_str());
1499  double x2=atof((char*)param[5].argument[0].c_str());
1500  double y2=atof((char*)param[6].argument[0].c_str());
1501  double z2=atof((char*)param[7].argument[0].c_str());
1502  MG_PRIMITIVE_BOITE *b=new MG_PRIMITIVE_BOITE(id,x1,y1,z1,x2,y2,z2);
1503  b->construit();
1504  arbre->ajouter_mg_primitive(b);
1505  }
1506  if (entite=="SPHERE")
1507  {
1508  parse.decode(data.c_str(),"@,@,@,@",param+2);
1509  double centre_x=atof((char*)param[2].argument[0].c_str());
1510  double centre_y=atof((char*)param[3].argument[0].c_str());
1511  double centre_z=atof((char*)param[4].argument[0].c_str());
1512  double rayon=atof((char*)param[5].argument[0].c_str());
1513  MG_PRIMITIVE_SPHERE *b=new MG_PRIMITIVE_SPHERE(id,centre_x,centre_y,centre_z,rayon);
1514  b->construit();
1515  arbre->ajouter_mg_primitive(b);
1516  }
1517  if (entite=="ELLIPSOIDE_REVOLUTION")
1518  {
1519  parse.decode(data.c_str(),"@,@,@,@,@,@,@,@",param+2);
1520  double centre_x=atof((char*)param[2].argument[0].c_str());
1521  double centre_y=atof((char*)param[3].argument[0].c_str());
1522  double centre_z=atof((char*)param[4].argument[0].c_str());
1523  double axe_x=atof((char*)param[5].argument[0].c_str());
1524  double axe_y=atof((char*)param[6].argument[0].c_str());
1525  double axe_z=atof((char*)param[7].argument[0].c_str());
1526  double rayon_majeur=atof((char*)param[8].argument[0].c_str());
1527  double rayon_mineur=atof((char*)param[9].argument[0].c_str());
1528  MG_PRIMITIVE_ELLIPSOIDE_REVOLUTION *b=new MG_PRIMITIVE_ELLIPSOIDE_REVOLUTION(id,centre_x,centre_y,centre_z,axe_x,axe_y,axe_z,rayon_majeur,rayon_mineur);
1529  b->construit();
1530  arbre->ajouter_mg_primitive(b);
1531  }
1532  if (entite=="CYLINDRE")
1533  {
1534  parse.decode(data.c_str(),"@,@,@,@,@,@,@",param+2);
1535  double extremite_x=atof((char*)param[2].argument[0].c_str());
1536  double extremite_y=atof((char*)param[3].argument[0].c_str());
1537  double extremite_z=atof((char*)param[4].argument[0].c_str());
1538  double longitude=atof((char*)param[5].argument[0].c_str());
1539  double latitude=atof((char*)param[6].argument[0].c_str());
1540  double rayon=atof((char*)param[7].argument[0].c_str());
1541  double longueur=atof((char*)param[8].argument[0].c_str());
1542  MG_PRIMITIVE_CYLINDRE *b=new MG_PRIMITIVE_CYLINDRE(id,extremite_x,extremite_y,extremite_z,longitude,latitude,rayon,longueur);
1543  b->construit();
1544  arbre->ajouter_mg_primitive(b);
1545  }
1546  if (entite=="TORE")
1547  {
1548  parse.decode(data.c_str(),"@,@,@,@,@,@,@",param+2);
1549  double centre_x=atof((char*)param[2].argument[0].c_str());
1550  double centre_y=atof((char*)param[3].argument[0].c_str());
1551  double centre_z=atof((char*)param[4].argument[0].c_str());
1552  double longitude=atof((char*)param[5].argument[0].c_str());
1553  double latitude=atof((char*)param[6].argument[0].c_str());
1554  double rayon_cercle=atof((char*)param[7].argument[0].c_str());
1555  double rayon_tore=atof((char*)param[8].argument[0].c_str());
1556  MG_PRIMITIVE_TORE *b=new MG_PRIMITIVE_TORE(id,centre_x,centre_y,centre_z,longitude,latitude,rayon_cercle,rayon_tore);
1557  b->construit();
1558  arbre->ajouter_mg_primitive(b);
1559  }
1560  if (entite=="CONE")
1561  {
1562  parse.decode(data.c_str(),"@,@,@,@,@,@,@",param+2);
1563  double base_x=atof((char*)param[2].argument[0].c_str());
1564  double base_y=atof((char*)param[3].argument[0].c_str());
1565  double base_z=atof((char*)param[4].argument[0].c_str());
1566  double longitude=atof((char*)param[5].argument[0].c_str());
1567  double latitude=atof((char*)param[6].argument[0].c_str());
1568  double rayon=atof((char*)param[7].argument[0].c_str());
1569  double hauteur=atof((char*)param[8].argument[0].c_str());
1570  MG_PRIMITIVE_CONE *b=new MG_PRIMITIVE_CONE(id,base_x,base_y,base_z,longitude,latitude,rayon,hauteur);
1571  b->construit();
1572  arbre->ajouter_mg_primitive(b);
1573  }
1574  if (entite=="UNION")
1575  {
1576  parse.decode(data.c_str(),"@,@,@",param+2);
1577  int sem=atoi((char*)param[2].argument[0].c_str());
1578  long id1=cid((char*)param[3].argument[0].c_str());
1579  long id2=cid((char*)param[4].argument[0].c_str());
1580  MG_PRIMITIVE *p1=arbre->get_mg_primitiveid(id1);
1581  MG_PRIMITIVE *p2=arbre->get_mg_primitiveid(id2);
1582  MG_OPERATEUR_BOOLEAN_UNION *op=new MG_OPERATEUR_BOOLEAN_UNION(id,sem,p1,p2);
1583  arbre->ajouter_mg_operateur_boolean(op);
1584  }
1585  if (entite=="DIFFERENCE")
1586  {
1587  parse.decode(data.c_str(),"@,@,@",param+2);
1588  int sem=atoi((char*)param[2].argument[0].c_str());
1589  long id1=cid((char*)param[3].argument[0].c_str());
1590  long id2=cid((char*)param[4].argument[0].c_str());
1591  MG_PRIMITIVE *p1=arbre->get_mg_primitiveid(id1);
1592  MG_PRIMITIVE *p2=arbre->get_mg_primitiveid(id2);
1593  MG_OPERATEUR_BOOLEAN_DIFFERENCE *op=new MG_OPERATEUR_BOOLEAN_DIFFERENCE(id,sem,p1,p2);
1594  arbre->ajouter_mg_operateur_boolean(op);
1595  }
1596  if (entite=="INTERSECTION")
1597  {
1598  parse.decode(data.c_str(),"@,@,@",param+2);
1599  int sem=atoi((char*)param[2].argument[0].c_str());
1600  long id1=cid((char*)param[3].argument[0].c_str());
1601  long id2=cid((char*)param[4].argument[0].c_str());
1602  MG_PRIMITIVE *p1=arbre->get_mg_primitiveid(id1);
1603  MG_PRIMITIVE *p2=arbre->get_mg_primitiveid(id2);
1604  MG_OPERATEUR_BOOLEAN_INTERSECTION *op=new MG_OPERATEUR_BOOLEAN_INTERSECTION(id,sem,p1,p2);
1605  arbre->ajouter_mg_operateur_boolean(op);
1606  }
1607  if (entite=="PRIM_COMPLEXE")
1608  {
1609  parse.decode(data.c_str(),"@",param+2);
1610  long id1=cid((char*)param[2].argument[0].c_str());
1611  MG_OPERATEUR_BOOLEAN *op=arbre->get_mg_operateur_booleanid(id1);
1612  MG_PRIMITIVE* p=op->construit(id);
1613  arbre->ajouter_mg_primitive(p);
1614  }
1615 
1616  if (entite=="MG_CG_MODELE")
1617  {
1618  lire_MG_CG_MODELE(id,parse,param,data);
1619  }
1620  if (entite =="MG_CG_ASSEMBLAGE")
1621  {
1622  lire_MG_CG_ASSEMBLAGE(id,parse,param,data);
1623  }
1624  if (entite =="MG_CG_INFO_DOUBLE")
1625  {
1626  lire_MG_CG_INFO_DOUBLE(id,parse,param,data);
1627  }
1628  if (entite =="MG_CG_INFO_STRING")
1629  {
1630  lire_MG_CG_INFO_STRING(id,parse,param,data);
1631  }
1632  if (entite =="MG_CG_INFO_VCT_DOUBLE")
1633  {
1634  lire_MG_CG_INFO_VCT_DOUBLE(id,parse,param,data);
1635  }
1636  if (entite =="MG_CG_GROUPE_FORME")
1637  {
1638  lire_MG_CG_GROUPE_FORME(id,parse,param,data);
1639  }
1640  if (entite =="MG_CG_FORME_ARETE")
1641  {
1642  lire_MG_CG_FORME_ARETE(id,parse,param,data);
1643  }
1644  if (entite =="MG_CG_FORME_ARETE_DROITE")
1645  {
1646  lire_MG_CG_FORME_ARETE_DROITE(id,parse,param,data);
1647  }
1648  if (entite =="MG_CG_FORME_VOLUME")
1649  {
1650  lire_MG_CG_FORME_VOLUME(id,parse,param,data);
1651  }
1652  if (entite =="MG_CG_FORME_VOLUME_BOITE")
1653  {
1654  lire_MG_CG_FORME_VOLUME_BOITE(id,parse,param,data);
1655  }
1656  if (entite =="MG_CG_FORME_VOLUME_SPHERE")
1657  {
1658  lire_MG_CG_FORME_VOLUME_SPHERE(id,parse,param,data);
1659  }
1660  if (entite =="MG_CG_FORME_VOLUME_ELLIPSOIDE")
1661  {
1662  lire_MG_CG_FORME_VOLUME_ELLIPSOIDE(id,parse,param,data);
1663  }
1664  if (entite =="MG_CG_FORME_VOLUME_CYLINDRE")
1665  {
1666  lire_MG_CG_FORME_VOLUME_CYLINDRE(id,parse,param,data);
1667  }
1668  if (entite =="MG_CG_FORME_VOLUME_CONE")
1669  {
1670  lire_MG_CG_FORME_VOLUME_CONE(id,parse,param,data);
1671  }
1672  if (entite =="MG_CG_FORME_VOLUME_TORE")
1673  {
1674  lire_MG_CG_FORME_VOLUME_TORE(id,parse,param,data);
1675  }
1676  if (entite =="MG_CG_FORME_MULTIPLE")
1677  {
1678  lire_MG_CG_FORME_MULTIPLE(id,parse,param,data);
1679  }
1680  if (entite =="MG_CG_FORME_MULTI_VOLUME")
1681  {
1682  lire_MG_CG_FORME_MULTI_VOLUME(id,parse,param,data);
1683  }
1684  if (entite =="MG_CG_OP_BOOL_UNION")
1685  {
1686  lire_MG_CG_OP_BOOL_UNION(id,parse,param,data);
1687  }
1688  if (entite =="MG_CG_OP_BOOL_DIFFERENCE")
1689  {
1690  lire_MG_CG_OP_BOOL_DIFFERENCE(id,parse,param,data);
1691  }
1692  if (entite =="MG_CG_OP_BOOL_INTERSECTION")
1693  {
1694  lire_MG_CG_OP_BOOL_INTERSECTION(id,parse,param,data);
1695  }
1696  if (entite =="MG_CG_OP_BOOL_FRAGMENT")
1697  {
1698  lire_MG_CG_OP_BOOL_FRAGMENT(id,parse,param,data);
1699  }
1700  if (entite =="MG_CG_OP_INCLUSION_MATRICE")
1701  {
1702  lire_MG_CG_OP_INCLUSION_MATRICE(id,parse,param,data);
1703  }
1704  if (entite =="MG_CG_OP_TRANSF_ROTATION")
1705  {
1706  lire_MG_CG_OP_TRANSF_ROTATION(id,parse,param,data);
1707  }
1708  if (entite =="MG_CG_OP_TRANSF_TRANSLATION")
1709  {
1710  lire_MG_CG_OP_TRANSF_TRANSLATION(id,parse,param,data);
1711  }
1712  if (entite =="MG_CG_OP_TRANSF_ECHELLE")
1713  {
1714  lire_MG_CG_OP_TRANSF_ECHELLE(id,parse,param,data);
1715  }
1716  if (entite =="MG_CG_OP_TRANSF_DECALLAGE")
1717  {
1718  lire_MG_CG_OP_TRANSF_DECALLAGE(id,parse,param,data);
1719  }
1720 
1721 #endif
1722  if (entite =="MG_SOUS_GEOMETRIE")
1723  {
1724  lire_MG_SOUS_GEOMETRIE(id,parse,param,data);
1725  }
1726  if (entite=="GEOMETRIE_EPS")
1727  {
1728  parse.decode(data.c_str(),"@",param+2);
1729  double val=atof((char*)param[2].argument[0].c_str());
1730  mggeo->change_valeur_precision(val);
1731  }
1732  if (entite=="GROUPE_TOPOLOGIQUE")
1733  {
1734  parse.decode(data.c_str(),"@,(&)",param+2);
1735  MG_GROUPE_TOPOLOGIQUE* mggt=new MG_GROUPE_TOPOLOGIQUE(id);
1736  mggeo->ajouter_mg_groupe_topologique(mggt);
1737  int nb=atoi(param[2].argument[0].c_str());
1738  for (int i=0;i<nb;i++)
1739  {
1740  unsigned long id2=cid(param[3].argument[i].c_str());
1741  MG_ELEMENT_TOPOLOGIQUE* ele;
1742  ele=mggeo->get_mg_sommetid(id2);
1743  if (ele==NULL) ele=mggeo->get_mg_areteid(id2);
1744  if (ele==NULL) ele=mggeo->get_mg_faceid(id2);
1745  if (ele==NULL) ele=mggeo->get_mg_volumeid(id2);
1746  if (ele!=NULL) mggt->ajouter(ele);
1747  }
1748 
1749  }
1750  if (entite=="GEOM_FONCTION")
1751  {
1752  parse.decode(data.c_str(),"@,@,(&)",param+2);
1753  int dim=atoi((char*)param[2].argument[0].c_str());
1754  MG_GEOM_FONCTION *gf=new MG_GEOM_FONCTION(id,dim);
1755  mggeo->ajouter_mg_geom_fonction(gf);
1756  int nb=atoi(param[3].argument[0].c_str());
1757  for (int i=0;i<nb;i++)
1758  {
1759  parse.decode(param[4].argument[i].c_str(),"(&)",param+5);
1760  double *coo=new double[dim];
1761  for (int j=0;j<dim;j++)
1762  coo[j]=atof(param[5].argument[j].c_str());
1763  gf->ajouter_point(coo);
1764  delete [] coo;
1765  }
1766 
1767  }
1768 
1769  if (entite=="VOLUME")
1770  {
1771  lire_MG_VOLUME(id,parse,param,data,mggeo,volumemince);
1772 
1773  /*{
1774  for (int i=0;i<nb;i++)
1775  {
1776  parse.decode(param[6].argument[i].c_str(),"(@,@)",param+7);
1777  char nom[3];
1778  double val;
1779  strcpy(nom,param[7].argument[0].c_str());
1780  val=atof(param[8].argument[0].c_str());
1781  mgvol->ajouter_ccf(nom,val);
1782  }
1783  }*/
1784  }
1785  if (entite=="COQUE")
1786  {
1787  if (version_fichier<2)
1788  {
1789  parse.decode(data.c_str(),"@,@,@,@,(&)",param+2);
1790  MG_COQUE* mgcoq=new MG_COQUE(param[2].argument[0],id);
1791  mggeo->ajouter_mg_coque(mgcoq);
1792  int nummat=atoi((char*)param[4].argument[0].c_str());
1793  mgcoq->change_num_materiau(nummat);
1794  int nb=atoi(param[5].argument[0].c_str());
1795  if (nb!=0) lire_ccf(version_fichier,nb,6,parse,param,mgcoq);
1796  }
1797  else
1798  {
1799  parse.decode(data.c_str(),"@,@,@,(&)",param+2);
1800  MG_COQUE* mgcoq=new MG_COQUE(param[2].argument[0],id);
1801  mggeo->ajouter_mg_coque(mgcoq);
1802  int nb=atoi(param[4].argument[0].c_str());
1803  if (nb!=0) lire_ccf(version_fichier,nb,5,parse,param,mgcoq);
1804  }
1805  /*if (nb!=0)
1806  {
1807  for (int i=0;i<nb;i++)
1808  {
1809  parse.decode(param[6].argument[i].c_str(),"(@,@)",param+7);
1810  char nom[3];
1811  double val;
1812  strcpy(nom,param[7].argument[0].c_str());
1813  val=atof(param[8].argument[0].c_str());
1814  mgcoq->ajouter_ccf(nom,val);
1815  }
1816  }*/
1817  }
1818  if (entite=="POUTRE")
1819  {
1820  if (version_fichier<2)
1821  {
1822  parse.decode(data.c_str(),"@,@,@,@,(&)",param+2);
1823  MG_POUTRE* mgpoutre=new MG_POUTRE(param[2].argument[0],id);
1824  mggeo->ajouter_mg_poutre(mgpoutre);
1825  int nummat=atoi((char*)param[4].argument[0].c_str());
1826  mgpoutre->change_num_materiau(nummat);
1827  int nb=atoi(param[5].argument[0].c_str());
1828  if (nb!=0) lire_ccf(version_fichier,nb,6,parse,param,mgpoutre);
1829  }
1830  else
1831  {
1832  parse.decode(data.c_str(),"@,@,@,(&)",param+2);
1833  MG_POUTRE* mgpou=new MG_POUTRE(param[2].argument[0],id);
1834  mggeo->ajouter_mg_poutre(mgpou);
1835  int nb=atoi(param[4].argument[0].c_str());
1836  if (nb!=0) lire_ccf(version_fichier,nb,5,parse,param,mgpou);
1837  }
1838 
1839  /*if (nb!=0)
1840  {
1841  for (int i=0;i<nb;i++)
1842  {
1843  parse.decode(param[6].argument[i].c_str(),"(@,@)",param+7);
1844  char nom[3];
1845  double val;
1846  strcpy(nom,param[7].argument[0].c_str());
1847  val=atof(param[8].argument[0].c_str());
1848  mgpoutre->ajouter_ccf(nom,val);
1849  }
1850  }*/
1851  }
1852  if (entite=="COQUILLE")
1853  {
1854  lire_MG_COQUILLE(id,parse,param,data,mggeo);
1855  }
1856 
1857 #ifdef BREP_STEP
1858  if (entite=="SURFACE_STEP")
1859  {
1860  parse.decode(data.c_str(),"@",param+2);
1861  long idstepsuf=atol(param[2].argument[0].c_str());
1862  ST_SURFACE *stsurf=mggeo->get_gest_step().lst_surface.getid(idstepsuf);
1863  STEP_SURFACE* stepsurf=new STEP_SURFACE(id,stsurf);
1864  mggeo->ajouter_mg_surface(stepsurf);
1865  }
1866  if (entite=="COURBE_STEP")
1867  {
1868  parse.decode(data.c_str(),"@",param+2);
1869  long idstepcur=atol(param[2].argument[0].c_str());
1870  ST_COURBE *stcur=mggeo->get_gest_step().lst_courbe.getid(idstepcur);
1871  STEP_COURBE* stepcur=new STEP_COURBE(id,stcur);
1872  mggeo->ajouter_mg_courbe(stepcur);
1873  }
1874 
1875  if (entite=="POINT_STEP")
1876  {
1877  parse.decode(data.c_str(),"@",param+2);
1878  long idsteppt=atol(param[2].argument[0].c_str());
1879  ST_POINT *stpt=mggeo->get_gest_step().lst_point.getid(idsteppt);
1880  STEP_POINT* steppt=new STEP_POINT(id,stpt);
1881  mggeo->ajouter_mg_point(steppt);
1882  }
1883 
1884 #endif
1885 #ifdef BREP_SAT
1886  if (entite=="SURFACE_SAT")
1887  {
1888  parse.decode(data.c_str(),"@",param+2);
1889  long idsatsuf=atol(param[2].argument[0].c_str());
1890  SAT_SURFACE *satsurf=mggeo->get_gest_sat().lst_surface.getid(idsatsuf);
1891  ACIS_SURFACE* acissurf=new ACIS_SURFACE(id,satsurf);
1892  mggeo->ajouter_mg_surface(acissurf);
1893  }
1894  if (entite=="COURBE_SAT")
1895  {
1896  parse.decode(data.c_str(),"@",param+2);
1897  long idsatcur=atol(param[2].argument[0].c_str());
1898  SAT_COURBE *satcur=mggeo->get_gest_sat().lst_courbe.getid(idsatcur);
1899  ACIS_COURBE* aciscur=new ACIS_COURBE(id,satcur);
1900  mggeo->ajouter_mg_courbe(aciscur);
1901  }
1902 
1903  if (entite=="POINT_SAT")
1904  {
1905  parse.decode(data.c_str(),"@",param+2);
1906  long idsatpt=atol(param[2].argument[0].c_str());
1907  SAT_POINT *satpt=mggeo->get_gest_sat().lst_point.getid(idsatpt);
1908  ACIS_POINT* acispt=new ACIS_POINT(id,satpt);
1909  mggeo->ajouter_mg_point(acispt);
1910  }
1911 
1912 #endif
1913 
1914 #ifdef ALL_OCC
1915 
1916  if (entite=="SURFACE_OCC")
1917  {
1918  parse.decode(data.c_str(),"@",param+2);
1919  long idocc=atol(param[2].argument[0].c_str());
1920  TopoDS_Face occface;
1921  if(mggeo->get_occ_fonction().get_version()=="OCCV2017")
1922  {
1923  OCC_FONCTION_V2017* occ_fonction_2017 = (OCC_FONCTION_V2017*)&mggeo->get_occ_fonction();
1924  occface=occ_fonction_2017->get_TopoDS_Face_id(idocc);
1925  }
1926  else
1927  {
1928  const TopoDS_Shape& occshape=mggeo->get_occ_fonction().GetShape(idocc);
1929  occface=TopoDS::Face(occshape);
1930  }
1931  mggeo->get_occ_fonction().change_precision(mggeo->get_valeur_precision());
1932  OCC_SURFACE* occsurf=new OCC_SURFACE(id,occface,&mggeo->get_occ_fonction());
1933  occsurf->change_idoriginal(std::to_string(idocc));
1934  mggeo->ajouter_mg_surface(occsurf);
1935  }
1936  if (entite=="COURBE_OCC")
1937  {
1938  parse.decode(data.c_str(),"@",param+2);
1939  long idocc=atol(param[2].argument[0].c_str());
1940  TopoDS_Edge occedge;
1941  if(mggeo->get_occ_fonction().get_version()=="OCCV2017")
1942  {
1943  OCC_FONCTION_V2017* occ_fonction_2017 = (OCC_FONCTION_V2017*)&mggeo->get_occ_fonction();
1944  occedge=occ_fonction_2017->get_TopoDS_Edge_id(idocc);
1945  }
1946  else
1947  {
1948  const TopoDS_Shape& occshape=mggeo->get_occ_fonction().GetShape(idocc);
1949  occedge=TopoDS::Edge(occshape);
1950  }
1951  OCC_COURBE* occcrb=new OCC_COURBE(id,occedge, &mggeo->get_occ_fonction());
1952  mggeo->ajouter_mg_courbe(occcrb);
1953  occcrb->change_idoriginal(std::to_string(idocc));
1954  }
1955  if (entite=="POINT_OCC")
1956  {
1957  parse.decode(data.c_str(),"@",param+2);
1958  long idocc=atol(param[2].argument[0].c_str());
1959  TopoDS_Vertex occvertex;
1960  if(mggeo->get_occ_fonction().get_version()=="OCCV2017")
1961  {
1962  OCC_FONCTION_V2017* occ_fonction_2017 = (OCC_FONCTION_V2017*)&mggeo->get_occ_fonction();
1963  occvertex = occ_fonction_2017->get_TopoDS_Vertex_id(idocc);
1964  }
1965  else
1966  {
1967  const TopoDS_Shape& occshape=mggeo->get_occ_fonction().GetShape(idocc);
1968  occvertex=TopoDS::Vertex(occshape);
1969  }
1970 
1971  OCC_POINT* occpoint=new OCC_POINT(id,occvertex, &mggeo->get_occ_fonction());
1972  mggeo->ajouter_mg_point(occpoint);
1973  occpoint->change_idoriginal((std::to_string(idocc)));
1974  }
1975 #endif
1976 #ifdef WINDOWS_VERSION
1977  if (entite=="CAD4FE_POLYCURVE")
1978  {
1979  CAD4FE::PolyCurve * polycurve = NULL;
1980  parse.decode(data.c_str(),"@,(&)",param+2);
1981  int nb = atoi(param[2].argument[0].c_str());
1982 
1983  if (nb == 0)
1984  {
1985  printf("PolyCurve %d is formed with reference vertex : ", id);
1986  parse.decode(param[3].argument[0].c_str(),"@",param+4);
1987  int idRefVertex;
1988  idRefVertex=cid(param[4].argument[0].c_str());
1989  printf("%d ;\n ", idRefVertex);
1990  MG_SOMMET * refVertex = mggeo->get_mg_sommetid(idRefVertex);
1991  polycurve = new CAD4FE::PolyCurve(refVertex);
1992  }
1993  else
1994  {
1995  printf("PolyCurve %d is formed with reference edges : ", id);
1996  polycurve = new CAD4FE::PolyCurve;
1997  for (int i=0;i<nb;i++)
1998  {
1999  parse.decode(param[3].argument[i].c_str(),"@",param+4);
2000  int idRefEdge;
2001  idRefEdge=cid(param[4].argument[0].c_str());
2002  printf("%d ; ", idRefEdge);
2003  MG_ARETE * refEdge = mggeo->get_mg_areteid(idRefEdge);
2004  CAD4FE::PolyCurve tmpPC(refEdge);
2005  polycurve->Merge(tmpPC);
2006  }
2007  printf("\n");
2008  }
2009 
2010  polycurve->change_id(id);
2011  mggeo->ajouter_mg_courbe(polycurve);
2012  }
2013 
2014 
2015  if (entite=="CAD4FE_POLYSURFACE")
2016  {
2017  CAD4FE::PolySurface * polysurface = new CAD4FE::PolySurface;
2018  polysurface->change_id(id);
2019  mggeo->ajouter_mg_surface(polysurface);
2020 
2021  parse.decode(data.c_str(),"@,(&)",param+2);
2022 
2023  int nb = atoi(param[2].argument[0].c_str());
2024  printf("PolySurface %d is formed with reference faces : ", id);
2025  for (int i=0;i<nb;i++)
2026  {
2027  parse.decode(param[3].argument[i].c_str(),"@",param+4);
2028  int idRefFace;
2029  idRefFace=cid(param[4].argument[0].c_str());
2030  printf("%d ; ", idRefFace);
2031 
2032  MG_FACE * refFace = mggeo->get_mg_faceid(idRefFace);
2033  CAD4FE::PolySurface tmpSF(refFace);
2034  polysurface->Merge(tmpSF);
2035  }
2036 
2037  printf("\n");
2038  }
2039  if (entite=="CAD4FE_MCEDGE")
2040  {
2041  parse.decode(data.c_str(),"@,@,@,@,@,@,(&)",param+2);
2042 
2043  std::string idOriginal = param[2].argument[0];
2044  long idPolyCurve=cid(param[3].argument[0]);
2045  CAD4FE::PolyCurve * polycurve = (CAD4FE::PolyCurve *) mggeo->get_mg_courbeid(idPolyCurve);
2046 
2047  // sense is not used because a MCEdge always has
2048  // a sense = 1 !
2049  // (because polycurve domain is equal to mcEdge domain)
2050  CAD4FE::MCEdge * mcEdge = new CAD4FE::MCEdge(idOriginal, polycurve);
2051  mcEdge->change_id(id);
2052  mggeo->ajouter_mg_arete(mcEdge);
2053 
2054  int nb=atoi(param[7].argument[0].c_str());
2055  if (nb!=0)
2056  {
2057  for (int i=0;i<nb;i++)
2058  {
2059  parse.decode(param[8].argument[i].c_str(),"(@,@)",param+9);
2060  char nom[3];
2061  double val;
2062  strcpy(nom,param[9].argument[0].c_str());
2063  val=atof(param[10].argument[0].c_str());
2064  mcEdge->ajouter_ccf(nom,val);
2065  }
2066  }
2067  }
2068  if (entite=="CAD4FE_MCFACE")
2069  {
2070  parse.decode(data.c_str(),"@,@,@,@,@,(&)",param+2);
2071 
2072  std::string idOriginal = param[2].argument[0];
2073  long idPolySurface=cid(param[3].argument[0]);
2074  CAD4FE::PolySurface * polysurface = (CAD4FE::PolySurface *) mggeo->get_mg_surfaceid(idPolySurface);
2075 
2076  CAD4FE::MCFace * mcFace = new CAD4FE::MCFace(idOriginal, polysurface);
2077  mcFace->change_id(id);
2078  mggeo->ajouter_mg_face(mcFace);
2079 
2080  int nb=atoi(param[6].argument[0].c_str());
2081  if (nb!=0)
2082  {
2083  for (int i=0;i<nb;i++)
2084  {
2085  parse.decode(param[7].argument[i].c_str(),"(@,@)",param+8);
2086  char nom[3];
2087  double val;
2088  strcpy(nom,param[8].argument[0].c_str());
2089  val=atof(param[9].argument[0].c_str());
2090  mcFace->ajouter_ccf(nom,val);
2091  }
2092  }
2093  }
2094  if (entite=="CAD4FE_MCVERTEX")
2095  {
2096  parse.decode(data.c_str(),"@,@,@,(&),@,(&)",param+2);
2097  std::string idOriginal = param[2].argument[0];
2098  long idsom=cid(param[3].argument[0]);
2099  MG_SOMMET * mgsom = mggeo->get_mg_sommetid(idsom);
2100  CAD4FE::MCVertex * mcVertex = new CAD4FE::MCVertex(mgsom);
2101  mcVertex->change_id(id);
2102  mggeo->ajouter_mg_sommet(mcVertex);
2103  int nb_ref_vertex=atoi(param[4].argument[0].c_str());
2104  if (nb_ref_vertex!=0)
2105  {
2106  for (int i=0;i<nb_ref_vertex;i++)
2107  {
2108  unsigned long idRefVertex=cid(param[5].argument[i]);
2109  mcVertex->GetMergedRefVertices()[idRefVertex] = NULL;
2110  mapMergedRefVertices.insert(std::make_pair(mcVertex,idRefVertex));
2111  }
2112  }
2113  int nb_ccf=atoi(param[4+2].argument[0].c_str());
2114  if (nb_ccf!=0)
2115  {
2116  for (int i=0;i<nb_ccf;i++)
2117  {
2118  parse.decode(param[5+2].argument[i].c_str(),"(@,@)",param+6+2);
2119  char nom_ccf[3];
2120  double val_ccf;
2121  strcpy(nom_ccf,param[6+2].argument[0].c_str());
2122  val_ccf=atof(param[7+2].argument[0].c_str());
2123  mgsom->ajouter_ccf(nom_ccf,val_ccf);
2124  }
2125  }
2126  }
2127 #endif
2128  if (entite=="FACE")
2129  {
2130  lire_MG_FACE(id,parse,param,data,mggeo);
2131  /*if (nb!=0)
2132  {
2133  for (int i=0;i<nb;i++)
2134  {
2135  parse.decode(param[7].argument[i].c_str(),"(@,@)",param+8);
2136  char nom[3];
2137  double val;
2138  strcpy(nom,param[8].argument[0].c_str());
2139  val=atof(param[9].argument[0].c_str());
2140  mgface->ajouter_ccf(nom,val);
2141  }
2142  }*/
2143  }
2144  if (entite=="COFACE")
2145  {
2146  parse.decode(data.c_str(),"@,@,@",param+2);
2147  long idface=cid(param[2].argument[0]);
2148  long idcoq=cid(param[3].argument[0]);
2149  int sens=atoi(param[4].argument[0].c_str());
2150  MG_FACE* mgface=mggeo->get_mg_faceid(idface);
2151  MG_COQUILLE* mgcoq=mggeo->get_mg_coquilleid(idcoq);
2152  MG_COFACE* mgcoface=mggeo->ajouter_mg_coface(id,mgface,mgcoq,sens);
2153  mgcoq->ajouter_mg_coface(mgcoface);
2154  }
2155  if (entite=="BOUCLE")
2156  {
2157  lire_MG_BOUCLE(id,parse,param,data,mggeo);
2158  }
2159  if (entite=="POINT")
2160  {
2161  parse.decode(data.c_str(),"@,@,@",param+2);
2162  double xyz[3];
2163  xyz[0]=atof(param[2].argument[0].c_str());
2164  xyz[1]=atof(param[3].argument[0].c_str());
2165  xyz[2]=atof(param[4].argument[0].c_str());
2166  LC_POINT* point=new LC_POINT(id,xyz);
2167  mggeo->ajouter_mg_point(point);
2168  }
2169  if (entite=="SOMMET")
2170  {
2171  lire_MG_SOMMET(id,parse,param,data,mggeo);
2172  }
2173 #ifdef ALL_OCC
2174  if (entite=="OCC_SOMMET")
2175  {
2176  parse.decode(data.c_str(),"@,@,@,@,(&)",param+2);
2177  long idpoint=cid(param[3].argument[0]);
2178  MG_POINT* mgpt=mggeo->get_mg_pointid(idpoint);
2179  TopoDS_Vertex topods_vertex;
2180  long idori = stol(param[2].argument[0]);
2181  OCC_SOMMET* occ_sommet;
2182  if(mggeo->get_occ_fonction().get_version()=="OCCV2017")
2183  {
2184  OCC_FONCTION_V2017* occ_fonction_v2017 = (OCC_FONCTION_V2017*)&mggeo->get_occ_fonction();
2185  topods_vertex=occ_fonction_v2017->get_TopoDS_Vertex_id(idori);
2186  occ_sommet = new OCC_SOMMET(param[2].argument[0],id,mgpt,topods_vertex,&mggeo->get_occ_fonction());
2187  mggeo->ajouter_mg_sommet(occ_sommet);
2188  occ_fonction_v2017->ajouter_OCC_SOMMET(occ_sommet);
2189  }
2190  else
2191  {
2192  std::cout << "*** MG_FILE : ERREUR lecture OCC_SOMMET : Mauvaise OCC_FONCTION ! ***" << std::endl;
2193  }
2194  int argccf=5;
2195  if (version_fichier>2.1)
2196  {
2197  argccf=6;
2198  int ipole=atoi(param[4].argument[0].c_str());
2199  if (ipole==1) occ_sommet->change_pole(true);
2200  }
2201  int nb=atoi(param[argccf-1].argument[0].c_str());
2202  if (nb!=0) lire_ccf(version_fichier,nb,argccf,parse,param,occ_sommet);
2203  }
2204  if (entite=="OCC_ARETE")
2205  {
2206  parse.decode(data.c_str(),"@,@,@,@,@,@,(&)",param+2);
2207  long idcur=cid(param[3].argument[0]);
2208  int sens=atol(param[6].argument[0].c_str());
2209  long idori = stoi(param[2].argument[0]);
2210  TopoDS_Edge topods_edge;
2211  OCC_ARETE* occ_arete;
2212  MG_COURBE* mgcur=mggeo->get_mg_courbeid(idcur);
2213  if(mggeo->get_occ_fonction().get_version()=="OCCV2017")
2214  {
2215  OCC_FONCTION_V2017* occ_fonction_v2017 = (OCC_FONCTION_V2017*)&mggeo->get_occ_fonction();
2216  topods_edge=occ_fonction_v2017->get_TopoDS_Edge_id(idori);
2217  occ_arete= new OCC_ARETE(param[2].argument[0],id,mgcur,sens,topods_edge,&mggeo->get_occ_fonction());
2218  mggeo->ajouter_mg_arete(occ_arete);
2219  occ_fonction_v2017->ajouter_OCC_ARETE(occ_arete);
2220  }
2221  else
2222  {
2223  std::cout << "*** MG_FILE : ERREUR lecture OCC_ARETE : Mauvaise OCC_FONCTION ! ***" << std::endl;
2224  }
2225  int nb=atoi(param[7].argument[0].c_str());
2226  if (nb!=0) lire_ccf(version_fichier,nb,8,parse,param,occ_arete);
2227  }
2228  if (entite=="OCC_BOUCLE")
2229  {
2230  parse.decode(data.c_str(),"@,@,(@)",param+2);
2231  long ident=cid(param[2].argument[0]);
2232  long idori=stol(param[3].argument[0]);
2233  TopoDS_Wire topods_wire;
2234  OCC_BOUCLE* occ_boucle;
2235  if(mggeo->get_occ_fonction().get_version()=="OCCV2017")
2236  {
2237  OCC_FONCTION_V2017* occ_fonction_v2017 = (OCC_FONCTION_V2017*)&mggeo->get_occ_fonction();
2238  topods_wire=occ_fonction_v2017->get_TopoDS_Wire_id(idori);
2239  if(ident!=-1)
2240  {
2241  MG_FACE* mgface=mggeo->get_mg_faceid(ident);
2242  MG_POUTRE* mgpoutre=mggeo->get_mg_poutreid(ident);
2243  if (mgface!=NULL)
2244  {
2245  OCC_BOUCLE* occ_boucle=new OCC_BOUCLE(param[3].argument[0],id,mgface,topods_wire,&mggeo->get_occ_fonction());
2246  mggeo->ajouter_mg_boucle(occ_boucle,mgface);
2247  occ_fonction_v2017->ajouter_OCC_BOUCLE(occ_boucle);
2248  }
2249  if (mgpoutre!=NULL)
2250  {
2251  OCC_BOUCLE* occ_boucle=new OCC_BOUCLE(param[3].argument[0],id,mgpoutre,topods_wire,&mggeo->get_occ_fonction());
2252  mggeo->ajouter_mg_boucle(occ_boucle,mgpoutre);
2253  occ_fonction_v2017->ajouter_OCC_BOUCLE(occ_boucle);
2254  }
2255  }
2256  else
2257  {
2258  OCC_BOUCLE* occ_boucle=new OCC_BOUCLE(param[3].argument[0],id,topods_wire,&mggeo->get_occ_fonction());
2259  mggeo->ajouter_mg_boucle(occ_boucle);
2260  occ_fonction_v2017->ajouter_OCC_BOUCLE(occ_boucle);
2261  }
2262  }
2263  else
2264  {
2265  std::cout << "*** MG_FILE : ERREUR lecture OCC_BOUCLE : Mauvaise OCC_FONCTION ! ***" << std::endl;
2266  }
2267 
2268  }
2269  if (entite=="OCC_FACE")
2270  {
2271  parse.decode(data.c_str(),"@,@,(@),@,@,@,(&)",param+2);
2272  long idsurf=cid(param[3].argument[0]);
2273  int sens=atoi(param[5].argument[0].c_str());
2274  long idori = stol(param[2].argument[0]);
2275  TopoDS_Face topods_face;
2276  OCC_FACE* occ_face;
2277  MG_SURFACE* mgsurf=mggeo->get_mg_surfaceid(idsurf);
2278  if(mggeo->get_occ_fonction().get_version()=="OCCV2017")
2279  {
2280  OCC_FONCTION_V2017* occ_fonction_v2017 = (OCC_FONCTION_V2017*)&mggeo->get_occ_fonction();
2281  topods_face=occ_fonction_v2017->get_TopoDS_Face_id(idori);
2282  occ_face = new OCC_FACE(param[2].argument[0],id,mgsurf,sens,topods_face,&mggeo->get_occ_fonction());
2283  mggeo->ajouter_mg_face(occ_face);
2284  occ_fonction_v2017->ajouter_OCC_FACE(occ_face);
2285  }
2286  else
2287  {
2288  std::cout << "*** MG_FILE : ERREUR lecture OCC_FACE : Mauvaise OCC_FONCTION ! ***" << std::endl;
2289  }
2290  int argccf=7;
2291  if (version_fichier>2.1)
2292  {
2293  argccf=8;
2294  int nbpole=atoi(param[6].argument[0].c_str());
2295  occ_face->change_nb_pole(nbpole);
2296  }
2297  int nb=atoi(param[argccf-1].argument[0].c_str());
2298  if (nb!=0) lire_ccf(version_fichier,nb,argccf,parse,param,occ_face);
2299  }
2300  if (entite=="OCC_COQUILLE")
2301  {
2302  parse.decode(data.c_str(),"@,@,@",param+2);
2303  long ident=cid(param[2].argument[0]);
2304  long idori = stol(param[3].argument[0]);
2305  TopoDS_Shell topods_shell;
2306  OCC_COQUILLE* occ_coquille;
2307  if(mggeo->get_occ_fonction().get_version()=="OCCV2017")
2308  {
2309  OCC_FONCTION_V2017* occ_fonction_v2017 = (OCC_FONCTION_V2017*)&mggeo->get_occ_fonction();
2310  topods_shell=occ_fonction_v2017->get_TopoDS_Shell_id(idori);
2311  if(idori!=-1)
2312  {
2313  MG_VOLUME* mgvol=mggeo->get_mg_volumeid(ident);
2314  MG_COQUE* mgcoq=mggeo->get_mg_coqueid(ident);
2315  if (mgvol!=NULL)
2316  {
2317  OCC_COQUILLE* occ_coquille = new OCC_COQUILLE(param[3].argument[0],id,mgvol,topods_shell,&mggeo->get_occ_fonction());
2318  mggeo->ajouter_mg_coquille(occ_coquille,mgvol);
2319  occ_fonction_v2017->ajouter_OCC_COQUILLE(occ_coquille);
2320  }
2321  if (mgcoq!=NULL)
2322  {
2323  OCC_COQUILLE* occ_coquille = new OCC_COQUILLE(param[3].argument[0],id,mgcoq,topods_shell,&mggeo->get_occ_fonction());
2324  mggeo->ajouter_mg_coquille(occ_coquille,mgcoq);
2325  occ_fonction_v2017->ajouter_OCC_COQUILLE(occ_coquille);
2326  }
2327  }
2328  else
2329  {
2330  OCC_COQUILLE* occ_coquille = new OCC_COQUILLE(param[3].argument[0],id,topods_shell,&mggeo->get_occ_fonction());
2331  mggeo->ajouter_mg_coquille(occ_coquille);
2332  occ_fonction_v2017->ajouter_OCC_COQUILLE(occ_coquille);
2333  }
2334  }
2335  else
2336  {
2337  std::cout << "*** MG_FILE : ERREUR lecture OCC_COQUILLE : Mauvaise OCC_FONCTION ! ***" << std::endl;
2338  }
2339  }
2340  if (entite=="OCC_VOLUME")
2341  {
2342 
2343  parse.decode(data.c_str(),"@,@,@,@",param+2);
2344  long idori = stol(param[2].argument[0]);
2345  TopoDS_Solid topods_solid;
2346  OCC_VOLUME* occ_volume;
2347  if(mggeo->get_occ_fonction().get_version()=="OCCV2017")
2348  {
2349  OCC_FONCTION_V2017* occ_fonction_v2017 = (OCC_FONCTION_V2017*)&mggeo->get_occ_fonction();
2350  topods_solid=occ_fonction_v2017->get_TopoDS_Solid_id(idori);
2351  occ_volume = new OCC_VOLUME(param[2].argument[0],id,topods_solid,&mggeo->get_occ_fonction());
2352  mggeo->ajouter_mg_volume(occ_volume);
2353  occ_fonction_v2017->ajouter_OCC_VOLUME(occ_volume);
2354  }
2355  else
2356  {
2357  std::cout << "*** MG_FILE : ERREUR lecture OCC_VOLUME : Mauvaise OCC_FONCTION ! ***" << std::endl;
2358  }
2359  int mince=atoi(param[4].argument[0].c_str());
2360  if (mince==0)
2361  {
2362  std::string data2=param[5].argument[0];
2363  parse.decode(data2.c_str(),"@,(&)",param+5);
2364  int nb=atoi(param[5].argument[0].c_str());
2365  if (nb!=0) lire_ccf(version_fichier,nb,6,parse,param,occ_volume);
2366  }
2367  else
2368  {
2369  std::string data2=param[5].argument[0];
2370  parse.decode(data2.c_str(),"(&),@,(&)",param+5);
2371  int nb_face=param[5].argument.size();
2372  for (int i=0;i<nb_face;i=i+2)
2373  {
2374  unsigned long idn1=cid(param[5].argument[i]);
2375  unsigned long idn2=cid(param[5].argument[i+1]);
2376  volumemince.push_back(id);
2377  volumemince.push_back(idn1);
2378  volumemince.push_back(idn2);
2379  }
2380  int nb=atoi(param[6].argument[0].c_str());
2381  if (nb!=0) lire_ccf(version_fichier,nb,7,parse,param,occ_volume);
2382  }
2383  }
2384 
2385 
2386 #endif
2387  if (entite=="ARETE_ELEMENT")
2388  {
2389  if (version_fichier<2.35)
2390  parse.decode(data.c_str(),"@,(&),@,(&)",param+2);
2391  else
2392  parse.decode(data.c_str(),"@,(&),(&),@,(&)",param+2);
2393  MG_ARETE_ELEMENT* are=new MG_ARETE_ELEMENT(id);
2394  mggeo->ajouter_mg_arete(are);
2395  int numparamnb=4;
2396  if (version_fichier>2.35)
2397  {
2398  numparamnb=5;
2399  lire_contrainte(4,param,are);
2400  }
2401  int nb=atoi(param[numparamnb].argument[0].c_str());
2402  if (nb!=0) lire_ccf(version_fichier,nb,5,parse,param,are);
2403 
2404 
2405  }
2406  if (entite=="FACE_ELEMENT")
2407  {
2408  if (version_fichier<2.35)
2409  parse.decode(data.c_str(),"@,(&),@,(&)",param+2);
2410  else
2411  parse.decode(data.c_str(),"@,(&),(&),@,(&)",param+2);
2412  MG_FACE_ELEMENT* face=new MG_FACE_ELEMENT(id);
2413  mggeo->ajouter_mg_face(face);
2414  int numparamnb=4;
2415  if (version_fichier>2.35)
2416  {
2417  numparamnb=5;
2418  lire_contrainte(4,param,face);
2419 
2420  }
2421  int nb=atoi(param[numparamnb].argument[0].c_str());
2422  if (nb!=0)
2423  lire_ccf(version_fichier,nb,numparamnb+1,parse,param,face);
2424 
2425  }
2426  if (entite=="COQUE_ELEMENT")
2427  {
2428  parse.decode(data.c_str(),"@,(&),@,(&)",param+2);
2429  MG_COQUE_ELEMENT* coq=new MG_COQUE_ELEMENT(id);
2430  mggeo->ajouter_mg_coque(coq);
2431  int nbele=atoi(param[2].argument[0].c_str());
2432  for (int i=0;i<nbele;i++)
2433  {
2434  unsigned long idele=cid(param[3].argument[i].c_str());
2435  coq->ajouter_element(idele);
2436  }
2437  int nb=atoi(param[4].argument[0].c_str());
2438  if (nb!=0) lire_ccf(version_fichier,nb,5,parse,param,coq);
2439  /* if (nb!=0)
2440  {
2441  for (int i=0;i<nb;i++)
2442  {
2443  parse.decode(param[5].argument[i].c_str(),"(@,@)",param+6);
2444  char nom[3];
2445  double val;
2446  strcpy(nom,param[6].argument[0].c_str());
2447  val=atof(param[7].argument[0].c_str());
2448  coq->ajouter_ccf(nom,val);
2449  }
2450  }*/
2451  }
2452  if (entite=="POUTRE_ELEMENT")
2453  {
2454  parse.decode(data.c_str(),"@,(&),@,(&)",param+2);
2455  MG_POUTRE_ELEMENT* pou=new MG_POUTRE_ELEMENT(id);
2456  mggeo->ajouter_mg_poutre(pou);
2457  int nbele=atoi(param[2].argument[0].c_str());
2458  for (int i=0;i<nbele;i++)
2459  {
2460  unsigned long idele=cid(param[3].argument[i].c_str());
2461  pou->ajouter_element(idele);
2462  }
2463  int nb=atoi(param[4].argument[0].c_str());
2464  if (nb!=0) lire_ccf(version_fichier,nb,5,parse,param,pou);
2465  /*if (nb!=0)
2466  {
2467  for (int i=0;i<nb;i++)
2468  {
2469  parse.decode(param[5].argument[i].c_str(),"(@,@)",param+6);
2470  char nom[3];
2471  double val;
2472  strcpy(nom,param[6].argument[0].c_str());
2473  val=atof(param[7].argument[0].c_str());
2474  pou->ajouter_ccf(nom,val);
2475  }
2476  }*/
2477  }
2478  if (entite=="VOLUME_ELEMENT")
2479  {
2480  if (version_fichier<2.35)
2481  parse.decode(data.c_str(),"@,(&),@,(&)",param+2);
2482  else
2483  parse.decode(data.c_str(),"@,(&),(&),@,(&)",param+2);
2484  MG_VOLUME_ELEMENT* vol=new MG_VOLUME_ELEMENT(id);
2485  mggeo->ajouter_mg_volume(vol);
2486  int numparamnb=4;
2487  if (version_fichier>2.35)
2488  {
2489  numparamnb=5;
2490  lire_contrainte(4,param,vol);
2491 
2492  }
2493  int nb=atoi(param[numparamnb].argument[0].c_str());
2494  if (nb!=0) lire_ccf(version_fichier,nb,numparamnb+1,parse,param,vol);
2495 
2496  }
2497  if (entite=="SOMMET_NOEUD")
2498  {
2499  if (version_fichier<2.35)
2500  parse.decode(data.c_str(),"@,@,(&)",param+2);
2501  else
2502  parse.decode(data.c_str(),"@,(&),@,(&)",param+2);
2503  long idnoeud=cid(param[2].argument[0]);
2504  MG_SOMMET_NOEUD* mgsom=new MG_SOMMET_NOEUD(id,idnoeud);
2505  mggeo->ajouter_mg_sommet(mgsom);
2506  int numparamnb=3;
2507  if (version_fichier>2.35)
2508  {
2509  numparamnb=4;
2510  lire_contrainte(3,param,mgsom);
2511 
2512  }
2513  int nb=atoi(param[numparamnb].argument[0].c_str());
2514  if (nb!=0) lire_ccf(version_fichier,nb,numparamnb+1,parse,param,mgsom);
2515  }
2516  if (entite=="ARETE")
2517  {
2518  lire_MG_ARETE(id,parse,param,data,mggeo);
2519  }
2520  if (entite=="COSOMMET")
2521  {
2522  parse.decode(data.c_str(),"@,@,@",param+2);
2523  long idsom=cid(param[2].argument[0]);
2524  long idarete=cid(param[3].argument[0]);
2525  int num=atoi(param[4].argument[0].c_str());
2526  MG_SOMMET* mgsom=mggeo->get_mg_sommetid(idsom);
2527  MG_ARETE* mgarete=mggeo->get_mg_areteid(idarete);
2528  MG_COSOMMET* mgcosom=mggeo->ajouter_mg_cosommet(id,mgarete,mgsom);
2529  if (num==1) mgarete->changer_cosommet1(mgcosom);
2530  if (num==2) mgarete->changer_cosommet2(mgcosom);
2531  }
2532  if (entite=="COARETE")
2533  {
2534  parse.decode(data.c_str(),"@,@,@",param+2);
2535  long idarete=cid(param[2].argument[0]);
2536  long idboucle=cid(param[3].argument[0]);
2537  int sens=atoi(param[4].argument[0].c_str());
2538  MG_ARETE* mgarete=mggeo->get_mg_areteid(idarete);
2539  MG_BOUCLE* mgboucle=mggeo->get_mg_boucleid(idboucle);
2540  MG_COARETE* mgcoarete=mggeo->ajouter_mg_coarete(id,mgarete,mgboucle,sens);
2541  mgboucle->ajouter_mg_coarete(mgcoarete);
2542  }
2543  if (entite=="VISU_COURBE")
2544  {
2545  parse.decode(data.c_str(),"@,@,@,@,@,@",param+2);
2546  double xyz1[3];
2547  double xyz2[3];
2548  xyz1[0]=atof(param[2].argument[0].c_str());
2549  xyz1[1]=atof(param[3].argument[0].c_str());
2550  xyz1[2]=atof(param[4].argument[0].c_str());
2551  xyz2[0]=atof(param[5].argument[0].c_str());
2552  xyz2[1]=atof(param[6].argument[0].c_str());
2553  xyz2[2]=atof(param[7].argument[0].c_str());
2554  MG_VISU_COURBE* mgcrb=new MG_VISU_COURBE(id,xyz1,xyz2);
2555  mggeo->ajouter_mg_visu_courbe(mgcrb);
2556  }
2557  if (entite=="MAILLAGE")
2558  {
2559  parse.decode(data.c_str(),"@",param+2);
2560  long idgeo=cid(param[2].argument[0]);
2561  mggeo=get_mg_geometrieid(idgeo);
2562  if(mggeo==NULL) mggeo=get_mg_constructionid(idgeo);
2563  mgmai=new MG_MAILLAGE(id,mggeo);
2564  ajouter_mg_maillage(mgmai);
2565  }
2566  if (entite=="MAILLAGE_STRUCTURE")
2567  {
2568  parse.decode(data.c_str(),"@,@,@,@,@,@,@,@,@,@",param+2);
2569  long idgeo=cid(param[2].argument[0]);
2570  mggeo=get_mg_geometrieid(idgeo);
2571  mgmai=new MG_MAILLAGE(id,mggeo);
2572  ajouter_mg_maillage(mgmai);
2573  double xmin=atof(param[3].argument[0].c_str());
2574  double ymin=atof(param[4].argument[0].c_str());
2575  double zmin=atof(param[5].argument[0].c_str());
2576  double xmax=atof(param[6].argument[0].c_str());
2577  double ymax=atof(param[7].argument[0].c_str());
2578  double zmax=atof(param[8].argument[0].c_str());
2579  int nx=atoi(param[9].argument[0].c_str());
2580  int ny=atoi(param[10].argument[0].c_str());
2581  int nz=atoi(param[11].argument[0].c_str());
2582  BOITE_3D b(xmin,ymin,zmin,xmax,ymax,zmax);
2583  mgmai->change_param_structure(b,nx,ny,nz);
2584  }
2585  if (entite=="FEM_MAILLAGE")
2586  {
2587  parse.decode(data.c_str(),"@,@,@",param+2);
2588  int degre=atoi(param[2].argument[0].c_str());
2589  long idmai=cid(param[3].argument[0]);
2590  long idgeo=cid(param[4].argument[0]);
2591  mggeo=get_mg_geometrieid(idgeo);
2592  if (mggeo==NULL) mggeo=get_mg_constructionid(idgeo);
2593  mgmai=get_mg_maillageid(idmai);
2594  femmai=new FEM_MAILLAGE(id,mggeo,mgmai,degre);
2595  ajouter_fem_maillage(femmai);
2596  }
2597  if (entite=="FEM_MAILLAGE_STRUCTURE")
2598  {
2599  parse.decode(data.c_str(),"@,@,@,@,@,@,@,@,@,@,@,@",param+2);
2600  int degre=atoi(param[2].argument[0].c_str());
2601  long idmai=cid(param[3].argument[0]);
2602  long idgeo=cid(param[4].argument[0]);
2603  mggeo=get_mg_geometrieid(idgeo);
2604  mgmai=get_mg_maillageid(idmai);
2605  femmai=new FEM_MAILLAGE(id,mggeo,mgmai,degre);
2606  ajouter_fem_maillage(femmai);
2607  double xmin=atof(param[5].argument[0].c_str());
2608  double ymin=atof(param[6].argument[0].c_str());
2609  double zmin=atof(param[7].argument[0].c_str());
2610  double xmax=atof(param[8].argument[0].c_str());
2611  double ymax=atof(param[9].argument[0].c_str());
2612  double zmax=atof(param[10].argument[0].c_str());
2613  int nx=atoi(param[11].argument[0].c_str());
2614  int ny=atoi(param[12].argument[0].c_str());
2615  int nz=atoi(param[13].argument[0].c_str());
2616  BOITE_3D b(xmin,ymin,zmin,xmax,ymax,zmax);
2617  femmai->change_param_structure(b,nx,ny,nz);
2618  }
2619  if (entite=="NOEUD") lire_NOEUD(id,parse,param,data,mgmai,mggeo);
2620  if (entite=="FEM_NOEUD")
2621  {
2622  parse.decode(data.c_str(),"@,@,@,@,@,@,@",param+2);
2623  long idtopo=cid(param[2].argument[0]);
2624  long idmai=cid(param[3].argument[0]);
2625  double x=atof(param[4].argument[0].c_str());
2626  double y=atof(param[5].argument[0].c_str());
2627  double z=atof(param[6].argument[0].c_str());
2628  int num=atoi(param[7].argument[0].c_str());
2629  int numopt=atoi(param[8].argument[0].c_str());
2630  MG_ELEMENT_MAILLAGE* elmai;
2631  if (idmai>-1)
2632  {
2633  elmai=mgmai->get_mg_noeudid(idmai);
2634  if (elmai==NULL) elmai=mgmai->get_mg_segmentid(idmai);
2635  if (elmai==NULL) elmai=mgmai->get_mg_triangleid(idmai);
2636  if (elmai==NULL) elmai=mgmai->get_mg_tetraid(idmai);
2637  }
2638  else elmai=NULL;
2639  FEM_NOEUD* noeud;
2640  if (elmai!=NULL) noeud=new FEM_NOEUD(id,elmai,x,y,z);
2641  else
2642  {
2643  MG_ELEMENT_TOPOLOGIQUE* topo;
2644  if (idtopo>-1)
2645  {
2646  topo=mggeo->get_mg_sommetid(idtopo);
2647  if (topo==NULL) topo=mggeo->get_mg_areteid(idtopo);
2648  if (topo==NULL) topo=mggeo->get_mg_faceid(idtopo);
2649  if (topo==NULL) topo=mggeo->get_mg_volumeid(idtopo);
2650  }
2651  else topo=NULL;
2652  noeud=new FEM_NOEUD(id,topo,x,y,z);
2653  }
2654  noeud->change_numero(num);
2655  noeud->change_numero_opt(numopt);
2656  femmai->ajouter_fem_noeud(noeud);
2657  }
2658  if (entite=="FEM_NOEUD_DEF")
2659  {
2660  parse.decode(data.c_str(),"@,@,@",param+2);
2661  double x=atof(param[2].argument[0].c_str());
2662  double y=atof(param[3].argument[0].c_str());
2663  double z=atof(param[4].argument[0].c_str());
2664  FEM_NOEUD* noeud=femmai->get_fem_noeudid(id);
2665  noeud->change_dx(x);
2666  noeud->change_dy(y);
2667  noeud->change_dz(z);
2668  femmai->active_deforme();
2669  }
2670  if (entite=="FEM_NOEUD_REAC")
2671  {
2672  parse.decode(data.c_str(),"@,@,@",param+2);
2673  double x=atof(param[2].argument[0].c_str());
2674  double y=atof(param[3].argument[0].c_str());
2675  double z=atof(param[4].argument[0].c_str());
2676  FEM_NOEUD* noeud=femmai->get_fem_noeudid(id);
2677  noeud->change_rx(x);
2678  noeud->change_ry(y);
2679  noeud->change_rz(z);
2680  femmai->active_reaction();;
2681  }
2682  if (entite=="SEGMENT") lire_SEGMENT(id,parse,param,data,mgmai,mggeo);
2683  if (entite=="FEM_ELEMENT_NOEUD")
2684  {
2685  parse.decode(data.c_str(),"@,@,@",param+2);
2686  long idtopo=cid(param[2].argument[0]);
2687  long idmai=cid(param[3].argument[0]);
2688  long idn1=cid(param[4].argument[0]);
2689  FEM_NOEUD* tab[1];
2690  tab[0]=femmai->get_fem_noeudid(idn1);
2691  MG_ELEMENT_TOPOLOGIQUE* topo=NULL;
2692  if (idtopo>-1)
2693  topo=mggeo->get_mg_sommetid(idtopo);
2694  MG_ELEMENT_MAILLAGE* elmai;
2695  if (idmai>-1)
2696  elmai=mgmai->get_mg_noeudid(idmai);
2697  else elmai=NULL;
2698  FEM_ELEMENT0* fem=new FEM_ELEMENT0(id,topo,elmai,tab);
2699  femmai->ajouter_fem_element0(fem);
2700  }
2701  if (entite=="FEM_SEGMENT2")
2702  {
2703  parse.decode(data.c_str(),"@,@,@,@",param+2);
2704  long idtopo=cid(param[2].argument[0]);
2705  long idmai=cid(param[3].argument[0]);
2706  long idn1=cid(param[4].argument[0]);
2707  long idn2=cid(param[5].argument[0]);
2708  FEM_NOEUD* tab[2];
2709  tab[0]=femmai->get_fem_noeudid(idn1);
2710  tab[1]=femmai->get_fem_noeudid(idn2);
2711  MG_ELEMENT_TOPOLOGIQUE* topo=NULL;
2712  if (idtopo>-1)
2713  topo=mggeo->get_mg_areteid(idtopo);
2714  if (topo==NULL) topo=mggeo->get_mg_poutreid(idtopo);
2715  MG_ELEMENT_MAILLAGE* elmai;
2716  if (idmai>-1)
2717  elmai=mgmai->get_mg_segmentid(idmai);
2718  else elmai=NULL;
2719  FEM_SEGMENT2* seg=new FEM_SEGMENT2(id,topo,elmai,tab);
2720  femmai->ajouter_fem_element1(seg);
2721  }
2722  if (entite=="FEM_MINI_SEGMENT2")
2723  {
2724  parse.decode(data.c_str(),"@,@",param+2);
2725  long idn1=cid(param[2].argument[0]);
2726  long idn2=cid(param[3].argument[0]);
2727  FEM_NOEUD* tab[2];
2728  tab[0]=femmai->get_fem_noeudid(idn1);
2729  tab[1]=femmai->get_fem_noeudid(idn2);
2730  MG_SEGMENT* mseg=femmai->get_mg_maillage()->get_mg_segment(tab[0]->get_mg_element_maillage()->get_id(),tab[1]->get_mg_element_maillage()->get_id());
2731  FEM_MINI_SEGMENT2* seg=new FEM_MINI_SEGMENT2(id,mseg,tab);
2732  femmai->ajouter_fem_element1(seg);
2733  }
2734  if (entite=="FEM_SEGMENT3")
2735  {
2736  parse.decode(data.c_str(),"@,@,@,@,@",param+2);
2737  long idtopo=cid(param[2].argument[0]);
2738  long idmai=cid(param[3].argument[0]);
2739  long idn1=cid(param[4].argument[0]);
2740  long idn2=cid(param[5].argument[0]);
2741  long idn3=cid(param[6].argument[0]);
2742  FEM_NOEUD* tab[3];
2743  tab[0]=femmai->get_fem_noeudid(idn1);
2744  tab[1]=femmai->get_fem_noeudid(idn2);
2745  tab[2]=femmai->get_fem_noeudid(idn3);
2746  MG_ELEMENT_MAILLAGE* elmai;
2747  MG_ELEMENT_TOPOLOGIQUE* topo=NULL;
2748  if (idtopo>-1)
2749  topo=mggeo->get_mg_areteid(idtopo);
2750  if (idmai>-1)
2751  elmai=mgmai->get_mg_segmentid(idmai);
2752  else elmai=NULL;
2753  FEM_SEGMENT3* seg=new FEM_SEGMENT3(id,topo,elmai,tab);
2754  femmai->ajouter_fem_element1(seg);
2755  }
2756  if (entite=="TRIANGLE") lire_TRIANGLE(id,parse,param,data,mgmai,mggeo);
2757  if (entite=="QUADRANGLE") lire_QUADRANGLE(id,parse,param,data,mgmai,mggeo);
2758  if (entite=="FEM_TRIANGLE3")
2759  {
2760  parse.decode(data.c_str(),"@,@,@,@,@",param+2);
2761  long idtopo=cid(param[2].argument[0]);
2762  long idmai=cid(param[3].argument[0]);
2763  long idn1=cid(param[4].argument[0]);
2764  long idn2=cid(param[5].argument[0]);
2765  long idn3=cid(param[6].argument[0]);
2766  FEM_NOEUD* tab[3];
2767  tab[0]=femmai->get_fem_noeudid(idn1);
2768  tab[1]=femmai->get_fem_noeudid(idn2);
2769  tab[2]=femmai->get_fem_noeudid(idn3);
2770  MG_ELEMENT_MAILLAGE* elmai;
2771  if (idmai>-1)
2772  elmai=mgmai->get_mg_triangleid(idmai);
2773  else elmai=NULL;
2774  MG_ELEMENT_TOPOLOGIQUE* topo=NULL;
2775  if (idtopo>-1)
2776  topo=mggeo->get_mg_faceid(idtopo);
2777  FEM_TRIANGLE3* tri=new FEM_TRIANGLE3(id,topo,elmai,tab);
2778  femmai->ajouter_fem_element2(tri);
2779  }
2780  if (entite=="FEM_TRIANGLE6")
2781  {
2782  parse.decode(data.c_str(),"@,@,@,@,@,@,@,@",param+2);
2783  long idtopo=cid(param[2].argument[0]);
2784  long idmai=cid(param[3].argument[0]);
2785  long idn1=cid(param[4].argument[0]);
2786  long idn2=cid(param[5].argument[0]);
2787  long idn3=cid(param[6].argument[0]);
2788  long idn4=cid(param[7].argument[0]);
2789  long idn5=cid(param[8].argument[0]);
2790  long idn6=cid(param[9].argument[0]);
2791  FEM_NOEUD* tab[6];
2792  tab[0]=femmai->get_fem_noeudid(idn1);
2793  tab[1]=femmai->get_fem_noeudid(idn2);
2794  tab[2]=femmai->get_fem_noeudid(idn3);
2795  tab[3]=femmai->get_fem_noeudid(idn4);
2796  tab[4]=femmai->get_fem_noeudid(idn5);
2797  tab[5]=femmai->get_fem_noeudid(idn6);
2798  MG_ELEMENT_MAILLAGE* elmai;
2799  if (idmai>-1)
2800  elmai=mgmai->get_mg_triangleid(idmai);
2801  else elmai=NULL;
2802  MG_ELEMENT_TOPOLOGIQUE* topo=NULL;
2803  if (idtopo>-1)
2804  topo=mggeo->get_mg_faceid(idtopo);
2805  FEM_TRIANGLE6* tri=new FEM_TRIANGLE6(id,topo,elmai,tab);
2806  femmai->ajouter_fem_element2(tri);
2807  }
2808  if (entite=="FEM_QUADRANGLE4")
2809  {
2810  parse.decode(data.c_str(),"@,@,@,@,@,@",param+2);
2811  long idtopo=cid(param[2].argument[0]);
2812  long idmai=cid(param[3].argument[0]);
2813  long idn1=cid(param[4].argument[0]);
2814  long idn2=cid(param[5].argument[0]);
2815  long idn3=cid(param[6].argument[0]);
2816  long idn4=cid(param[7].argument[0]);
2817  FEM_NOEUD* tab[4];
2818  tab[0]=femmai->get_fem_noeudid(idn1);
2819  tab[1]=femmai->get_fem_noeudid(idn2);
2820  tab[2]=femmai->get_fem_noeudid(idn3);
2821  tab[3]=femmai->get_fem_noeudid(idn4);
2822  MG_ELEMENT_MAILLAGE* elmai;
2823  if (idmai>-1)
2824  elmai=mgmai->get_mg_quadrangleid(idmai);
2825  else elmai=NULL;
2826  MG_ELEMENT_TOPOLOGIQUE* topo=NULL;
2827  if (idtopo>-1)
2828  topo=mggeo->get_mg_faceid(idtopo);
2829  FEM_QUADRANGLE4* quad=new FEM_QUADRANGLE4(id,topo,elmai,tab);
2830  femmai->ajouter_fem_element2(quad);
2831  }
2832  if (entite=="FEM_QUADRANGLE8")
2833  {
2834  parse.decode(data.c_str(),"@,@,@,@,@,@,@,@,@,@",param+2);
2835  long idtopo=cid(param[2].argument[0]);
2836  long idmai=cid(param[3].argument[0]);
2837  long idn1=cid(param[4].argument[0]);
2838  long idn2=cid(param[5].argument[0]);
2839  long idn3=cid(param[6].argument[0]);
2840  long idn4=cid(param[7].argument[0]);
2841  long idn5=cid(param[8].argument[0]);
2842  long idn6=cid(param[9].argument[0]);
2843  long idn7=cid(param[10].argument[0]);
2844  long idn8=cid(param[11].argument[0]);
2845  FEM_NOEUD* tab[8];
2846  tab[0]=femmai->get_fem_noeudid(idn1);
2847  tab[1]=femmai->get_fem_noeudid(idn2);
2848  tab[2]=femmai->get_fem_noeudid(idn3);
2849  tab[3]=femmai->get_fem_noeudid(idn4);
2850  tab[4]=femmai->get_fem_noeudid(idn5);
2851  tab[5]=femmai->get_fem_noeudid(idn6);
2852  tab[6]=femmai->get_fem_noeudid(idn7);
2853  tab[7]=femmai->get_fem_noeudid(idn8);
2854  MG_ELEMENT_MAILLAGE* elmai;
2855  if (idmai>-1)
2856  elmai=mgmai->get_mg_quadrangleid(idmai);
2857  else elmai=NULL;
2858  MG_ELEMENT_TOPOLOGIQUE* topo=NULL;
2859  if (idtopo>-1)
2860  topo=mggeo->get_mg_faceid(idtopo);
2861  FEM_QUADRANGLE8* quad=new FEM_QUADRANGLE8(id,topo,elmai,tab);
2862  femmai->ajouter_fem_element2(quad);
2863  }
2864  if (entite=="TETRAEDRE") lire_TETRA(id,parse,param,data,mgmai,mggeo);
2865 
2866  if (entite=="HEXAEDRE") lire_HEXA(id,parse,param,data,mgmai,mggeo);
2867  if (entite=="PENTAEDRE") lire_PENTA(id,parse,param,data,mgmai,mggeo);
2868  if (entite=="PYRAMIDE") lire_PYRAMIDE(id,parse,param,data,mgmai,mggeo);
2869  if (entite=="FEM_TETRA4")
2870  {
2871  parse.decode(data.c_str(),"@,@,@,@,@,@,@",param+2);
2872  long idtopo=cid(param[2].argument[0]);
2873  long idmai=cid(param[3].argument[0]);
2874  long idn1=cid(param[4].argument[0]);
2875  long idn2=cid(param[5].argument[0]);
2876  long idn3=cid(param[6].argument[0]);
2877  long idn4=cid(param[7].argument[0]);
2878  long etat=atoi(param[8].argument[0].c_str());
2879  FEM_NOEUD* tab[4];
2880  tab[0]=femmai->get_fem_noeudid(idn1);
2881  tab[1]=femmai->get_fem_noeudid(idn2);
2882  tab[2]=femmai->get_fem_noeudid(idn3);
2883  tab[3]=femmai->get_fem_noeudid(idn4);
2884  MG_ELEMENT_MAILLAGE* elmai;
2885  if (idmai>-1)
2886  elmai=mgmai->get_mg_tetraid(idmai);
2887  else elmai=NULL;
2888  MG_ELEMENT_TOPOLOGIQUE* topo=NULL;
2889  if (idtopo>-1)
2890  topo=mggeo->get_mg_volumeid(idtopo);
2891  FEM_TETRA4* tet=new FEM_TETRA4(id,topo,elmai,tab);
2892  tet->change_etat(0,etat);
2893  femmai->ajouter_fem_element3(tet);
2894  }
2895  if (entite=="XFEM_ELEMENT_NOEUD")
2896  {
2897  parse.decode(data.c_str(),"@,@,@,@",param+2);
2898  unsigned long idele=cid(param[2].argument[0]);
2899  unsigned long idtopo=cid(param[3].argument[0]);
2900  unsigned long idn1=cid(param[4].argument[0]);
2901  int etat=atoi(param[5].argument[0].c_str());
2902  MG_ELEMENT_TOPOLOGIQUE* topo=mggeo->get_mg_sommetid(idtopo);
2903  FEM_ELEMENT_MAILLAGE* mai=femmai->get_fem_element0id(idele);
2904  if (mai==NULL) mai=femmai->get_fem_element1id(idele);
2905  if (mai==NULL) mai=femmai->get_fem_element2id(idele);
2906  if (mai==NULL) mai=femmai->get_fem_element3id(idele);
2907  FEM_NOEUD* tab[4];
2908  tab[0]=femmai->get_fem_noeudid(idn1);
2909  XFEM_ELEMENT0* xele=new XFEM_ELEMENT0(id,mai,topo,tab);
2910  femmai->ajouter_xfem_element0(xele);
2911  xele->change_etat(etat);
2912  }
2913  if (entite=="XFEM_SEGMENT2")
2914  {
2915  parse.decode(data.c_str(),"@,@,@,@,@",param+2);
2916  unsigned long idele=cid(param[2].argument[0]);
2917  unsigned long idtopo=cid(param[3].argument[0]);
2918  unsigned long idn1=cid(param[4].argument[0]);
2919  unsigned long idn2=cid(param[5].argument[0]);
2920  int etat=atoi(param[6].argument[0].c_str());
2921  FEM_ELEMENT_MAILLAGE* mai=femmai->get_fem_element1id(idele);
2922  if (mai==NULL) mai=femmai->get_fem_element2id(idele);
2923  if (mai==NULL) mai=femmai->get_fem_element3id(idele);
2924  MG_ELEMENT_TOPOLOGIQUE* topo=mggeo->get_mg_areteid(idtopo);
2925  FEM_NOEUD* tab[4];
2926  tab[0]=femmai->get_fem_noeudid(idn1);
2927  tab[1]=femmai->get_fem_noeudid(idn2);
2928  XFEM_SEGMENT2* xseg=new XFEM_SEGMENT2(id,mai,topo,tab);
2929  femmai->ajouter_xfem_element1(xseg);
2930  xseg->change_etat(etat);
2931  }
2932  if (entite=="XFEM_TRIANGLE3")
2933  {
2934  parse.decode(data.c_str(),"@,@,@,@,@,@",param+2);
2935  unsigned long idtet=cid(param[2].argument[0]);
2936  unsigned long idtopo=cid(param[3].argument[0]);
2937  unsigned long idn1=cid(param[4].argument[0]);
2938  unsigned long idn2=cid(param[5].argument[0]);
2939  unsigned long idn3=cid(param[6].argument[0]);
2940  int etat=atoi(param[7].argument[0].c_str());
2941  FEM_ELEMENT_MAILLAGE* mai=femmai->get_fem_element3id(idtet);
2942  MG_ELEMENT_TOPOLOGIQUE* topo=mggeo->get_mg_volumeid(idtopo);
2943  FEM_NOEUD* tab[3];
2944  tab[0]=femmai->get_fem_noeudid(idn1);
2945  tab[1]=femmai->get_fem_noeudid(idn2);
2946  tab[2]=femmai->get_fem_noeudid(idn3);
2947  XFEM_TRIANGLE3* xtri=new XFEM_TRIANGLE3(id,mai,topo,tab);
2948  femmai->ajouter_xfem_element2(xtri);
2949  xtri->change_etat(etat);
2950  }
2951  if (entite=="XFEM_TETRA4")
2952  {
2953  parse.decode(data.c_str(),"@,@,@,@,@,@,@",param+2);
2954  unsigned long idtet=cid(param[2].argument[0]);
2955  unsigned long idtopo=cid(param[3].argument[0]);
2956  unsigned long idn1=cid(param[4].argument[0]);
2957  unsigned long idn2=cid(param[5].argument[0]);
2958  unsigned long idn3=cid(param[6].argument[0]);
2959  unsigned long idn4=cid(param[7].argument[0]);
2960  int etat=atoi(param[8].argument[0].c_str());
2961  FEM_ELEMENT_MAILLAGE* mai=femmai->get_fem_element3id(idtet);
2962  MG_ELEMENT_TOPOLOGIQUE* topo=mggeo->get_mg_volumeid(idtopo);
2963  FEM_NOEUD* tab[4];
2964  tab[0]=femmai->get_fem_noeudid(idn1);
2965  tab[1]=femmai->get_fem_noeudid(idn2);
2966  tab[2]=femmai->get_fem_noeudid(idn3);
2967  tab[3]=femmai->get_fem_noeudid(idn4);
2968  XFEM_TETRA4* xtet=new XFEM_TETRA4(id,mai,topo,tab);
2969  femmai->ajouter_xfem_element3(xtet);
2970  xtet->change_etat(etat);
2971  }
2972  if (entite=="FEM_TETRA10")
2973  {
2974  parse.decode(data.c_str(),"@,@,@,@,@,@,@,@,@,@,@,@",param+2);
2975  long idtopo=cid(param[2].argument[0]);
2976  long idmai=cid(param[3].argument[0]);
2977  long idn1=cid(param[4].argument[0]);
2978  long idn2=cid(param[5].argument[0]);
2979  long idn3=cid(param[6].argument[0]);
2980  long idn4=cid(param[7].argument[0]);
2981  long idn5=cid(param[8].argument[0]);
2982  long idn6=cid(param[9].argument[0]);
2983  long idn7=cid(param[10].argument[0]);
2984  long idn8=cid(param[11].argument[0]);
2985  long idn9=cid(param[12].argument[0]);
2986  long idn10=cid(param[13].argument[0]);
2987  FEM_NOEUD* tab[10];
2988  tab[0]=femmai->get_fem_noeudid(idn1);
2989  tab[1]=femmai->get_fem_noeudid(idn2);
2990  tab[2]=femmai->get_fem_noeudid(idn3);
2991  tab[3]=femmai->get_fem_noeudid(idn4);
2992  tab[4]=femmai->get_fem_noeudid(idn5);
2993  tab[5]=femmai->get_fem_noeudid(idn6);
2994  tab[6]=femmai->get_fem_noeudid(idn7);
2995  tab[7]=femmai->get_fem_noeudid(idn8);
2996  tab[8]=femmai->get_fem_noeudid(idn9);
2997  tab[9]=femmai->get_fem_noeudid(idn10);
2998  MG_ELEMENT_MAILLAGE* elmai;
2999  if (idmai>-1)
3000  elmai=mgmai->get_mg_tetraid(idmai);
3001  else elmai=NULL;
3002  MG_ELEMENT_TOPOLOGIQUE* topo=NULL;
3003  if (idtopo>-1)
3004  topo=mggeo->get_mg_volumeid(idtopo);
3005  FEM_TETRA10* tet=new FEM_TETRA10(id,topo,elmai,tab);
3006  femmai->ajouter_fem_element3(tet);
3007  }
3008  if (entite=="FEM_HEXA8")
3009  {
3010  parse.decode(data.c_str(),"@,@,@,@,@,@,@,@,@,@",param+2);
3011  long idtopo=cid(param[2].argument[0]);
3012  long idmai=cid(param[3].argument[0]);
3013  long idn1=cid(param[4].argument[0]);
3014  long idn2=cid(param[5].argument[0]);
3015  long idn3=cid(param[6].argument[0]);
3016  long idn4=cid(param[7].argument[0]);
3017  long idn5=cid(param[8].argument[0]);
3018  long idn6=cid(param[9].argument[0]);
3019  long idn7=cid(param[10].argument[0]);
3020  long idn8=cid(param[11].argument[0]);
3021  FEM_NOEUD* tab[8];
3022  tab[0]=femmai->get_fem_noeudid(idn1);
3023  tab[1]=femmai->get_fem_noeudid(idn2);
3024  tab[2]=femmai->get_fem_noeudid(idn3);
3025  tab[3]=femmai->get_fem_noeudid(idn4);
3026  tab[4]=femmai->get_fem_noeudid(idn5);
3027  tab[5]=femmai->get_fem_noeudid(idn6);
3028  tab[6]=femmai->get_fem_noeudid(idn7);
3029  tab[7]=femmai->get_fem_noeudid(idn8);
3030  MG_ELEMENT_MAILLAGE* elmai;
3031  if (idmai>-1)
3032  elmai=mgmai->get_mg_hexaid(idmai);
3033  else elmai=NULL;
3034  MG_ELEMENT_TOPOLOGIQUE* topo=NULL;
3035  if (idtopo>-1)
3036  topo=mggeo->get_mg_volumeid(idtopo);
3037  FEM_HEXA8* hex=new FEM_HEXA8(id,topo,elmai,tab);
3038  femmai->ajouter_fem_element3(hex);
3039  }
3040  if (entite=="FEM_HEXA20")
3041  {
3042  parse.decode(data.c_str(),"@,@,@,@,@,@,@,@,@,@,@,@,@,@,@,@,@,@,@,@,@,@",param+2);
3043  long idtopo=cid(param[2].argument[0]);
3044  long idmai=cid(param[3].argument[0]);
3045  long idn1=cid(param[4].argument[0]);
3046  long idn2=cid(param[5].argument[0]);
3047  long idn3=cid(param[6].argument[0]);
3048  long idn4=cid(param[7].argument[0]);
3049  long idn5=cid(param[8].argument[0]);
3050  long idn6=cid(param[9].argument[0]);
3051  long idn7=cid(param[10].argument[0]);
3052  long idn8=cid(param[11].argument[0]);
3053  long idn9=cid(param[12].argument[0]);
3054  long idn10=cid(param[13].argument[0]);
3055  long idn11=cid(param[14].argument[0]);
3056  long idn12=cid(param[15].argument[0]);
3057  long idn13=cid(param[16].argument[0]);
3058  long idn14=cid(param[17].argument[0]);
3059  long idn15=cid(param[18].argument[0]);
3060  long idn16=cid(param[19].argument[0]);
3061  long idn17=cid(param[20].argument[0]);
3062  long idn18=cid(param[21].argument[0]);
3063  long idn19=cid(param[22].argument[0]);
3064  long idn20=cid(param[23].argument[0]);
3065  FEM_NOEUD* tab[20];
3066  tab[0]=femmai->get_fem_noeudid(idn1);
3067  tab[1]=femmai->get_fem_noeudid(idn2);
3068  tab[2]=femmai->get_fem_noeudid(idn3);
3069  tab[3]=femmai->get_fem_noeudid(idn4);
3070  tab[4]=femmai->get_fem_noeudid(idn5);
3071  tab[5]=femmai->get_fem_noeudid(idn6);
3072  tab[6]=femmai->get_fem_noeudid(idn7);
3073  tab[7]=femmai->get_fem_noeudid(idn8);
3074  tab[8]=femmai->get_fem_noeudid(idn9);
3075  tab[9]=femmai->get_fem_noeudid(idn10);
3076  tab[10]=femmai->get_fem_noeudid(idn11);
3077  tab[11]=femmai->get_fem_noeudid(idn12);
3078  tab[12]=femmai->get_fem_noeudid(idn13);
3079  tab[13]=femmai->get_fem_noeudid(idn14);
3080  tab[14]=femmai->get_fem_noeudid(idn15);
3081  tab[15]=femmai->get_fem_noeudid(idn16);
3082  tab[16]=femmai->get_fem_noeudid(idn17);
3083  tab[17]=femmai->get_fem_noeudid(idn18);
3084  tab[18]=femmai->get_fem_noeudid(idn19);
3085  tab[19]=femmai->get_fem_noeudid(idn20);
3086  MG_ELEMENT_MAILLAGE* elmai;
3087  if (idmai>-1)
3088  elmai=mgmai->get_mg_hexaid(idmai);
3089  else elmai=NULL;
3090  MG_ELEMENT_TOPOLOGIQUE* topo=NULL;
3091  if (idtopo>-1)
3092  topo=mggeo->get_mg_volumeid(idtopo);
3093  FEM_HEXA20* hex=new FEM_HEXA20(id,topo,elmai,tab);
3094  femmai->ajouter_fem_element3(hex);
3095  }
3096  if (entite=="FEM_PENTA6")
3097  {
3098  parse.decode(data.c_str(),"@,@,@,@,@,@,@,@",param+2);
3099  long idtopo=cid(param[2].argument[0]);
3100  long idmai=cid(param[3].argument[0]);
3101  long idn1=cid(param[4].argument[0]);
3102  long idn2=cid(param[5].argument[0]);
3103  long idn3=cid(param[6].argument[0]);
3104  long idn4=cid(param[7].argument[0]);
3105  long idn5=cid(param[8].argument[0]);
3106  long idn6=cid(param[9].argument[0]);
3107  FEM_NOEUD* tab[6];
3108  tab[0]=femmai->get_fem_noeudid(idn1);
3109  tab[1]=femmai->get_fem_noeudid(idn2);
3110  tab[2]=femmai->get_fem_noeudid(idn3);
3111  tab[3]=femmai->get_fem_noeudid(idn4);
3112  tab[4]=femmai->get_fem_noeudid(idn5);
3113  tab[5]=femmai->get_fem_noeudid(idn6);
3114  MG_ELEMENT_MAILLAGE* elmai;
3115  if (idmai>-1)
3116  elmai=mgmai->get_mg_pentaid(idmai);
3117  else elmai=NULL;
3118  MG_ELEMENT_TOPOLOGIQUE* topo=NULL;
3119  if (idtopo>-1)
3120  topo=mggeo->get_mg_volumeid(idtopo);
3121  FEM_PENTA6* pen=new FEM_PENTA6(id,topo,elmai,tab);
3122  femmai->ajouter_fem_element3(pen);
3123  }
3124  if (entite=="FEM_PENTA15")
3125  {
3126  parse.decode(data.c_str(),"@,@,@,@,@,@,@,@,@,@,@,@,@,@,@,@,@",param+2);
3127  long idtopo=cid(param[2].argument[0]);
3128  long idmai=cid(param[3].argument[0]);
3129  long idn1=cid(param[4].argument[0]);
3130  long idn2=cid(param[5].argument[0]);
3131  long idn3=cid(param[6].argument[0]);
3132  long idn4=cid(param[7].argument[0]);
3133  long idn5=cid(param[8].argument[0]);
3134  long idn6=cid(param[9].argument[0]);
3135  long idn7=cid(param[10].argument[0]);
3136  long idn8=cid(param[11].argument[0]);
3137  long idn9=cid(param[12].argument[0]);
3138  long idn10=cid(param[13].argument[0]);
3139  long idn11=cid(param[14].argument[0]);
3140  long idn12=cid(param[15].argument[0]);
3141  long idn13=cid(param[16].argument[0]);
3142  long idn14=cid(param[17].argument[0]);
3143  long idn15=cid(param[18].argument[0]);
3144  FEM_NOEUD* tab[15];
3145  tab[0]=femmai->get_fem_noeudid(idn1);
3146  tab[1]=femmai->get_fem_noeudid(idn2);
3147  tab[2]=femmai->get_fem_noeudid(idn3);
3148  tab[3]=femmai->get_fem_noeudid(idn4);
3149  tab[4]=femmai->get_fem_noeudid(idn5);
3150  tab[5]=femmai->get_fem_noeudid(idn6);
3151  tab[6]=femmai->get_fem_noeudid(idn7);
3152  tab[7]=femmai->get_fem_noeudid(idn8);
3153  tab[8]=femmai->get_fem_noeudid(idn9);
3154  tab[9]=femmai->get_fem_noeudid(idn10);
3155  tab[10]=femmai->get_fem_noeudid(idn11);
3156  tab[11]=femmai->get_fem_noeudid(idn12);
3157  tab[12]=femmai->get_fem_noeudid(idn13);
3158  tab[13]=femmai->get_fem_noeudid(idn14);
3159  tab[14]=femmai->get_fem_noeudid(idn15);
3160  MG_ELEMENT_MAILLAGE* elmai;
3161  if (idmai>-1)
3162  elmai=mgmai->get_mg_pentaid(idmai);
3163  else elmai=NULL;
3164  MG_ELEMENT_TOPOLOGIQUE* topo=NULL;
3165  if (idtopo>-1)
3166  topo=mggeo->get_mg_volumeid(idtopo);
3167  FEM_PENTA15* pen=new FEM_PENTA15(id,topo,elmai,tab);
3168  femmai->ajouter_fem_element3(pen);
3169  }
3170  if (entite=="SOLUTION")
3171  {
3172  parse.decode(data.c_str(),"@,@,@,@,@,@,(&)",param+2);
3173  int typeentite=atoi(param[2].argument[0].c_str());
3174  int typesolution=atoi(param[3].argument[0].c_str());
3175  std::string nomsol=param[4].argument[0];
3176  long idmai=cid(param[5].argument[0]);
3177  int nb=atoi(param[6].argument[0].c_str());
3178  std::string chemin=param[7].argument[0];
3179  MG_MAILLAGE* mai=get_mg_maillageid(idmai);
3180  MG_SOLUTION* sol=new MG_SOLUTION(id,mai,nb,(char*)chemin.c_str(),SOL_EXISTANTE,nomsol,typeentite,typesolution);
3181  ajouter_mg_solution(sol);
3182  for (int i=0;i<nb;i++)
3183  sol->change_legende(i,param[8].argument[i]);
3184  }
3185  if (entite=="FEM_SOLUTION")
3186  {
3187  parse.decode(data.c_str(),"@,@,@,@,@,@,(&)",param+2);
3188  int typeentite=atoi(param[2].argument[0].c_str());
3189  int typesolution=atoi(param[3].argument[0].c_str());
3190  std::string nomsol=param[4].argument[0];
3191  long idmai=cid(param[5].argument[0]);
3192  int nb=atoi(param[6].argument[0].c_str());
3193  std::string chemin_sol=param[7].argument[0];
3194  FEM_MAILLAGE* mai=get_fem_maillageid(idmai);
3195  FEM_SOLUTION* sol=new FEM_SOLUTION(id,mai,nb,(char*)chemin_sol.c_str(),SOL_EXISTANTE,nomsol,typeentite,typesolution);
3196  ajouter_fem_solution(sol);
3197  for (int i=0;i<nb;i++)
3198  sol->change_legende(i,param[8].argument[i]);
3199  }
3200 #ifdef WINDOWS_VERSION
3201  if (entite=="CAD4FE_MCSEGMENT")
3202  {
3203  parse.decode(data.c_str(),"@,@,@",param+2);
3204  long idtopo=cid(param[2].argument[0]);
3205  long idn1=cid(param[3].argument[0]);
3206  long idn2=cid(param[4].argument[0]);
3207  CAD4FE::MCNode* noeud1=(CAD4FE::MCNode*)mgmai->get_mg_noeudid(idn1);
3208  CAD4FE::MCNode* noeud2=(CAD4FE::MCNode*)mgmai->get_mg_noeudid(idn2);
3209  MG_ELEMENT_TOPOLOGIQUE* topo;
3210  if (idtopo>-1)
3211  {
3212  topo=mggeo->get_mg_areteid(idtopo);
3213  if (topo==NULL) topo=mggeo->get_mg_faceid(idtopo);
3214  if (topo==NULL) topo=mggeo->get_mg_volumeid(idtopo);
3215  }
3216  else topo=NULL;
3217  CAD4FE::MCSegment * seg = new CAD4FE::MCSegment(id,topo,noeud1,noeud2);
3218  mgmai->ajouter_mg_segment(seg);
3219  }
3220  if (entite=="CAD4FE_MCNODE")
3221  {
3222  parse.decode(data.c_str(),"@,@,@,@,@",param+2);
3223  long idRefTopo=cid(param[2].argument[0]);
3224  long idMCTopo=cid(param[3].argument[0]);
3225  double x=atof(param[4].argument[0].c_str());
3226  double y=atof(param[5].argument[0].c_str());
3227  double z=atof(param[6].argument[0].c_str());
3228  MG_ELEMENT_TOPOLOGIQUE* refTopo=NULL;
3229  if (refTopo==NULL) refTopo=mggeo->get_mg_sommetid(idRefTopo);
3230  if (refTopo==NULL) refTopo=mggeo->get_mg_areteid(idRefTopo);
3231  if (refTopo==NULL) refTopo=mggeo->get_mg_faceid(idRefTopo);
3232  if (refTopo==NULL) refTopo=mggeo->get_mg_volumeid(idRefTopo);
3233  MG_ELEMENT_TOPOLOGIQUE* mcTopo=NULL;
3234  if (mcTopo==NULL) mcTopo=mggeo->get_mg_sommetid(idMCTopo);
3235  if (mcTopo==NULL) mcTopo=mggeo->get_mg_areteid(idMCTopo);
3236  if (mcTopo==NULL) mcTopo=mggeo->get_mg_faceid(idMCTopo);
3237  if (mcTopo==NULL) mcTopo=mggeo->get_mg_volumeid(idMCTopo);
3238 
3239  if (mcTopo->get_dimension()==0)
3240  {
3241  if (updatedMergedRefVertices == false)
3242  {
3243  for (std::multimap<CAD4FE::MCVertex * , unsigned long>::iterator itMergedRefVertices = mapMergedRefVertices.begin();
3244  itMergedRefVertices != mapMergedRefVertices.end();
3245  itMergedRefVertices++)
3246  {
3247  CAD4FE::MCVertex * v = itMergedRefVertices->first;
3248  MG_SOMMET * refV = NULL;
3249  unsigned long id = itMergedRefVertices->second;
3250  refV = (MG_SOMMET *) mggeo->get_mg_sommetid(id);
3251  v->MergeRefVertex(refV);
3252  }
3253 
3254  updatedMergedRefVertices = true;
3255  }
3256  }
3257 
3258  CAD4FE::MCNode* noeud=new CAD4FE::MCNode(id,mcTopo,refTopo,x,y,z);
3259  mgmai->ajouter_mg_noeud(noeud);
3260  }
3261  if (entite=="CAD4FE_MCTRIANGLE")
3262  {
3263  parse.decode(data.c_str(),"@,@,@,@",param+2);
3264  long idtopo=cid(param[2].argument[0]);
3265  long idn1=cid(param[3].argument[0]);
3266  long idn2=cid(param[4].argument[0]);
3267  long idn3=cid(param[5].argument[0]);
3268  CAD4FE::MCNode* noeud1=(CAD4FE::MCNode*)mgmai->get_mg_noeudid(idn1);
3269  CAD4FE::MCNode* noeud2=(CAD4FE::MCNode*)mgmai->get_mg_noeudid(idn2);
3270  CAD4FE::MCNode* noeud3=(CAD4FE::MCNode*)mgmai->get_mg_noeudid(idn3);
3271  CAD4FE::MCSegment* mgsegment[3];
3272  CAD4FE::MCNode *mgnoeud[3]={noeud1,noeud2,noeud3};
3273  // la topo. d'un MCTriangle est obligatoirement une MCFace
3274  CAD4FE::MCFace* mcFace=(CAD4FE::MCFace*)mggeo->get_mg_faceid(idtopo);
3275  for (int i=0;i<3;i++)
3276  {
3277  mgsegment[i]=(CAD4FE::MCSegment*)mgmai->get_mg_segment(mgnoeud[i]->get_id(),mgnoeud[(i+1)%3]->get_id());
3278  if (mgsegment[i]==NULL)
3279  {
3280  mgsegment[i]=new CAD4FE::MCSegment(mcFace,mgnoeud[i],mgnoeud[(i+1)%3]);
3281  mgmai->ajouter_mg_segment(mgsegment[i]);
3282  }
3283  }
3284  CAD4FE::M3D_MCTriangle *triangle = new CAD4FE::M3D_MCTriangle(id,mcFace,noeud1,noeud2,noeud3,mgsegment[0],mgsegment[1],mgsegment[2]);
3285  mgmai->ajouter_mg_triangle(triangle);
3286  }
3287 #endif
3288  }
3289  }
3290  while (param[0].argument[0]!="FIN");
3291 
3292  for (int i=0;i<volumemince.size();i=i+3)
3293  {
3294  MG_VOLUME *vol=mggeo->get_mg_volumeid(volumemince[i]);
3295  MG_FACE* face1=mggeo->get_mg_faceid(volumemince[i+1]);
3296  MG_FACE* face2=mggeo->get_mg_faceid(volumemince[i+2]);
3297  vol->ajouter_face_correspondante(face1,face2);
3298  }
3299 
3300 
3301  LISTE_MG_ARBRE::iterator itarbre;
3302  for (MG_ARBRE* arb=get_premier_arbre(itarbre);arb!=NULL;arb=get_suivant_arbre(itarbre))
3303  {
3304  LISTE_MG_ASSEMBLAGE::iterator itass;
3305  for (MG_ASSEMBLAGE *ass=arb->get_premier_assemblage(itass);ass!=NULL;ass=arb->get_suivant_assemblage(itass))
3306  ass->ini_donne(arb);
3307  }
3308  TPL_MAP_ENTITE<MG_GEOMETRIE*> lst;
3309  LISTE_MG_GEOMETRIE::iterator itgeo;
3310  for (MG_GEOMETRIE* geo=get_premier_geometrie(itgeo);geo;geo=get_suivant_geometrie(itgeo))
3311  lst.ajouter(geo);
3312  LISTE_MG_CONSTRUCTION::iterator itcon;
3313  for (MG_GEOMETRIE* geo=get_premier_construction(itcon);geo;geo=get_suivant_construction(itcon))
3314  lst.ajouter(geo);
3315  TPL_MAP_ENTITE<MG_GEOMETRIE*>::ITERATEUR it;
3316  for (MG_GEOMETRIE* geo=lst.get_premier(it);geo;geo=lst.get_suivant(it))
3317  {
3318  LISTE_MG_SOMMET::iterator itsom;
3319  for (MG_SOMMET* som=geo->get_premier_sommet(itsom);som;som=geo->get_suivant_sommet(itsom))
3320  if (som->est_une_topo_element())
3321  {
3322  MG_SOMMET_NOEUD* somno=(MG_SOMMET_NOEUD*)som;
3323  unsigned long idnoeud=somno->get_id_mg_noeud();
3324  MG_NOEUD* noeud;
3325  LISTE_MG_MAILLAGE::iterator itmai;
3326  for (MG_MAILLAGE* mai=get_premier_mg_maillage(itmai);mai;mai=get_suivant_mg_maillage(itmai))
3327  if (mai->get_mg_noeudid(idnoeud)!=NULL) noeud=mai->get_mg_noeudid(idnoeud);
3328  somno->change_mg_noeud(noeud);
3329  }
3330  LISTE_MG_COQUE::iterator itcoq;
3331  for (MG_COQUE* coq=geo->get_premier_coque(itcoq);coq;coq=geo->get_suivant_coque(itcoq))
3332  if (coq->est_une_topo_element())
3333  {
3334  MG_COQUE_ELEMENT* coque=(MG_COQUE_ELEMENT*)coq;
3335  int nbele=coque->get_nb_liste_id();
3336  MG_MAILLAGE* mgmai=NULL;
3337  for (int i=0;i<nbele;i++)
3338  {
3339  unsigned long eleid=coque->get_liste_id(i);
3340  if (i==0)
3341  {
3342  LISTE_MG_MAILLAGE::iterator itmai;
3343  for (MG_MAILLAGE* mai=get_premier_mg_maillage(itmai);mai;mai=get_suivant_mg_maillage(itmai))
3344  {
3345  if (mai->get_mg_triangleid(eleid)!=NULL) mgmai=mai;
3346  if (mai->get_mg_quadrangleid(eleid)!=NULL) mgmai=mai;
3347  }
3348  }
3349  MG_ELEMENT_MAILLAGE* ele=NULL;
3350  if (ele==NULL) ele=mgmai->get_mg_triangleid(eleid);
3351  if (ele==NULL) ele=mgmai->get_mg_quadrangleid(eleid);
3352  coque->ajouter_element(ele);
3353  }
3354 
3355  }
3356  LISTE_MG_POUTRE::iterator itpou;
3357  for (MG_POUTRE* pou=geo->get_premier_poutre(itpou);pou;pou=geo->get_suivant_poutre(itpou))
3358  if (pou->est_une_topo_element())
3359  {
3360  MG_POUTRE_ELEMENT* poutre=(MG_POUTRE_ELEMENT*)pou;
3361  int nbele=poutre->get_nb_liste_id();
3362  MG_MAILLAGE* mgmai=NULL;
3363  for (int i=0;i<nbele;i++)
3364  {
3365  unsigned long eleid=poutre->get_liste_id(i);
3366  if (i==0)
3367  {
3368  LISTE_MG_MAILLAGE::iterator itmai;
3369  for (MG_MAILLAGE* mai=get_premier_mg_maillage(itmai);mai;mai=get_suivant_mg_maillage(itmai))
3370  {
3371  if (mai->get_mg_segmentid(eleid)!=NULL) mgmai=mai;
3372  }
3373  }
3374  MG_ELEMENT_MAILLAGE* ele=NULL;
3375  if (ele==NULL) ele=mgmai->get_mg_segmentid(eleid);
3376  poutre->ajouter_element(ele);
3377  }
3378 
3379  }
3380  }
3381 #ifdef WINDOWS_VERSION
3382  if (updatedMergedRefVertices == false)
3383  {
3384  for (std::multimap<CAD4FE::MCVertex * , unsigned long>::iterator itMergedRefVertices = mapMergedRefVertices.begin();
3385  itMergedRefVertices != mapMergedRefVertices.end();
3386  itMergedRefVertices++)
3387  {
3388  CAD4FE::MCVertex * v = itMergedRefVertices->first;
3389  MG_SOMMET * refV = NULL;
3390  unsigned long id = itMergedRefVertices->second;
3391  refV = (MG_SOMMET *) mggeo->get_mg_sommetid(id);
3392  v->MergeRefVertex(refV);
3393  }
3394 
3395  updatedMergedRefVertices = true;
3396  }
3397 
3398 #endif
3399  fclose(in);
3400  return 1;
3401 }
3402 
3403 
3404 
3405 
CAD4FE_MCEdge.h
CAD4FE_MCFace.h
CAD4FE_MCNode.h
CAD4FE_MCSegment.h
CAD4FE_MCTriangle.h
CAD4FE_MCVertex.h
CAD4FE_PolyCurve.h
CAD4FE_PolySurface.h
CAD4FE_m3d_MCTriangle.h
acis_courbe.h
acis_point.h
acis_surface.h
ACIS_COURBE
Definition: acis_courbe.h:35
ACIS_POINT
Definition: acis_point.h:33
ACIS_SURFACE
Definition: acis_surface.h:34
BOITE_3D
Definition: ot_boite_3d.h:28
CAD4FE::M3D_MCTriangle
Definition: CAD4FE_m3d_MCTriangle.h:41
CAD4FE::MCVertex::MergeRefVertex
void MergeRefVertex(MG_SOMMET *)
Definition: CAD4FE_MCVertex.cpp:82
CAD4FE::MCVertex::GetMergedRefVertices
std::map< unsigned long, MG_SOMMET * > & GetMergedRefVertices()
Definition: CAD4FE_MCVertex.cpp:94
CAD4FE::PolyCurve::Merge
void Merge(PolyCurve &)
Definition: CAD4FE_PolyCurve.cpp:605
CAD4FE::PolySurface::Merge
void Merge(PolySurface &)
Definition: CAD4FE_PolySurface.cpp:62
FEM_ELEMENT0
Definition: fem_element0.h:37
FEM_ELEMENT_MAILLAGE
Definition: fem_element_maillage.h:36
FEM_ELEMENT_MAILLAGE::change_etat
virtual void change_etat(int num, int val)
Definition: fem_element_maillage.cpp:124
FEM_HEXA20
Definition: fem_hexa20.h:36
FEM_HEXA8
Definition: fem_hexa8.h:36
FEM_MAILLAGE
Definition: fem_maillage.h:67
FEM_MAILLAGE::get_fem_element0id
FEM_ELEMENT0 * get_fem_element0id(unsigned long num)
Definition: fem_maillage.cpp:261
FEM_MAILLAGE::change_param_structure
void change_param_structure(BOITE_3D btmp, int nxtmp, int nytmp, int nztmp)
Definition: fem_maillage.cpp:1797
FEM_MAILLAGE::ajouter_xfem_element2
int ajouter_xfem_element2(XFEM_ELEMENT2 *femelement2)
Definition: fem_maillage.cpp:913
FEM_MAILLAGE::get_fem_noeudid
FEM_NOEUD * get_fem_noeudid(unsigned long num)
Definition: fem_maillage.cpp:150
FEM_MAILLAGE::get_fem_element2id
FEM_ELEMENT2 * get_fem_element2id(unsigned long num)
Definition: fem_maillage.cpp:484
FEM_MAILLAGE::get_mg_maillage
MG_MAILLAGE * get_mg_maillage(void)
Definition: fem_maillage.cpp:93
FEM_MAILLAGE::ajouter_xfem_element3
int ajouter_xfem_element3(XFEM_ELEMENT3 *femelement3)
Definition: fem_maillage.cpp:1025
FEM_MAILLAGE::ajouter_xfem_element1
int ajouter_xfem_element1(XFEM_ELEMENT1 *femelement1)
Definition: fem_maillage.cpp:801
FEM_MAILLAGE::ajouter_fem_noeud
FEM_NOEUD * ajouter_fem_noeud(MG_NOEUD *mgnoeud, unsigned long num=0)
Definition: fem_maillage.cpp:120
FEM_MAILLAGE::active_reaction
void active_reaction(void)
Definition: fem_maillage.cpp:1731
FEM_MAILLAGE::ajouter_xfem_element0
int ajouter_xfem_element0(XFEM_ELEMENT0 *femelement0)
Definition: fem_maillage.cpp:690
FEM_MAILLAGE::active_deforme
void active_deforme(void)
Definition: fem_maillage.cpp:1716
FEM_MAILLAGE::ajouter_fem_element3
int ajouter_fem_element3(FEM_ELEMENT3 *femelement3)
Definition: fem_maillage.cpp:580
FEM_MAILLAGE::ajouter_fem_element1
int ajouter_fem_element1(FEM_ELEMENT1 *femsegment)
Definition: fem_maillage.cpp:357
FEM_MAILLAGE::get_fem_element3id
FEM_ELEMENT3 * get_fem_element3id(unsigned long num)
Definition: fem_maillage.cpp:595
FEM_MAILLAGE::ajouter_fem_element2
int ajouter_fem_element2(FEM_ELEMENT2 *femtriangle)
Definition: fem_maillage.cpp:469
FEM_MAILLAGE::get_fem_element1id
FEM_ELEMENT1 * get_fem_element1id(unsigned long num)
Definition: fem_maillage.cpp:372
FEM_MAILLAGE::ajouter_fem_element0
int ajouter_fem_element0(FEM_ELEMENT0 *femnoeud)
Definition: fem_maillage.cpp:246
FEM_MINI_SEGMENT2
Definition: fem_mini_segment2.h:32
FEM_NOEUD
Definition: fem_noeud.h:36
FEM_NOEUD::change_numero_opt
void change_numero_opt(int num)
Definition: fem_noeud.cpp:343
FEM_NOEUD::change_numero
void change_numero(int num)
Definition: fem_noeud.cpp:333
FEM_NOEUD::change_ry
virtual void change_ry(double yy)
Definition: fem_noeud.cpp:289
FEM_NOEUD::change_rx
virtual void change_rx(double xx)
Definition: fem_noeud.cpp:283
FEM_NOEUD::change_dy
virtual void change_dy(double yy)
Definition: fem_noeud.cpp:308
FEM_NOEUD::change_dz
virtual void change_dz(double zz)
Definition: fem_noeud.cpp:314
FEM_NOEUD::change_rz
virtual void change_rz(double zz)
Definition: fem_noeud.cpp:295
FEM_NOEUD::change_dx
virtual void change_dx(double xx)
Definition: fem_noeud.cpp:302
FEM_PENTA15
Definition: fem_penta15.h:36
FEM_PENTA6
Definition: fem_penta6.h:35
FEM_QUADRANGLE4
Definition: fem_quadrangle4.h:35
FEM_QUADRANGLE8
Definition: fem_quadrangle8.h:36
FEM_SEGMENT2
Definition: fem_segment2.h:34
FEM_SEGMENT3
Definition: fem_segment3.h:33
FEM_SOLUTION
Definition: fem_solution.h:41
FEM_SOLUTION::change_legende
void change_legende(int num, std::string val)
Definition: fem_solution.cpp:457
FEM_TETRA10
Definition: fem_tetra10.h:35
FEM_TETRA4
Definition: fem_tetra4.h:35
FEM_TRIANGLE3
Definition: fem_triangle3.h:35
FEM_TRIANGLE6
Definition: fem_triangle6.h:34
LC_POINT
Definition: lc_point.h:31
MG_ARETE_ELEMENT
Definition: mg_arete_element.h:33
MG_ARETE
Definition: mg_arete.h:37
MG_ARETE::changer_cosommet1
virtual void changer_cosommet1(class MG_COSOMMET *cosom)
Definition: mg_arete.cpp:73
MG_ARETE::changer_cosommet2
virtual void changer_cosommet2(class MG_COSOMMET *cosom)
Definition: mg_arete.cpp:77
MG_BOUCLE
Definition: mg_boucle.h:36
MG_BOUCLE::ajouter_mg_coarete
virtual void ajouter_mg_coarete(class MG_COARETE *mgcoarete)
Definition: mg_boucle.cpp:73
MG_CG_ASSEMBLAGE
Definition: mg_cg_assemblage.h:38
MG_CG_ASSEMBLAGE::actualiser_mg_sous_geometrie
void actualiser_mg_sous_geometrie(void)
Definition: mg_cg_assemblage.cpp:203
MG_CG_ASSEMBLAGE::ajouter_mgcg_forme
virtual int ajouter_mgcg_forme(MG_CG_FORME *mgcg_forme, bool avec_mg_element=true)
Definition: mg_cg_assemblage.cpp:87
MG_CG_ASSEMBLAGE::change_mg_sous_geometrie
virtual void change_mg_sous_geometrie(MG_SOUS_GEOMETRIE *mg_sous_geometrie)
Definition: mg_cg_assemblage.cpp:72
MG_CG_FORME
Definition: mg_cg_forme.h:42
MG_CG_FORME::change_mgcg_operateur_parent
virtual void change_mgcg_operateur_parent(MG_CG_OPERATEUR *mgcg_operateur)
Definition: mg_cg_forme.cpp:91
MG_CG_GROUPE_FORME
Definition: mg_cg_groupe_forme.h:31
MG_CG_GROUPE_FORME::ajouter_mgcg_forme
int ajouter_mgcg_forme(MG_CG_FORME *mgcg_forme)
Definition: mg_cg_groupe_forme.cpp:60
MG_CG_INFO_DOUBLE
Definition: mg_cg_info.h:58
MG_CG_INFO_STRING
Definition: mg_cg_info.h:44
MG_CG_INFO_VCT_DOUBLE
Definition: mg_cg_info.h:72
MG_CG_MODELE
Definition: mg_cg_modele.h:42
MG_CG_MODELE::ajouter_mgcg_assemblage
virtual int ajouter_mgcg_assemblage(MG_CG_ASSEMBLAGE *mgcg_assemblage)
Definition: mg_cg_modele.cpp:329
MG_CG_MODELE::get_mgcg_operateurid
virtual MG_CG_OPERATEUR * get_mgcg_operateurid(long id)
Definition: mg_cg_modele.cpp:180
MG_CG_MODELE::change_epsilon_triangulation
virtual void change_epsilon_triangulation(double val)
Definition: mg_cg_modele.cpp:1114
MG_CG_MODELE::get_mg_geometrie
virtual MG_GEOMETRIE * get_mg_geometrie(void)
Definition: mg_cg_modele.cpp:98
MG_CG_MODELE::change_fusionner_entite_similaire
virtual void change_fusionner_entite_similaire(bool val)
Definition: mg_cg_modele.cpp:1084
MG_CG_MODELE::change_importer_triangulation
virtual void change_importer_triangulation(bool val)
Definition: mg_cg_modele.cpp:1104
MG_CG_MODELE::get_mgcg_formeid
virtual MG_CG_FORME * get_mgcg_formeid(long id)
Definition: mg_cg_modele.cpp:298
MG_CG_MODELE::get_mgcg_assemblageid
virtual MG_CG_ASSEMBLAGE * get_mgcg_assemblageid(long id)
Definition: mg_cg_modele.cpp:380
MG_CG_MODELE::get_mg_identificateur
MG_IDENTIFICATEUR * get_mg_identificateur(long id)
Definition: mg_cg_modele.cpp:1124
MG_CG_OP_TRANSF_DECALLAGE
Definition: mg_cg_op_transf_decallage.h:34
MG_CG_OP_TRANSF_DECALLAGE::change_decallage
virtual void change_decallage(double decallage)
Definition: mg_cg_op_transf_decallage.cpp:50
MG_CG_OP_TRANSF_ECHELLE
Definition: mg_cg_op_transf_echelle.h:34
MG_CG_OP_TRANSF_ECHELLE::change_facteur_echelle
virtual void change_facteur_echelle(double facteur_echelle)
Definition: mg_cg_op_transf_echelle.cpp:82
MG_CG_OP_TRANSF_ECHELLE::change_centre_echelle
virtual void change_centre_echelle(double x, double y, double z)
Definition: mg_cg_op_transf_echelle.cpp:60
MG_CG_OP_TRANSF_ROTATION
Definition: mg_cg_op_transf_rotation.h:35
MG_CG_OP_TRANSF_ROTATION::change_rotation
virtual void change_rotation(OT_QUATERNION &quaternion)
Definition: mg_cg_op_transf_rotation.cpp:68
MG_CG_OP_TRANSF_ROTATION::change_centre_rotation
virtual void change_centre_rotation(double x, double y, double z)
Definition: mg_cg_op_transf_rotation.cpp:78
MG_CG_OP_TRANSF_TRANSLATION
Definition: mg_cg_op_transf_translation.h:34
MG_CG_OP_TRANSF_TRANSLATION::change_translation
virtual void change_translation(double x, double y, double z)
Definition: mg_cg_op_transf_translation.cpp:57
MG_CG_OPERATEUR
Definition: mg_cg_operateur.h:35
MG_CG_OPERATEUR::ajouter_mgcg_forme_sortie
virtual int ajouter_mgcg_forme_sortie(MG_CG_FORME *mgcg_forme)
Definition: mg_cg_operateur.cpp:187
MG_CG::creer_MG_CG_FORME_ARETE
static MG_CG_FORME_ARETE * creer_MG_CG_FORME_ARETE(MG_CG_MODELE *mgcg_modele, int provenance, MG_ARETE *mg_arete)
Definition: mg_cg.cpp:167
MG_CG::creer_MG_CG_FORME_ARETE_DROITE
static MG_CG_FORME_ARETE_DROITE * creer_MG_CG_FORME_ARETE_DROITE(MG_CG_MODELE *mgcg_modele, double x1, double y1, double z1, double x2, double y2, double z2)
Definition: mg_cg.cpp:177
MG_CG::creer_MG_CG_FORME_VOLUME_ELLIPSOIDE
static MG_CG_FORME_VOLUME_ELLIPSOIDE * creer_MG_CG_FORME_VOLUME_ELLIPSOIDE(MG_CG_MODELE *mgcg_modele, double centre_x, double centre_y, double centre_z, double direction_x, double direction_y, double direction_z, double rayon_majeur, double rayon_mineur)
Definition: mg_cg.cpp:229
MG_CG::creer_MG_CG_OP_TRANSF_DECALLAGE
static MG_CG_OP_TRANSF_DECALLAGE * creer_MG_CG_OP_TRANSF_DECALLAGE(MG_CG_MODELE *mgcg_modele, int semantique, MG_CG_FORME *mgcg_forme_entree)
Definition: mg_cg.cpp:417
MG_CG::creer_MG_CG_OP_TRANSF_ROTATION
static MG_CG_OP_TRANSF_ROTATION * creer_MG_CG_OP_TRANSF_ROTATION(MG_CG_MODELE *mgcg_modele, int semantique, MG_CG_FORME *mgcg_forme_entree)
Definition: mg_cg.cpp:375
MG_CG::creer_MG_CG_OP_BOOL_UNION
static MG_CG_OP_BOOL_UNION * creer_MG_CG_OP_BOOL_UNION(MG_CG_MODELE *mgcg_modele, int semantique, MG_CG_FORME *mgcg_forme_entree_1, MG_CG_FORME *mgcg_forme_entree_2)
Definition: mg_cg.cpp:305
MG_CG::creer_MG_CG_OP_BOOL_FRAGMENT
static MG_CG_OP_BOOL_FRAGMENT * creer_MG_CG_OP_BOOL_FRAGMENT(MG_CG_MODELE *mgcg_modele, int semantique, MG_CG_FORME *mgcg_forme_entree_1, MG_CG_FORME *mgcg_forme_entree_2)
Definition: mg_cg.cpp:347
MG_CG::creer_MG_CG_FORME_VOLUME_CONE
static MG_CG_FORME_VOLUME_CONE * creer_MG_CG_FORME_VOLUME_CONE(MG_CG_MODELE *mgcg_modele, double extremite_x, double extremite_y, double extremite_z, double direction_x, double direction_y, double direction_z, double rayon, double longueur)
Definition: mg_cg.cpp:257
MG_CG::creer_MG_CG_OP_BOOL_DIFFERENCE
static MG_CG_OP_BOOL_DIFFERENCE * creer_MG_CG_OP_BOOL_DIFFERENCE(MG_CG_MODELE *mgcg_modele, int semantique, MG_CG_FORME *mgcg_forme_entree_1, MG_CG_FORME *mgcg_forme_entree_2)
Definition: mg_cg.cpp:319
MG_CG::creer_MG_CG_OP_BOOL_INTERSECTION
static MG_CG_OP_BOOL_INTERSECTION * creer_MG_CG_OP_BOOL_INTERSECTION(MG_CG_MODELE *mgcg_modele, int semantique, MG_CG_FORME *mgcg_forme_entree_1, MG_CG_FORME *mgcg_forme_entree_2)
Definition: mg_cg.cpp:333
MG_CG::creer_MG_CG_FORME_MULTI_VOLUME
static MG_CG_FORME_MULTI_VOLUME * creer_MG_CG_FORME_MULTI_VOLUME(MG_CG_MODELE *mgcg_modele, int provenance, std::vector< MG_VOLUME * > &vector_mg_volume)
Definition: mg_cg.cpp:295
MG_CG::creer_MG_CG_OP_TRANSF_ECHELLE
static MG_CG_OP_TRANSF_ECHELLE * creer_MG_CG_OP_TRANSF_ECHELLE(MG_CG_MODELE *mgcg_modele, int semantique, MG_CG_FORME *mgcg_forme_entree)
Definition: mg_cg.cpp:403
MG_CG::creer_MG_CG_OP_INCLUSION_MATRICE
static MG_CG_OP_INCLUSION_MATRICE * creer_MG_CG_OP_INCLUSION_MATRICE(MG_CG_MODELE *mgcg_modele, int semantique, MG_CG_FORME *mgcg_forme_inclusion_entree, MG_CG_FORME *mgcg_forme_matrice_entree)
Definition: mg_cg.cpp:361
MG_CG::creer_MG_CG_FORME_MULTIPLE
static MG_CG_FORME_MULTIPLE * creer_MG_CG_FORME_MULTIPLE(MG_CG_MODELE *mgcg_modele, int provenance, std::vector< MG_ELEMENT_TOPOLOGIQUE * > &vector_mg_element_topologique, std::vector< MG_ELEMENT_COTOPOLOGIQUE * > &vector_mg_element_cotopologique)
Definition: mg_cg.cpp:285
MG_CG::creer_MG_CG_INFO_VCT_DOUBLE
static MG_CG_INFO_VCT_DOUBLE * creer_MG_CG_INFO_VCT_DOUBLE(MG_CONSTRUCTION_GEOMETRIQUE *mg_construction_geometrique, std::string identifiant, std::vector< double > &valeur)
Definition: mg_cg.cpp:137
MG_CG::creer_MG_CG_FORME_VOLUME_SPHERE
static MG_CG_FORME_VOLUME_SPHERE * creer_MG_CG_FORME_VOLUME_SPHERE(MG_CG_MODELE *mgcg_modele, double centre_x, double centre_y, double centre_z, double rayon)
Definition: mg_cg.cpp:215
MG_CG::creer_MG_CG_INFO_STRING
static MG_CG_INFO_STRING * creer_MG_CG_INFO_STRING(MG_CONSTRUCTION_GEOMETRIQUE *mg_construction_geometrique, std::string identifiant, std::string valeur)
Definition: mg_cg.cpp:117
MG_CG::creer_MG_CG_INFO_DOUBLE
static MG_CG_INFO_DOUBLE * creer_MG_CG_INFO_DOUBLE(MG_CONSTRUCTION_GEOMETRIQUE *mg_construction_geometrique, std::string identifiant, double valeur)
Definition: mg_cg.cpp:127
MG_CG::creer_MG_CG_OP_TRANSF_TRANSLATION
static MG_CG_OP_TRANSF_TRANSLATION * creer_MG_CG_OP_TRANSF_TRANSLATION(MG_CG_MODELE *mgcg_modele, int semantique, MG_CG_FORME *mgcg_forme_entree)
Definition: mg_cg.cpp:389
MG_CG::creer_MG_CG_GROUPE_FORME
static MG_CG_GROUPE_FORME * creer_MG_CG_GROUPE_FORME(MG_CG_MODELE *mgcg_modele, std::string nom)
Definition: mg_cg.cpp:107
MG_CG::creer_MG_CG_FORME_VOLUME_CYLINDRE
static MG_CG_FORME_VOLUME_CYLINDRE * creer_MG_CG_FORME_VOLUME_CYLINDRE(MG_CG_MODELE *mgcg_modele, double extremite_x, double extremite_y, double extremite_z, double direction_x, double direction_y, double direction_z, double rayon, double longueur)
Definition: mg_cg.cpp:243
MG_CG::creer_MG_CG_FORME_VOLUME_TORE
static MG_CG_FORME_VOLUME_TORE * creer_MG_CG_FORME_VOLUME_TORE(MG_CG_MODELE *mgcg_modele, double centre_x, double centre_y, double centre_z, double direction_x, double direction_y, double direction_z, double rayon_cercle, double rayon_tore, double angle_seg=2 *M_PI, double angle_rotation=0.0)
Definition: mg_cg.cpp:271
MG_CG::creer_MG_CG_FORME_VOLUME_BOITE
static MG_CG_FORME_VOLUME_BOITE * creer_MG_CG_FORME_VOLUME_BOITE(MG_CG_MODELE *mgcg_modele, double x1, double y1, double z1, double x2, double y2, double z2)
Definition: mg_cg.cpp:201
MG_CG::creer_MG_CG_FORME_VOLUME
static MG_CG_FORME_VOLUME * creer_MG_CG_FORME_VOLUME(MG_CG_MODELE *mgcg_modele, int provenance, MG_VOLUME *mg_volume)
Definition: mg_cg.cpp:191
MG_COARETE
Definition: mg_coarete.h:32
MG_COFACE
Definition: mg_coface.h:34
MG_COQUE_ELEMENT
Definition: mg_coque_element.h:33
MG_COQUE_ELEMENT::get_liste_id
virtual unsigned long get_liste_id(int num)
Definition: mg_coque_element.cpp:68
MG_COQUE_ELEMENT::ajouter_element
virtual void ajouter_element(MG_ELEMENT_MAILLAGE *ele)
Definition: mg_coque_element.cpp:56
MG_COQUE_ELEMENT::get_nb_liste_id
virtual int get_nb_liste_id(void)
Definition: mg_coque_element.cpp:61
MG_COQUE
Definition: mg_coque.h:34
MG_COQUE::change_num_materiau
void change_num_materiau(int num)
Definition: mg_coque.cpp:230
MG_COQUILLE
Definition: mg_coquille.h:35
MG_COQUILLE::ajouter_mg_coface
virtual void ajouter_mg_coface(class MG_COFACE *mgcoface)
Definition: mg_coquille.cpp:71
MG_COSOMMET
Definition: mg_cosommet.h:32
MG_COURBE
Definition: mg_courbe.h:31
MG_ELEMENT_GEOMETRIQUE::change_idoriginal
virtual void change_idoriginal(std::string id)
Definition: mg_element_geometrique.cpp:47
MG_ELEMENT_MAILLAGE
Definition: mg_element_maillage.h:39
MG_ELEMENT_TOPOLOGIQUE
Definition: mg_element_topologique.h:52
MG_ELEMENT_TOPOLOGIQUE::ajouter_contrainte
virtual void ajouter_contrainte(double val)
Definition: mg_element_topologique.cpp:447
MG_ELEMENT_TOPOLOGIQUE::ajouter_ccf
virtual void ajouter_ccf(char *nom, double val, std::string suiv="NS")
Definition: mg_element_topologique.cpp:159
MG_ELEMENT_TOPOLOGIQUE::get_dimension
virtual int get_dimension(void)=0
MG_FACE_ELEMENT
Definition: mg_face_element.h:33
MG_FACE
Definition: mg_face.h:35
MG_FACE::change_nb_pole
virtual void change_nb_pole(int val)
Definition: mg_face.cpp:491
MG_FILE::lire_MG_SOMMET
virtual void lire_MG_SOMMET(long id, class PARSE &parse, class PARS_ARGUMENT(&param)[100], std::string &data, MG_GEOMETRIE *mggeo)
Definition: mg_file.cpp:729
MG_FILE::lire_MG_CG_OP_BOOL_DIFFERENCE
virtual void lire_MG_CG_OP_BOOL_DIFFERENCE(long id, class PARSE &parse, class PARS_ARGUMENT(&param)[100], std::string &data)
Definition: mg_file.cpp:1075
MG_FILE::lire_MG_CG_FORME_MULTIPLE
virtual void lire_MG_CG_FORME_MULTIPLE(long id, class PARSE &parse, class PARS_ARGUMENT(&param)[100], std::string &data)
Definition: mg_file.cpp:1007
MG_FILE::lire_MG_CG_FORME_ARETE
virtual void lire_MG_CG_FORME_ARETE(long id, class PARSE &parse, class PARS_ARGUMENT(&param)[100], std::string &data)
Definition: mg_file.cpp:827
MG_FILE::lire_MG_CG_INFO_DOUBLE
virtual void lire_MG_CG_INFO_DOUBLE(long id, class PARSE &parse, class PARS_ARGUMENT(&param)[100], std::string &data)
Definition: mg_file.cpp:1277
MG_FILE::lire_MG_CG_GROUPE_FORME
virtual void lire_MG_CG_GROUPE_FORME(long id, class PARSE &parse, class PARS_ARGUMENT(&param)[100], std::string &data)
Definition: mg_file.cpp:808
MG_FILE::MG_FILE
MG_FILE()
Definition: mg_file.cpp:140
MG_FILE::lire_MG_CG_FORME_VOLUME_TORE
virtual void lire_MG_CG_FORME_VOLUME_TORE(long id, class PARSE &parse, class PARS_ARGUMENT(&param)[100], std::string &data)
Definition: mg_file.cpp:983
MG_FILE::lire_HEXA
virtual void lire_HEXA(long id, class PARSE &parse, class PARS_ARGUMENT(&param)[100], std::string &data, MG_MAILLAGE *mgmai, MG_GEOMETRIE *mggeo)
Definition: mg_file.cpp:380
MG_FILE::lire_MG_VOLUME
virtual void lire_MG_VOLUME(long id, class PARSE &parse, class PARS_ARGUMENT(&param)[100], std::string &data, MG_GEOMETRIE *mggeo, std::vector< unsigned long > &volumemince)
Definition: mg_file.cpp:489
MG_FILE::lire_MG_CG_FORME_VOLUME_ELLIPSOIDE
virtual void lire_MG_CG_FORME_VOLUME_ELLIPSOIDE(long id, class PARSE &parse, class PARS_ARGUMENT(&param)[100], std::string &data)
Definition: mg_file.cpp:917
MG_FILE::lire_MG_CG_OP_INCLUSION_MATRICE
virtual void lire_MG_CG_OP_INCLUSION_MATRICE(long id, class PARSE &parse, class PARS_ARGUMENT(&param)[100], std::string &data)
Definition: mg_file.cpp:1135
MG_FILE::lire_MG_ARETE
virtual void lire_MG_ARETE(long id, class PARSE &parse, class PARS_ARGUMENT(&param)[100], std::string &data, MG_GEOMETRIE *mggeo)
Definition: mg_file.cpp:703
MG_FILE::lire_MG_CG_FORME_ARETE_DROITE
virtual void lire_MG_CG_FORME_ARETE_DROITE(long id, class PARSE &parse, class PARS_ARGUMENT(&param)[100], std::string &data)
Definition: mg_file.cpp:844
MG_FILE::lire_MG_CG_FORME_VOLUME_SPHERE
virtual void lire_MG_CG_FORME_VOLUME_SPHERE(long id, class PARSE &parse, class PARS_ARGUMENT(&param)[100], std::string &data)
Definition: mg_file.cpp:899
MG_FILE::lire_MG_SOUS_GEOMETRIE
virtual void lire_MG_SOUS_GEOMETRIE(long id, class PARSE &parse, class PARS_ARGUMENT(&param)[100], std::string &data)
Definition: mg_file.cpp:453
MG_FILE::lire_MG_CG_OP_TRANSF_ROTATION
virtual void lire_MG_CG_OP_TRANSF_ROTATION(long id, class PARSE &parse, class PARS_ARGUMENT(&param)[100], std::string &data)
Definition: mg_file.cpp:1156
MG_FILE::lire_NOEUD
virtual void lire_NOEUD(long id, class PARSE &parse, class PARS_ARGUMENT(&param)[100], std::string &data, MG_MAILLAGE *mgmai, MG_GEOMETRIE *mggeo)
Definition: mg_file.cpp:272
MG_FILE::lire_MG_CG_OP_BOOL_INTERSECTION
virtual void lire_MG_CG_OP_BOOL_INTERSECTION(long id, class PARSE &parse, class PARS_ARGUMENT(&param)[100], std::string &data)
Definition: mg_file.cpp:1095
MG_FILE::lire_MG_COQUILLE
virtual void lire_MG_COQUILLE(long id, class PARSE &parse, class PARS_ARGUMENT(&param)[100], std::string &data, MG_GEOMETRIE *mggeo)
Definition: mg_file.cpp:554
MG_FILE::lire_MG_CG_FORME_VOLUME_CYLINDRE
virtual void lire_MG_CG_FORME_VOLUME_CYLINDRE(long id, class PARSE &parse, class PARS_ARGUMENT(&param)[100], std::string &data)
Definition: mg_file.cpp:939
MG_FILE::lire_MG_CG_OP_TRANSF_DECALLAGE
virtual void lire_MG_CG_OP_TRANSF_DECALLAGE(long id, class PARSE &parse, class PARS_ARGUMENT(&param)[100], std::string &data)
Definition: mg_file.cpp:1228
MG_FILE::lire_MG_CG_OP_TRANSF_TRANSLATION
virtual void lire_MG_CG_OP_TRANSF_TRANSLATION(long id, class PARSE &parse, class PARS_ARGUMENT(&param)[100], std::string &data)
Definition: mg_file.cpp:1184
MG_FILE::lire_MG_CG_INFO_VCT_DOUBLE
virtual void lire_MG_CG_INFO_VCT_DOUBLE(long id, class PARSE &parse, class PARS_ARGUMENT(&param)[100], std::string &data)
Definition: mg_file.cpp:1307
MG_FILE::get_code_de_lecture
int get_code_de_lecture(void)
Definition: mg_file.cpp:149
MG_FILE::lire_MG_CG_FORME_VOLUME
virtual void lire_MG_CG_FORME_VOLUME(long id, class PARSE &parse, class PARS_ARGUMENT(&param)[100], std::string &data)
Definition: mg_file.cpp:863
MG_FILE::str_dossier
std::string str_dossier
Definition: mg_file.h:41
MG_FILE::lire_contrainte
virtual void lire_contrainte(int numparam, class PARS_ARGUMENT(&param)[100], MG_ELEMENT_TOPOLOGIQUE *ele)
Definition: mg_file.cpp:162
MG_FILE::lire_TRIANGLE
virtual void lire_TRIANGLE(long id, class PARSE &parse, class PARS_ARGUMENT(&param)[100], std::string &data, MG_MAILLAGE *mgmai, MG_GEOMETRIE *mggeo)
Definition: mg_file.cpp:317
MG_FILE::lire_MG_CG_FORME_VOLUME_BOITE
virtual void lire_MG_CG_FORME_VOLUME_BOITE(long id, class PARSE &parse, class PARS_ARGUMENT(&param)[100], std::string &data)
Definition: mg_file.cpp:880
MG_FILE::lire_SEGMENT
virtual void lire_SEGMENT(long id, class PARSE &parse, class PARS_ARGUMENT(&param)[100], std::string &data, MG_MAILLAGE *mgmai, MG_GEOMETRIE *mggeo)
Definition: mg_file.cpp:294
MG_FILE::lire_MG_CG_OP_TRANSF_ECHELLE
virtual void lire_MG_CG_OP_TRANSF_ECHELLE(long id, class PARSE &parse, class PARS_ARGUMENT(&param)[100], std::string &data)
Definition: mg_file.cpp:1205
MG_FILE::~MG_FILE
virtual ~MG_FILE()
Definition: mg_file.cpp:145
MG_FILE::lire_PENTA
virtual void lire_PENTA(long id, class PARSE &parse, class PARS_ARGUMENT(&param)[100], std::string &data, MG_MAILLAGE *mgmai, MG_GEOMETRIE *mggeo)
Definition: mg_file.cpp:408
MG_FILE::lire_MG_CG_MODELE
virtual void lire_MG_CG_MODELE(long id, class PARSE &parse, class PARS_ARGUMENT(&param)[100], std::string &data)
Definition: mg_file.cpp:767
MG_FILE::cid
virtual long cid(std::string str)
Definition: mg_file.cpp:154
MG_FILE::lire
virtual int lire(char *chemin)
Definition: mg_file.cpp:1344
MG_FILE::lire_PYRAMIDE
virtual void lire_PYRAMIDE(long id, class PARSE &parse, class PARS_ARGUMENT(&param)[100], std::string &data, MG_MAILLAGE *mgmai, MG_GEOMETRIE *mggeo)
Definition: mg_file.cpp:431
MG_FILE::lire_QUADRANGLE
virtual void lire_QUADRANGLE(long id, class PARSE &parse, class PARS_ARGUMENT(&param)[100], std::string &data, MG_MAILLAGE *mgmai, MG_GEOMETRIE *mggeo)
Definition: mg_file.cpp:337
MG_FILE::lire_MG_CG_FORME_VOLUME_CONE
virtual void lire_MG_CG_FORME_VOLUME_CONE(long id, class PARSE &parse, class PARS_ARGUMENT(&param)[100], std::string &data)
Definition: mg_file.cpp:961
MG_FILE::lire_MG_CG_ASSEMBLAGE
virtual void lire_MG_CG_ASSEMBLAGE(long id, class PARSE &parse, class PARS_ARGUMENT(&param)[100], std::string &data)
Definition: mg_file.cpp:785
MG_FILE::lire_MG_FACE
virtual void lire_MG_FACE(long id, class PARSE &parse, class PARS_ARGUMENT(&param)[100], std::string &data, MG_GEOMETRIE *mggeo)
Definition: mg_file.cpp:612
MG_FILE::lire_MG_CG_INFO_STRING
virtual void lire_MG_CG_INFO_STRING(long id, class PARSE &parse, class PARS_ARGUMENT(&param)[100], std::string &data)
Definition: mg_file.cpp:1247
MG_FILE::code_de_lecture
int code_de_lecture
Definition: mg_file.h:40
MG_FILE::lire_ccf
virtual void lire_ccf(double version, int nb, int numparam, class PARSE &parse, class PARS_ARGUMENT(&param)[100], MG_ELEMENT_TOPOLOGIQUE *ele)
Definition: mg_file.cpp:173
MG_FILE::lire_MG_CG_OP_BOOL_UNION
virtual void lire_MG_CG_OP_BOOL_UNION(long id, class PARSE &parse, class PARS_ARGUMENT(&param)[100], std::string &data)
Definition: mg_file.cpp:1055
MG_FILE::lire_MG_BOUCLE
virtual void lire_MG_BOUCLE(long id, class PARSE &parse, class PARS_ARGUMENT(&param)[100], std::string &data, MG_GEOMETRIE *mggeo)
Definition: mg_file.cpp:645
MG_FILE::lire_TETRA
virtual void lire_TETRA(long id, class PARSE &parse, class PARS_ARGUMENT(&param)[100], std::string &data, MG_MAILLAGE *mgmai, MG_GEOMETRIE *mggeo)
Definition: mg_file.cpp:361
MG_FILE::lire_MG_CG_FORME_MULTI_VOLUME
virtual void lire_MG_CG_FORME_MULTI_VOLUME(long id, class PARSE &parse, class PARS_ARGUMENT(&param)[100], std::string &data)
Definition: mg_file.cpp:1034
MG_FILE::lire_MG_CG_OP_BOOL_FRAGMENT
virtual void lire_MG_CG_OP_BOOL_FRAGMENT(long id, class PARSE &parse, class PARS_ARGUMENT(&param)[100], std::string &data)
Definition: mg_file.cpp:1115
MG_GEOM_FONCTION
Definition: mg_geom_fonction.h:30
MG_GEOM_FONCTION::ajouter_point
virtual void ajouter_point(double *coo)
Definition: mg_geom_fonction.cpp:102
MG_GEOMETRIE
Definition: mg_geometrie.h:85
MG_GEOMETRIE::get_valeur_precision
double get_valeur_precision(void)
Definition: mg_geometrie.cpp:2642
MG_GEOMETRIE::ajouter_mg_courbe
virtual int ajouter_mg_courbe(MG_COURBE *mgcrb)
Definition: mg_geometrie.cpp:251
MG_GEOMETRIE::get_gest_step
class ST_GESTIONNAIRE & get_gest_step(void)
Definition: mg_geometrie.cpp:2694
MG_GEOMETRIE::ajouter_mg_face
virtual int ajouter_mg_face(MG_FACE *mgface)
Definition: mg_geometrie.cpp:1210
MG_GEOMETRIE::ajouter_mg_poutre
virtual int ajouter_mg_poutre(MG_POUTRE *mgpoutre)
Definition: mg_geometrie.cpp:1904
MG_GEOMETRIE::get_mg_surfaceid
MG_SURFACE * get_mg_surfaceid(unsigned long num)
Definition: mg_geometrie.cpp:382
MG_GEOMETRIE::get_mg_coqueid
MG_COQUE * get_mg_coqueid(unsigned long num)
Definition: mg_geometrie.cpp:1793
MG_GEOMETRIE::get_mg_poutreid
MG_POUTRE * get_mg_poutreid(unsigned long num)
Definition: mg_geometrie.cpp:1920
MG_GEOMETRIE::ajouter_mg_coquille
virtual int ajouter_mg_coquille(MG_COQUILLE *mgcoq)
Definition: mg_geometrie.cpp:1473
MG_GEOMETRIE::get_mg_element_cotopologiqueid
virtual MG_ELEMENT_COTOPOLOGIQUE * get_mg_element_cotopologiqueid(long num)
Definition: mg_geometrie.cpp:2497
MG_GEOMETRIE::ajouter_mg_visu_courbe
virtual int ajouter_mg_visu_courbe(MG_VISU_COURBE *mgvcrb)
Definition: mg_geometrie.cpp:2256
MG_GEOMETRIE::get_mg_boucleid
MG_BOUCLE * get_mg_boucleid(unsigned long num)
Definition: mg_geometrie.cpp:1088
MG_GEOMETRIE::ajouter_mg_surface
virtual int ajouter_mg_surface(MG_SURFACE *mgsrf)
Definition: mg_geometrie.cpp:366
MG_GEOMETRIE::get_mg_element_topologiqueid
virtual MG_ELEMENT_TOPOLOGIQUE * get_mg_element_topologiqueid(long num)
Definition: mg_geometrie.cpp:2461
MG_GEOMETRIE::ajouter_mg_point
virtual int ajouter_mg_point(MG_POINT *mgpt)
Definition: mg_geometrie.cpp:137
MG_GEOMETRIE::ajouter_mg_coarete
virtual int ajouter_mg_coarete(MG_COARETE *mgcoarete)
Definition: mg_geometrie.cpp:925
MG_GEOMETRIE::ajouter_mg_volume
virtual int ajouter_mg_volume(MG_VOLUME *mgvol)
Definition: mg_geometrie.cpp:1642
MG_GEOMETRIE::ajouter_mg_arete
virtual int ajouter_mg_arete(MG_ARETE *mgarete)
Definition: mg_geometrie.cpp:759
MG_GEOMETRIE::change_valeur_precision
void change_valeur_precision(double val)
Definition: mg_geometrie.cpp:2647
MG_GEOMETRIE::ajouter_mg_coque
virtual int ajouter_mg_coque(MG_COQUE *mgcoque)
Definition: mg_geometrie.cpp:1777
MG_GEOMETRIE::get_mg_courbeid
MG_COURBE * get_mg_courbeid(unsigned long num)
Definition: mg_geometrie.cpp:266
MG_GEOMETRIE::get_mg_pointid
MG_POINT * get_mg_pointid(unsigned long num)
Definition: mg_geometrie.cpp:153
MG_GEOMETRIE::ajouter_mg_groupe_topologique
virtual int ajouter_mg_groupe_topologique(MG_GROUPE_TOPOLOGIQUE *mggroupe_topologique)
Definition: mg_geometrie.cpp:2029
MG_GEOMETRIE::ajouter_mg_cosommet
virtual int ajouter_mg_cosommet(MG_COSOMMET *mgcosom)
Definition: mg_geometrie.cpp:643
MG_GEOMETRIE::get_gest_sat
class SAT_GESTIONNAIRE & get_gest_sat(void)
Definition: mg_geometrie.cpp:2688
MG_GEOMETRIE::get_type_geometrie
char * get_type_geometrie(void)
Definition: mg_geometrie.cpp:2583
MG_GEOMETRIE::get_mg_faceid
MG_FACE * get_mg_faceid(unsigned long num)
Definition: mg_geometrie.cpp:1226
MG_GEOMETRIE::ajouter_mg_boucle
virtual int ajouter_mg_boucle(MG_BOUCLE *mgboucle)
Definition: mg_geometrie.cpp:1041
MG_GEOMETRIE::change_gest_materiau
void change_gest_materiau(char *nom)
Definition: mg_geometrie.cpp:2632
MG_GEOMETRIE::ajouter_mg_geom_fonction
virtual int ajouter_mg_geom_fonction(MG_GEOM_FONCTION *mggeofon)
Definition: mg_geometrie.cpp:2141
MG_GEOMETRIE::change_est_construction
void change_est_construction(bool val)
Definition: mg_geometrie.cpp:2712
MG_GEOMETRIE::get_mg_sommetid
MG_SOMMET * get_mg_sommetid(unsigned long num)
Definition: mg_geometrie.cpp:513
MG_GEOMETRIE::get_mg_coquilleid
MG_COQUILLE * get_mg_coquilleid(unsigned long num)
Definition: mg_geometrie.cpp:1521
MG_GEOMETRIE::get_occ_fonction
class OCC_FONCTION & get_occ_fonction(void)
Definition: mg_geometrie.cpp:2701
MG_GEOMETRIE::ajouter_mg_sommet
virtual int ajouter_mg_sommet(MG_SOMMET *mgsom)
Definition: mg_geometrie.cpp:497
MG_GEOMETRIE::get_mg_areteid
MG_ARETE * get_mg_areteid(unsigned long num)
Definition: mg_geometrie.cpp:775
MG_GEOMETRIE::get_mg_volumeid
MG_VOLUME * get_mg_volumeid(unsigned long num)
Definition: mg_geometrie.cpp:1658
MG_GEOMETRIE::ajouter_mg_coface
virtual int ajouter_mg_coface(MG_COFACE *mgcoface)
Definition: mg_geometrie.cpp:1356
MG_GESTIONNAIRE
Definition: mg_gestionnaire.h:58
MG_GESTIONNAIRE::get_premier_arbre
MG_ARBRE * get_premier_arbre(LISTE_MG_ARBRE::iterator &it)
Definition: mg_gestionnaire.cpp:237
MG_GESTIONNAIRE::version_fichier
double version_fichier
Definition: mg_gestionnaire.h:177
MG_GESTIONNAIRE::get_mg_maillageid
MG_MAILLAGE * get_mg_maillageid(unsigned long num)
Definition: mg_gestionnaire.cpp:538
MG_GESTIONNAIRE::get_premier_geometrie
MG_GEOMETRIE * get_premier_geometrie(LISTE_MG_GEOMETRIE::iterator &it)
Definition: mg_gestionnaire.cpp:342
MG_GESTIONNAIRE::get_mg_geometrieid
MG_GEOMETRIE * get_mg_geometrieid(unsigned long num)
Definition: mg_gestionnaire.cpp:319
MG_GESTIONNAIRE::ajouter_mg_arbre
int ajouter_mg_arbre(MG_ARBRE *mgarbre)
Definition: mg_gestionnaire.cpp:201
MG_GESTIONNAIRE::get_suivant_mg_maillage
MG_MAILLAGE * get_suivant_mg_maillage(LISTE_MG_MAILLAGE::iterator &it)
Definition: mg_gestionnaire.cpp:570
MG_GESTIONNAIRE::ajouter_mg_geometrie
int ajouter_mg_geometrie(MG_GEOMETRIE *mggeo)
Definition: mg_gestionnaire.cpp:306
MG_GESTIONNAIRE::ajouter_fem_solution
int ajouter_fem_solution(FEM_SOLUTION *mgsol)
Definition: mg_gestionnaire.cpp:902
MG_GESTIONNAIRE::lst_mgcg_modele
LISTE_MGCG_MODELE lst_mgcg_modele
Definition: mg_gestionnaire.h:171
MG_GESTIONNAIRE::entiteidmax
unsigned long entiteidmax
Definition: mg_gestionnaire.h:173
MG_GESTIONNAIRE::get_premier_construction
MG_GEOMETRIE * get_premier_construction(LISTE_MG_CONSTRUCTION::iterator &it)
Definition: mg_gestionnaire.cpp:449
MG_GESTIONNAIRE::ajouter_mgcg_modele
int ajouter_mgcg_modele(MG_CG_MODELE *mgcg_modele)
Definition: mg_gestionnaire.cpp:96
MG_GESTIONNAIRE::ajouter_mg_solution
int ajouter_mg_solution(MG_SOLUTION *mgsol)
Definition: mg_gestionnaire.cpp:764
MG_GESTIONNAIRE::get_suivant_arbre
MG_ARBRE * get_suivant_arbre(LISTE_MG_ARBRE::iterator &it)
Definition: mg_gestionnaire.cpp:245
MG_GESTIONNAIRE::ajouter_fem_maillage
int ajouter_fem_maillage(FEM_MAILLAGE *femmai)
Definition: mg_gestionnaire.cpp:641
MG_GESTIONNAIRE::get_suivant_geometrie
MG_GEOMETRIE * get_suivant_geometrie(LISTE_MG_GEOMETRIE::iterator &it)
Definition: mg_gestionnaire.cpp:350
MG_GESTIONNAIRE::get_premier_mg_maillage
MG_MAILLAGE * get_premier_mg_maillage(LISTE_MG_MAILLAGE::iterator &it)
Definition: mg_gestionnaire.cpp:562
MG_GESTIONNAIRE::get_mg_constructionid
MG_GEOMETRIE * get_mg_constructionid(unsigned long num)
Definition: mg_gestionnaire.cpp:426
MG_GESTIONNAIRE::get_suivant_construction
MG_GEOMETRIE * get_suivant_construction(LISTE_MG_CONSTRUCTION::iterator &it)
Definition: mg_gestionnaire.cpp:457
MG_GESTIONNAIRE::get_fem_maillageid
FEM_MAILLAGE * get_fem_maillageid(unsigned long num)
Definition: mg_gestionnaire.cpp:658
MG_GESTIONNAIRE::get_mgcg_modeleid
MG_CG_MODELE * get_mgcg_modeleid(unsigned long num)
Definition: mg_gestionnaire.cpp:108
MG_GESTIONNAIRE::ajouter_mg_maillage
int ajouter_mg_maillage(MG_MAILLAGE *mgmai)
Definition: mg_gestionnaire.cpp:521
MG_GESTIONNAIRE::ajouter_mg_construction
int ajouter_mg_construction(MG_GEOMETRIE *construction)
Definition: mg_gestionnaire.cpp:413
MG_GROUPE_TOPOLOGIQUE
Definition: mg_groupe_topologique.h:32
MG_GROUPE_TOPOLOGIQUE::ajouter
virtual int ajouter(class MG_ELEMENT_TOPOLOGIQUE *ele)
Definition: mg_groupe_topologique.cpp:61
MG_IDENTIFICATEUR
Definition: mg_identificateur.h:35
MG_IDENTIFICATEUR::change_id
void change_id(unsigned long idtmp)
Definition: mg_identificateur.cpp:59
MG_IDENTIFICATEUR::get_id
unsigned long get_id()
Definition: mg_identificateur.cpp:53
MG_MAILLAGE
Definition: mg_maillage.h:63
MG_MAILLAGE::get_mg_pentaid
MG_PENTA * get_mg_pentaid(unsigned long num)
Definition: mg_maillage.cpp:1714
MG_MAILLAGE::ajouter_mg_penta
MG_PENTA * ajouter_mg_penta(MG_ELEMENT_TOPOLOGIQUE *topo, class MG_NOEUD *mgnoeud1, class MG_NOEUD *mgnoeud2, class MG_NOEUD *mgnoeud3, class MG_NOEUD *mgnoeud4, class MG_NOEUD *mgnoeud5, class MG_NOEUD *mgnoeud6, int origine, unsigned long num=0)
Definition: mg_maillage.cpp:1669
MG_MAILLAGE::get_mg_triangleid
MG_TRIANGLE * get_mg_triangleid(unsigned long num)
Definition: mg_maillage.cpp:772
MG_MAILLAGE::get_mg_quadrangleid
MG_QUADRANGLE * get_mg_quadrangleid(unsigned long num)
Definition: mg_maillage.cpp:973
MG_MAILLAGE::ajouter_mg_quadrangle
MG_QUADRANGLE * ajouter_mg_quadrangle(MG_ELEMENT_TOPOLOGIQUE *topo, class MG_NOEUD *mgnoeud1, class MG_NOEUD *mgnoeud2, class MG_NOEUD *mgnoeud3, class MG_NOEUD *mgnoeud4, int origine, unsigned long num=0)
Definition: mg_maillage.cpp:930
MG_MAILLAGE::change_param_structure
void change_param_structure(BOITE_3D btmp, int nxtmp, int nytmp, int nztmp)
Definition: mg_maillage.cpp:2663
MG_MAILLAGE::get_mg_noeudid
MG_NOEUD * get_mg_noeudid(unsigned long num)
Definition: mg_maillage.cpp:451
MG_MAILLAGE::ajouter_mg_triangle
MG_TRIANGLE * ajouter_mg_triangle(MG_ELEMENT_TOPOLOGIQUE *topo, class MG_NOEUD *mgnoeud1, class MG_NOEUD *mgnoeud2, class MG_NOEUD *mgnoeud3, int origine, unsigned long num=0)
Definition: mg_maillage.cpp:731
MG_MAILLAGE::get_mg_tetraid
MG_TETRA * get_mg_tetraid(unsigned long num)
Definition: mg_maillage.cpp:1201
MG_MAILLAGE::ajouter_mg_tetra
MG_TETRA * ajouter_mg_tetra(MG_ELEMENT_TOPOLOGIQUE *topo, class MG_NOEUD *mgnoeud1, class MG_NOEUD *mgnoeud2, class MG_NOEUD *mgnoeud3, class MG_NOEUD *mgnoeud4, int origine, unsigned long num=0)
Definition: mg_maillage.cpp:1158
MG_MAILLAGE::ajouter_mg_pyramide
MG_PYRAMIDE * ajouter_mg_pyramide(MG_ELEMENT_TOPOLOGIQUE *topo, class MG_NOEUD *mgnoeud1, class MG_NOEUD *mgnoeud2, class MG_NOEUD *mgnoeud3, class MG_NOEUD *mgnoeud4, class MG_NOEUD *mgnoeud5, int origine, unsigned long num=0)
Definition: mg_maillage.cpp:1926
MG_MAILLAGE::get_mg_segmentid
MG_SEGMENT * get_mg_segmentid(unsigned long num)
Definition: mg_maillage.cpp:595
MG_MAILLAGE::get_mg_hexaid
MG_HEXA * get_mg_hexaid(unsigned long num)
Definition: mg_maillage.cpp:1437
MG_MAILLAGE::get_mg_segment
MG_SEGMENT * get_mg_segment(unsigned int num)
Definition: mg_maillage.cpp:619
MG_MAILLAGE::ajouter_mg_segment
MG_SEGMENT * ajouter_mg_segment(MG_ELEMENT_TOPOLOGIQUE *topo, class MG_NOEUD *mgnoeud1, class MG_NOEUD *mgnoeud2, int origine, double longue=0.0, unsigned long num=0)
Definition: mg_maillage.cpp:565
MG_MAILLAGE::ajouter_mg_noeud
MG_NOEUD * ajouter_mg_noeud(MG_ELEMENT_TOPOLOGIQUE *topo, double xx, double yy, double zz, int origine, unsigned long num=0)
Definition: mg_maillage.cpp:421
MG_MAILLAGE::ajouter_mg_hexa
MG_HEXA * ajouter_mg_hexa(MG_ELEMENT_TOPOLOGIQUE *topo, class MG_NOEUD *mgnoeud1, class MG_NOEUD *mgnoeud2, class MG_NOEUD *mgnoeud3, class MG_NOEUD *mgnoeud4, class MG_NOEUD *mgnoeud5, class MG_NOEUD *mgnoeud6, class MG_NOEUD *mgnoeud7, class MG_NOEUD *mgnoeud8, int origine, unsigned long num=0)
Definition: mg_maillage.cpp:1390
MG_NOEUD
Definition: mg_noeud.h:42
MG_POINT
Definition: mg_point.h:34
MG_POUTRE_ELEMENT
Definition: mg_poutre_element.h:32
MG_POUTRE_ELEMENT::get_liste_id
virtual unsigned long get_liste_id(int num)
Definition: mg_poutre_element.cpp:68
MG_POUTRE_ELEMENT::ajouter_element
virtual void ajouter_element(MG_ELEMENT_MAILLAGE *ele)
Definition: mg_poutre_element.cpp:56
MG_POUTRE_ELEMENT::get_nb_liste_id
virtual int get_nb_liste_id(void)
Definition: mg_poutre_element.cpp:61
MG_POUTRE
Definition: mg_poutre.h:34
MG_POUTRE::change_num_materiau
void change_num_materiau(int num)
Definition: mg_poutre.cpp:158
MG_SEGMENT
Definition: mg_segment.h:39
MG_SOLUTION
Definition: mg_solution.h:47
MG_SOLUTION::change_legende
void change_legende(int num, std::string val)
Definition: mg_solution.cpp:328
MG_SOMMET_NOEUD
Definition: mg_sommet_noeud.h:34
MG_SOMMET_NOEUD::get_id_mg_noeud
virtual unsigned long get_id_mg_noeud(void)
Definition: mg_sommet_noeud.cpp:113
MG_SOMMET_NOEUD::change_mg_noeud
virtual void change_mg_noeud(MG_NOEUD *notmp)
Definition: mg_sommet_noeud.cpp:117
MG_SOMMET
Definition: mg_sommet.h:36
MG_SOMMET::change_pole
void change_pole(bool val)
Definition: mg_sommet.cpp:119
MG_SOUS_GEOMETRIE
Definition: mg_sous_geometrie.h:51
MG_SURFACE
Definition: mg_surface.h:32
MG_VISU_COURBE
Definition: mg_visu_courbe.h:30
MG_VOLUME_ELEMENT
Definition: mg_volume_element.h:33
MG_VOLUME
Definition: mg_volume.h:34
MG_VOLUME::ajouter_face_correspondante
virtual void ajouter_face_correspondante(MG_FACE *face1, MG_FACE *face2)
Definition: mg_volume.cpp:195
MG_VOLUME::change_num_materiau
virtual void change_num_materiau(int num)
Definition: mg_volume.cpp:176
OCC_ARETE
Definition: occ_arete.h:35
OCC_BOUCLE
Definition: occ_boucle.h:39
OCC_COQUILLE
Definition: occ_coquille.h:37
OCC_COURBE
Definition: occ_courbe.h:41
OCC_FACE
Definition: occ_face.h:35
OCC_FONCTION_V2017
Definition: occ_fonction_v2017.h:105
OCC_FONCTION_V2017::get_TopoDS_Solid_id
TopoDS_Solid get_TopoDS_Solid_id(long id)
Definition: occ_fonction_v2017.cpp:1206
OCC_FONCTION_V2017::get_TopoDS_Vertex_id
TopoDS_Vertex get_TopoDS_Vertex_id(long id)
Definition: occ_fonction_v2017.cpp:964
OCC_FONCTION_V2017::get_TopoDS_Wire_id
TopoDS_Wire get_TopoDS_Wire_id(long id)
Definition: occ_fonction_v2017.cpp:1058
OCC_FONCTION_V2017::ajouter_OCC_SOMMET
int ajouter_OCC_SOMMET(class OCC_SOMMET *occ_sommet)
Definition: occ_fonction_v2017.cpp:939
OCC_FONCTION_V2017::get_TopoDS_Edge_id
TopoDS_Edge get_TopoDS_Edge_id(long id)
Definition: occ_fonction_v2017.cpp:1011
OCC_FONCTION_V2017::ajouter_OCC_COQUILLE
int ajouter_OCC_COQUILLE(class OCC_COQUILLE *occ_coquille)
Definition: occ_fonction_v2017.cpp:1121
OCC_FONCTION_V2017::get_TopoDS_Shell_id
TopoDS_Shell get_TopoDS_Shell_id(long id)
Definition: occ_fonction_v2017.cpp:1164
OCC_FONCTION_V2017::ajouter_OCC_BOUCLE
int ajouter_OCC_BOUCLE(class OCC_BOUCLE *occ_boucle)
Definition: occ_fonction_v2017.cpp:1033
OCC_FONCTION_V2017::ajouter_OCC_FACE
int ajouter_OCC_FACE(class OCC_FACE *occ_face)
Definition: occ_fonction_v2017.cpp:1075
OCC_FONCTION_V2017::ouvrir_fichier_OCAF
virtual int ouvrir_fichier_OCAF(char *file)
Definition: occ_fonction_v2017.cpp:209
OCC_FONCTION_V2017::ajouter_OCC_VOLUME
int ajouter_OCC_VOLUME(class OCC_VOLUME *occ_volume)
Definition: occ_fonction_v2017.cpp:1181
OCC_FONCTION_V2017::ajouter_OCC_ARETE
int ajouter_OCC_ARETE(class OCC_ARETE *occ_arete)
Definition: occ_fonction_v2017.cpp:986
OCC_FONCTION_V2017::get_TopoDS_Face_id
TopoDS_Face get_TopoDS_Face_id(long id)
Definition: occ_fonction_v2017.cpp:1100
OCC_FONCTION::GetShape
virtual const TopoDS_Shape & GetShape(const int id_shape)
Definition: occ_fonction.cpp:77
OCC_FONCTION::get_version
virtual std::string get_version(void)
Definition: occ_fonction.cpp:88
OCC_FONCTION::change_precision
virtual void change_precision(double val)
Definition: occ_fonction.cpp:93
OCC_POINT
Definition: occ_point.h:46
OCC_SOMMET
Definition: occ_sommet.h:35
OCC_SURFACE
Definition: occ_surface.h:39
OCC_VOLUME
Definition: occ_volume.h:35
OT_CHAINE
Definition: ot_chaine.h:30
OT_CHAINE::split
std::vector< std::string > split(std::string chaine, char c)
Definition: ot_chaine.cpp:187
OT_QUATERNION
Definition: ot_mathematique.h:72
PARS_ARGUMENT
Definition: pars_argument.h:38
PARS_ARGUMENT::argument
std::vector< std::string > argument
Definition: pars_argument.h:44
PARSE
Definition: parse.h:33
PARSE::lire
std::string lire(FILE *in, char fin, int *ierr)
Definition: parse.cpp:50
PARSE::decode
void decode(char *code, std::string masque, class PARS_ARGUMENT *arg)
Definition: parse.cpp:71
SAT_COURBE
Definition: sat_courbe.h:34
SAT_GESTIONNAIRE::lst_courbe
TPL_MAP_ENTITE< class SAT_COURBE * > lst_courbe
Definition: sat_gestionnaire.h:81
SAT_GESTIONNAIRE::lst_surface
TPL_MAP_ENTITE< class SAT_SURFACE * > lst_surface
Definition: sat_gestionnaire.h:80
SAT_GESTIONNAIRE::lst_point
TPL_MAP_ENTITE< class SAT_POINT * > lst_point
Definition: sat_gestionnaire.h:77
SAT_POINT
Definition: sat_point.h:31
SAT_SURFACE
Definition: sat_surface.h:30
ST_COURBE
Definition: st_courbe.h:34
ST_GESTIONNAIRE::lst_courbe
TPL_MAP_ENTITE< class ST_COURBE * > lst_courbe
Definition: st_gestionnaire.h:95
ST_GESTIONNAIRE::lst_surface
TPL_MAP_ENTITE< class ST_SURFACE * > lst_surface
Definition: st_gestionnaire.h:96
ST_GESTIONNAIRE::lst_point
TPL_MAP_ENTITE< class ST_POINT * > lst_point
Definition: st_gestionnaire.h:91
ST_POINT
Definition: st_point.h:31
ST_SURFACE
Definition: st_surface.h:30
STEP_COURBE
Definition: step_courbe.h:33
STEP_POINT
Definition: step_point.h:34
STEP_SURFACE
Definition: step_surface.h:34
TPL_MAP_ENTITE
Definition: tpl_map_entite.h:36
TPL_MAP_ENTITE::get_premier
virtual X get_premier(ITERATEUR &it)
Definition: tpl_map_entite.h:112
TPL_MAP_ENTITE::getid
virtual X getid(unsigned long num)
Definition: tpl_map_entite.h:96
TPL_MAP_ENTITE::get_suivant
virtual X get_suivant(ITERATEUR &it)
Definition: tpl_map_entite.h:120
TPL_MAP_ENTITE::ajouter
virtual void ajouter(X x)
Definition: tpl_map_entite.h:55
TPL_MAP_ENTITE::ITERATEUR
std::map< unsigned long, X, std::less< unsigned long > >::iterator ITERATEUR
Definition: tpl_map_entite.h:38
XFEM_ELEMENT0
Definition: xfem_element0.h:37
XFEM_ELEMENT_MAILLAGE::change_etat
virtual void change_etat(int num)
Definition: xfem_element_maillage.cpp:80
XFEM_SEGMENT2
Definition: xfem_segment2.h:35
XFEM_TETRA4
Definition: xfem_tetra4.h:35
XFEM_TRIANGLE3
Definition: xfem_triangle3.h:35
fem_hexa20.h
fem_hexa8.h
fem_mini_segment2.h
fem_penta15.h
fem_penta6.h
fem_quadrangle4.h
fem_quadrangle8.h
fem_segment2.h
fem_segment3.h
fem_tetra10.h
fem_tetra4.h
fem_triangle3.h
fem_triangle6.h
lc_point.h
mg_arete_element.h
mg_assemblage.h
mg_cg.h
mg_cg_assemblage.h
mg_cg_forme.h
mg_cg_forme_arete_droite.h
mg_cg_forme_multi_volume.h
mg_cg_forme_multiple.h
mg_cg_forme_volume_boite.h
mg_cg_forme_volume_cone.h
mg_cg_forme_volume_cylindre.h
mg_cg_forme_volume_ellipsoide.h
mg_cg_forme_volume_sphere.h
mg_cg_forme_volume_tore.h
mg_cg_groupe_forme.h
mg_cg_info.h
mg_cg_modele.h
mg_cg_op_bool_difference.h
mg_cg_op_bool_fragment.h
mg_cg_op_bool_intersection.h
mg_cg_op_bool_union.h
mg_cg_op_inclusion_matrice.h
mg_cg_op_transf_decallage.h
mg_cg_op_transf_echelle.h
mg_cg_op_transf_rotation.h
mg_cg_op_transf_translation.h
mg_coque_element.h
mg_face_element.h
mg_file.h
mg_operateur_boolean_difference.h
mg_operateur_boolean_intersection.h
mg_operateur_boolean_union.h
mg_poutre_element.h
mg_primitive_boite.h
mg_primitive_complexe.h
mg_primitive_cone.h
mg_primitive_cylindre.h
mg_primitive_ellipsoide_revolution.h
mg_primitive_sphere.h
mg_primitive_tore.h
SOL_EXISTANTE
const unsigned int SOL_EXISTANTE
Definition: mg_solution.h:40
mg_sommet_noeud.h
mg_sous_geometrie.h
mg_volume_element.h
occ_courbe.h
occ_fonction.h
occ_fonction_v2017.h
occ_point.h
occ_sommet.h
occ_surface.h
ot_chaine.h
pars_argument.h
step_courbe.h
step_point.h
step_surface.h
xfem_segment2.h
xfem_tetra4.h
xfem_triangle3.h