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