fichier/src/mg_file.cpp

//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//  MAGiC
//####//  Jean Christophe Cuilliere et Vincent FRANCOIS
//####//  Departement de Genie Mecanique - UQTR
//####//------------------------------------------------------------
//####//  MAGIC est un projet de recherche de l equipe ERICCA
//####//  du departement de genie mecanique de l Universite du Quebec a Trois Rivieres
//####//  http://www.uqtr.ca/ericca
//####//  http://www.uqtr.ca/
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//
//####//       mg_file.cpp
//####//
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//    COPYRIGHT 2000-2024
//####//  jeu 13 jun 2024 11:58:53 EDT
//####//------------------------------------------------------------
//####//------------------------------------------------------------


#include "gestionversion.h"

#pragma hdrstop

#include <string.h>
#include "mg_file.h"
#include "mg_sommet_noeud.h"
#include "mg_arete_element.h"
#include "mg_face_element.h"
#include "mg_volume_element.h"
#include "mg_coque_element.h"
#include "mg_poutre_element.h"
#include "pars_argument.h"
#include "parse.h"
#include "ot_chaine.h"
#ifdef BREP_STEP
#include "step_surface.h"
#include "step_courbe.h"
#include "step_point.h"
#endif
#ifdef BREP_SAT
#include "acis_surface.h"
#include "acis_courbe.h"
#include "acis_point.h"
#endif
#include "lc_point.h"
#include "fem_segment2.h"
#include "fem_mini_segment2.h"
#include "fem_segment3.h"
#include "fem_triangle3.h"
#include "fem_triangle6.h"
#include "fem_quadrangle4.h"
#include "fem_quadrangle8.h"
#include "fem_tetra4.h"
#include "xfem_segment2.h"
#include "xfem_triangle3.h"
#include "xfem_tetra4.h"
#include "fem_tetra10.h"
#include "fem_hexa8.h"
#include "fem_hexa20.h"
#include "fem_penta6.h"
#include "fem_penta15.h"
#ifdef BREP_OCC
#include "occ_surface.h"
#include "occ_point.h"
#include "occ_courbe.h"
#include "occ_fonction.h"
#include "TopoDS_Shape.hxx"
#include "TopoDS.hxx"
#include "occ_sommet.h"
#endif
#ifdef CSG_OCC
#include "mg_assemblage.h"
#include "mg_primitive_boite.h"
#include "mg_primitive_sphere.h"
#include "mg_primitive_ellipsoide_revolution.h"
#include "mg_primitive_cylindre.h"
#include "mg_primitive_cone.h"
#include "mg_primitive_tore.h"
#include "mg_primitive_complexe.h"
#include "mg_operateur_boolean_union.h"
#include "mg_operateur_boolean_difference.h"
#include "mg_operateur_boolean_intersection.h"

#endif
#include "occ_fonction_v2017.h"
#include "mg_cg_forme.h"
#include "mg_cg_forme_arete_droite.h"
#include "mg_cg_forme_volume_boite.h"
#include "mg_cg_forme_volume_sphere.h"
#include "mg_cg_forme_volume_ellipsoide.h"
#include "mg_cg_forme_volume_cylindre.h"
#include "mg_cg_forme_volume_cone.h"
#include "mg_cg_forme_volume_tore.h"
#include "mg_cg_forme_multiple.h"
#include "mg_cg_forme_multi_volume.h"
#include "mg_cg_op_bool_union.h"
#include "mg_cg_op_bool_difference.h"
#include "mg_cg_op_bool_intersection.h"
#include "mg_cg_op_bool_fragment.h"
#include "mg_cg_op_inclusion_matrice.h"
#include "mg_cg_op_transf_rotation.h"
#include "mg_cg_op_transf_translation.h"
#include "mg_cg_op_transf_echelle.h"
#include "mg_cg_op_transf_decallage.h"
#include "mg_cg_modele.h"
#include "mg_cg_assemblage.h"
#include "mg_cg_op_bool_union.h"
#include "mg_cg.h"
#include "mg_sous_geometrie.h"
#include "mg_cg_info.h"
#include "mg_cg_groupe_forme.h"

#ifdef WINDOWS_VERSION
#include "CAD4FE_MCEdge.h"
#include "CAD4FE_MCFace.h"
#include "CAD4FE_MCVertex.h"
#include "CAD4FE_PolySurface.h"
#include "CAD4FE_PolyCurve.h"
#include "CAD4FE_MCNode.h"
#include "CAD4FE_MCSegment.h"
#include "CAD4FE_MCTriangle.h"
#include "CAD4FE_m3d_MCTriangle.h"
#endif


#pragma package(smart_init)


MG_FILE::MG_FILE(char* chemin):MG_GESTIONNAIRE()
{
  str_dossier ="";
  code_de_lecture=lire(chemin);
}

MG_FILE::MG_FILE():MG_GESTIONNAIRE()
{
}
    
MG_FILE::~MG_FILE()
{
}

int MG_FILE::get_code_de_lecture(void)
{
    return code_de_lecture;
}

long MG_FILE::cid(std::string str)
{
    const char *p=str.c_str();
    if (*p=='$') return atol(p+1);
    return -1;
}


void MG_FILE::lire_contrainte(int numparam,class PARS_ARGUMENT (&param)[100],MG_ELEMENT_TOPOLOGIQUE *ele)
  {
  int nb=param[numparam].argument.size();
  for (int i=0;i<nb;i++)
    {
    double val=atoi(param[numparam].argument[i].c_str());
    ele->ajouter_contrainte(val);
    }
  }
  
  
void MG_FILE::lire_ccf(double version,int nb,int numparam,class PARSE& parse,class PARS_ARGUMENT (&param)[100],MG_ELEMENT_TOPOLOGIQUE *ele)
{
if (version<2.0)
{
  for (int i=0;i<nb;i++)
    {
    parse.decode(param[numparam].argument[i].c_str(),"(@,@)",param+numparam+1);
    char nom[3];
    strcpy(nom,param[numparam+1].argument[0].c_str());
    if (strcmp(nom,"CM")==0)
    {
      unsigned long val;
      val=atol(param[numparam+2].argument[0].c_str());
      ele->ajouter_ccf(nom,val);
    }
    else
    {
      double val;
      val=atof(param[numparam+2].argument[0].c_str());
      ele->ajouter_ccf(nom,val);
    }
    }
}
else if (version<2.1)
{
  for (int i=0;i<nb;i++)
  {
  char test[500];
    strcpy(test,param[numparam].argument[i].c_str());
  parse.decode(param[numparam].argument[i].c_str(),"(@,@,@)",param+numparam+1);
  char formulation[10];
  strcpy(formulation,param[numparam+1].argument[0].c_str());
  char nom[3];
  strcpy(nom,param[numparam+2].argument[0].c_str());
  if (formulation[0]=='N')
      {
      double val;
      val=atof(param[numparam+3].argument[0].c_str());
      ele->ajouter_ccf(nom,val);
    }  
  if (formulation[0]=='I')
      {
      unsigned long val;
      val=atol(param[numparam+3].argument[0].c_str());
      ele->ajouter_ccf(nom,val);
    }  
  if (formulation[0]=='F')
      {
      parse.decode(param[numparam].argument[i].c_str(),"(@,@,@,@,(@))",param+numparam+1);
      char formule[500];
      strcpy(formule,param[numparam+3].argument[0].c_str());
      char variable[500];
      strcpy(variable,param[numparam+5].argument[0].c_str());
      OT_CHAINE ot;
      std::vector<std::string> listvariable=ot.split(variable,',');
      ele->ajouter_ccf(nom,formule,listvariable);
    }  
  }
}
else
{
  for (int i=0;i<nb;i++)
  {
  char test[500];
    strcpy(test,param[numparam].argument[i].c_str());
  parse.decode(param[numparam].argument[i].c_str(),"(@,@,@,@)",param+numparam+1);
  char formulation[10];
  strcpy(formulation,param[numparam+1].argument[0].c_str());
  char nom[3];
  strcpy(nom,param[numparam+2].argument[0].c_str());
  char suiv[10];
  strcpy(suiv,param[numparam+3].argument[0].c_str());
  if (formulation[0]=='N')
      {
      double val;
      val=atof(param[numparam+4].argument[0].c_str());
      ele->ajouter_ccf(nom,val,suiv);
    }  
  if (formulation[0]=='I')
      {
      unsigned long val;
      val=atol(param[numparam+4].argument[0].c_str());
      ele->ajouter_ccf(nom,val,suiv);
    }  
  if (formulation[0]=='F')
      {
      parse.decode(param[numparam].argument[i].c_str(),"(@,@,@,@,@,(@))",param+numparam+1);
      char formule[500];
      strcpy(formule,param[numparam+4].argument[0].c_str());
      char variable[500];
      strcpy(variable,param[numparam+6].argument[0].c_str());
      OT_CHAINE ot;
      std::vector<std::string> listvariable=ot.split(variable,',');
      ele->ajouter_ccf(nom,formule,listvariable,suiv);
    }  
  }
}
}

void MG_FILE::lire_NOEUD(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data,MG_MAILLAGE *mgmai,MG_GEOMETRIE *mggeo)
{
parse.decode(data.c_str(),"@,@,@,@,@",param+2);
long idtopo=cid(param[2].argument[0]);
double x=atof(param[3].argument[0].c_str());
double y=atof(param[4].argument[0].c_str());
double z=atof(param[5].argument[0].c_str());
int ori=atoi(param[6].argument[0].c_str());
MG_ELEMENT_TOPOLOGIQUE* topo;
if (idtopo>-1)
      {
      topo=mggeo->get_mg_sommetid(idtopo);
      if (topo==NULL) topo=mggeo->get_mg_areteid(idtopo);
      if (topo==NULL) topo=mggeo->get_mg_faceid(idtopo);
      if (topo==NULL) topo=mggeo->get_mg_volumeid(idtopo);
      }
else topo=NULL;
MG_NOEUD* noeud=new MG_NOEUD(id,topo,x,y,z,ori);
mgmai->ajouter_mg_noeud(noeud);
}

void MG_FILE::lire_SEGMENT(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data,MG_MAILLAGE *mgmai,MG_GEOMETRIE *mggeo)
{
parse.decode(data.c_str(),"@,@,@,@",param+2);
long idtopo=cid(param[2].argument[0]);
long idn1=cid(param[3].argument[0]);
long idn2=cid(param[4].argument[0]);
int ori=atoi(param[5].argument[0].c_str());
MG_NOEUD* noeud1=mgmai->get_mg_noeudid(idn1);
MG_NOEUD* noeud2=mgmai->get_mg_noeudid(idn2);
MG_ELEMENT_TOPOLOGIQUE* topo;
if (idtopo>-1)
     {
     topo=mggeo->get_mg_areteid(idtopo);
     if (topo==NULL) topo=mggeo->get_mg_faceid(idtopo);
     if (topo==NULL) topo=mggeo->get_mg_volumeid(idtopo);
     if (topo==NULL) topo=mggeo->get_mg_poutreid(idtopo);
     }
else topo=NULL;
MG_SEGMENT* seg=new MG_SEGMENT(id,topo,noeud1,noeud2,ori);
mgmai->ajouter_mg_segment(seg);
}
            

void MG_FILE::lire_TRIANGLE(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data,MG_MAILLAGE *mgmai,MG_GEOMETRIE *mggeo)
{
parse.decode(data.c_str(),"@,@,@,@,@",param+2);
long idtopo=cid(param[2].argument[0]);
long idn1=cid(param[3].argument[0]);
long idn2=cid(param[4].argument[0]);
long idn3=cid(param[5].argument[0]);
int ori=atoi(param[6].argument[0].c_str());
MG_NOEUD* noeud1=mgmai->get_mg_noeudid(idn1);
MG_NOEUD* noeud2=mgmai->get_mg_noeudid(idn2);
MG_NOEUD* noeud3=mgmai->get_mg_noeudid(idn3);
MG_ELEMENT_TOPOLOGIQUE* topo=NULL;
if (idtopo>-1)
    {
    topo=mggeo->get_mg_faceid(idtopo);
    if (topo==NULL) topo=mggeo->get_mg_volumeid(idtopo);
    }
mgmai->ajouter_mg_triangle(topo,noeud1,noeud2,noeud3,ori,id);  
}

void MG_FILE::lire_QUADRANGLE(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data,MG_MAILLAGE *mgmai,MG_GEOMETRIE *mggeo)
{
parse.decode(data.c_str(),"@,@,@,@,@,@",param+2);
long idtopo=cid(param[2].argument[0]);
long idn1=cid(param[3].argument[0]);
long idn2=cid(param[4].argument[0]);
long idn3=cid(param[5].argument[0]);
long idn4=cid(param[6].argument[0]);
int ori=atoi(param[7].argument[0].c_str());
MG_NOEUD* noeud1=mgmai->get_mg_noeudid(idn1);
MG_NOEUD* noeud2=mgmai->get_mg_noeudid(idn2);
MG_NOEUD* noeud3=mgmai->get_mg_noeudid(idn3);
MG_NOEUD* noeud4=mgmai->get_mg_noeudid(idn4);
MG_ELEMENT_TOPOLOGIQUE* topo;
if (idtopo>-1)
    {
    topo=mggeo->get_mg_faceid(idtopo);
    if (topo==NULL) topo=mggeo->get_mg_volumeid(idtopo);
    }
else topo=NULL;
mgmai->ajouter_mg_quadrangle(topo,noeud1,noeud2,noeud3,noeud4,ori,id);
}
            

void MG_FILE::lire_TETRA(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data,MG_MAILLAGE *mgmai,MG_GEOMETRIE *mggeo)
{
parse.decode(data.c_str(),"@,@,@,@,@,@",param+2);
long idtopo=cid(param[2].argument[0]);
long idn1=cid(param[3].argument[0]);
long idn2=cid(param[4].argument[0]);
long idn3=cid(param[5].argument[0]);
long idn4=cid(param[6].argument[0]);
int ori=atoi(param[7].argument[0].c_str());
MG_NOEUD* noeud1=mgmai->get_mg_noeudid(idn1);
MG_NOEUD* noeud2=mgmai->get_mg_noeudid(idn2);
MG_NOEUD* noeud3=mgmai->get_mg_noeudid(idn3);
MG_NOEUD* noeud4=mgmai->get_mg_noeudid(idn4);
MG_ELEMENT_TOPOLOGIQUE* topo;
if (idtopo>-1) topo=mggeo->get_mg_volumeid(idtopo);
else topo=NULL;
if (noeud1&&noeud2&&noeud3&&noeud4) mgmai->ajouter_mg_tetra(topo,noeud1,noeud2,noeud3,noeud4,ori,id);
}
            
void MG_FILE::lire_HEXA(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data,MG_MAILLAGE *mgmai,MG_GEOMETRIE *mggeo)
{
parse.decode(data.c_str(),"@,@,@,@,@,@,@,@,@,@",param+2);
long idtopo=cid(param[2].argument[0]);
long idn1=cid(param[3].argument[0]);
long idn2=cid(param[4].argument[0]);
long idn3=cid(param[5].argument[0]);
long idn4=cid(param[6].argument[0]);
long idn5=cid(param[7].argument[0]);
long idn6=cid(param[8].argument[0]);
long idn7=cid(param[9].argument[0]);
long idn8=cid(param[10].argument[0]);
int ori=atoi(param[11].argument[0].c_str());
MG_NOEUD* noeud1=mgmai->get_mg_noeudid(idn1);
MG_NOEUD* noeud2=mgmai->get_mg_noeudid(idn2);
MG_NOEUD* noeud3=mgmai->get_mg_noeudid(idn3);
MG_NOEUD* noeud4=mgmai->get_mg_noeudid(idn4);
MG_NOEUD* noeud5=mgmai->get_mg_noeudid(idn5);
MG_NOEUD* noeud6=mgmai->get_mg_noeudid(idn6);
MG_NOEUD* noeud7=mgmai->get_mg_noeudid(idn7);
MG_NOEUD* noeud8=mgmai->get_mg_noeudid(idn8);
MG_ELEMENT_TOPOLOGIQUE* topo;
if (idtopo>-1) topo=mggeo->get_mg_volumeid(idtopo);
else topo=NULL;
mgmai->ajouter_mg_hexa(topo,noeud1,noeud2,noeud3,noeud4,noeud5,noeud6,noeud7,noeud8,ori,id);
}
            

void MG_FILE::lire_PENTA(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data,MG_MAILLAGE *mgmai,MG_GEOMETRIE *mggeo)
{
parse.decode(data.c_str(),"@,@,@,@,@,@,@,@",param+2);
long idtopo=cid(param[2].argument[0]);
long idn1=cid(param[3].argument[0]);
long idn2=cid(param[4].argument[0]);
long idn3=cid(param[5].argument[0]);
long idn4=cid(param[6].argument[0]);
long idn5=cid(param[7].argument[0]);
long idn6=cid(param[8].argument[0]);
int ori=atoi(param[9].argument[0].c_str());
MG_NOEUD* noeud1=mgmai->get_mg_noeudid(idn1);
MG_NOEUD* noeud2=mgmai->get_mg_noeudid(idn2);
MG_NOEUD* noeud3=mgmai->get_mg_noeudid(idn3);
MG_NOEUD* noeud4=mgmai->get_mg_noeudid(idn4);
MG_NOEUD* noeud5=mgmai->get_mg_noeudid(idn5);
MG_NOEUD* noeud6=mgmai->get_mg_noeudid(idn6);
MG_ELEMENT_TOPOLOGIQUE* topo;
if (idtopo>-1) topo=mggeo->get_mg_volumeid(idtopo);
else topo=NULL;
mgmai->ajouter_mg_penta(topo,noeud1,noeud2,noeud3,noeud4,noeud5,noeud6,ori,id);
}

void MG_FILE::lire_PYRAMIDE(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data,MG_MAILLAGE *mgmai,MG_GEOMETRIE *mggeo)
{
parse.decode(data.c_str(),"@,@,@,@,@,@,@",param+2);
long idtopo=cid(param[2].argument[0]);
long idn1=cid(param[3].argument[0]);
long idn2=cid(param[4].argument[0]);
long idn3=cid(param[5].argument[0]);
long idn4=cid(param[6].argument[0]);
long idn5=cid(param[7].argument[0]);
int ori=atoi(param[8].argument[0].c_str());
MG_NOEUD* noeud1=mgmai->get_mg_noeudid(idn1);
MG_NOEUD* noeud2=mgmai->get_mg_noeudid(idn2);
MG_NOEUD* noeud3=mgmai->get_mg_noeudid(idn3);
MG_NOEUD* noeud4=mgmai->get_mg_noeudid(idn4);
MG_NOEUD* noeud5=mgmai->get_mg_noeudid(idn5);
MG_ELEMENT_TOPOLOGIQUE* topo;
if (idtopo>-1) topo=mggeo->get_mg_volumeid(idtopo);
else topo=NULL;
mgmai->ajouter_mg_pyramide(topo,noeud1,noeud2,noeud3,noeud4,noeud5,ori,id);
}


void MG_FILE::lire_MG_SOUS_GEOMETRIE(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data)
{
  // PARAM #                 2 3 4 5 6 7
  parse.decode(data.c_str(),"@,@,@,@,@,@,",param+2);
  long id_mg_geometrie = cid(param[2].argument[0]);
  long id_parent = cid(param[3].argument[0]);
  std::string type_geo = param[4].argument[0];
  std::string nom_fichier = param[5].argument[0];
  double precision = atof(param[6].argument[0].c_str());
  double valeur_unitee = atof(param[7].argument[0].c_str());
  MG_GEOMETRIE* mg_construction = get_mg_constructionid(id_mg_geometrie);
  MG_SOUS_GEOMETRIE* mg_sous_geometrie;
  if(type_geo=="MGCG_ASS")
  {
    MG_CG_ASSEMBLAGE* mgcg_assemblage;
    LISTE_MGCG_MODELE::iterator it_modele;
    bool trouve=false;
    it_modele=lst_mgcg_modele.begin();
    while(trouve==false && it_modele!=lst_mgcg_modele.end())
    {
      MG_CG_MODELE* mgcg_modele = it_modele->second;
      if(mgcg_modele->get_mgcg_assemblageid(id_parent)!=NULL)
      {
        mgcg_assemblage = mgcg_modele->get_mgcg_assemblageid(id_parent);
        trouve=true;
      }
    }
    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);
    mgcg_assemblage->change_mg_sous_geometrie(mg_sous_geometrie);
    mgcg_assemblage->actualiser_mg_sous_geometrie();
    ajouter_mg_geometrie(mg_sous_geometrie);
  }
}


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)
{
  if (version_fichier<2)
  {
    parse.decode(data.c_str(),"@,@,@,@,(&)",param+2);
    MG_VOLUME* mgvol=new MG_VOLUME(param[2].argument[0],id);
    mggeo->ajouter_mg_volume(mgvol);
    int nummat=atoi((char*)param[4].argument[0].c_str());
    mgvol->change_num_materiau(nummat);
    int nb=atoi(param[5].argument[0].c_str());
    if (nb!=0) lire_ccf(version_fichier,nb,6,parse,param,mgvol);
  }
  else if (version_fichier<2.3)
  {
    parse.decode(data.c_str(),"@,@,@,(&)",param+2);
    MG_VOLUME* mgvol=new MG_VOLUME(param[2].argument[0],id);
    mggeo->ajouter_mg_volume(mgvol);
    int nb=atoi(param[4].argument[0].c_str());
    if (nb!=0) lire_ccf(version_fichier,nb,5,parse,param,mgvol);
  }
  else 
  {
    parse.decode(data.c_str(),"@,@,@,@",param+2);
    MG_VOLUME* mgvol;
#ifdef ALL_OCC
    if(strcmp(mggeo->get_type_geometrie(),"OCCV2017")==0)
    {
      TopoDS_Solid topods_solid;
      OCC_FONCTION_V2017* occ_fonction_v2017 = (OCC_FONCTION_V2017*)&mggeo->get_occ_fonction();
      topods_solid=occ_fonction_v2017->get_TopoDS_Solid_id(atol(param[2].argument[0].c_str()));
      mgvol = new OCC_VOLUME(param[2].argument[0],id,topods_solid,&mggeo->get_occ_fonction());
      occ_fonction_v2017->ajouter_OCC_VOLUME((OCC_VOLUME*)mgvol);      
    }
    else mgvol=new MG_VOLUME(param[2].argument[0],id);
#else
    mgvol=new MG_VOLUME(param[2].argument[0],id);
#endif
    mggeo->ajouter_mg_volume(mgvol);
    int mince=atoi(param[4].argument[0].c_str());
    if (mince==0)
    {
      std::string data2=param[5].argument[0];
      parse.decode(data2.c_str(),"@,(&)",param+5);
      int nb=atoi(param[5].argument[0].c_str());
      if (nb!=0) lire_ccf(version_fichier,nb,6,parse,param,mgvol);
    }
    else
    {
      std::string data2=param[5].argument[0];
      parse.decode(data2.c_str(),"(&),@,(&)",param+5);
      int nb_face=param[5].argument.size();
      for (int i=0;i<nb_face;i=i+2)
      {
        unsigned long idn1=cid(param[5].argument[i]);
        unsigned long idn2=cid(param[5].argument[i+1]);
        volumemince.push_back(id);
        volumemince.push_back(idn1);
        volumemince.push_back(idn2);
      }
      int nb=atoi(param[6].argument[0].c_str());
      if (nb!=0) lire_ccf(version_fichier,nb,7,parse,param,mgvol);
    }
  }           
}

void MG_FILE::lire_MG_COQUILLE(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data,MG_GEOMETRIE *mggeo)
{
  bool import_occ_2017=false;
#ifdef ALL_OCC
  if(strcmp(mggeo->get_type_geometrie(),"OCCV2017")==0)
  {
    import_occ_2017=true;
    parse.decode(data.c_str(),"@,@,@",param+2);
    long ident=cid(param[2].argument[0]);
    long idori = stol(param[3].argument[0]);
    TopoDS_Shell topods_shell;
    OCC_COQUILLE* occ_coquille;    
    OCC_FONCTION_V2017* occ_fonction_v2017 = (OCC_FONCTION_V2017*)&mggeo->get_occ_fonction();
    topods_shell=occ_fonction_v2017->get_TopoDS_Shell_id(idori);                
    if(idori!=-1)
    {
      MG_VOLUME* mgvol=mggeo->get_mg_volumeid(ident);
      MG_COQUE* mgcoq=mggeo->get_mg_coqueid(ident);
      if (mgvol!=NULL)
      {
        OCC_COQUILLE* occ_coquille = new OCC_COQUILLE(param[3].argument[0],id,mgvol,topods_shell,&mggeo->get_occ_fonction());
        mggeo->ajouter_mg_coquille(occ_coquille,mgvol);
        occ_fonction_v2017->ajouter_OCC_COQUILLE(occ_coquille);
      }
      if (mgcoq!=NULL)
      {
        OCC_COQUILLE* occ_coquille = new OCC_COQUILLE(param[3].argument[0],id,mgcoq,topods_shell,&mggeo->get_occ_fonction());
        mggeo->ajouter_mg_coquille(occ_coquille,mgcoq);
        occ_fonction_v2017->ajouter_OCC_COQUILLE(occ_coquille);
      }
    }
    else
    {
      OCC_COQUILLE* occ_coquille = new OCC_COQUILLE(param[3].argument[0],id,topods_shell,&mggeo->get_occ_fonction());
      mggeo->ajouter_mg_coquille(occ_coquille);
      occ_fonction_v2017->ajouter_OCC_COQUILLE(occ_coquille);
    }
  }
#endif
  if(!import_occ_2017)
  {
    parse.decode(data.c_str(),"@,@",param+2);
    long ident=cid(param[2].argument[0]);
    MG_VOLUME* mgvol=mggeo->get_mg_volumeid(ident);
    MG_COQUE* mgcoq=mggeo->get_mg_coqueid(ident);
    if(mgvol!=NULL)
    {
      MG_COQUILLE* mgcoq=new MG_COQUILLE(id,mgvol);
      mggeo->ajouter_mg_coquille(mgcoq,mgvol);
    }
    if(mgcoq!=NULL)
    {
      MG_COQUILLE* mgcoquille=new MG_COQUILLE(id,mgcoq);
      mggeo->ajouter_mg_coquille(mgcoquille,mgcoq);
    }
  }  
}

void MG_FILE::lire_MG_FACE(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data,MG_GEOMETRIE *mggeo)
{
  if (version_fichier<2.2) parse.decode(data.c_str(),"@,@,(@),@,@,(&)",param+2);
  else parse.decode(data.c_str(),"@,@,(@),@,@,@,(&)",param+2);
  long idsurf=cid(param[3].argument[0]);
  int sens=atoi(param[5].argument[0].c_str());
  MG_SURFACE* mgsurf=mggeo->get_mg_surfaceid(idsurf);
  MG_FACE* mgface;
#ifdef ALL_OCC
  if(strcmp(mggeo->get_type_geometrie(),"OCCV2017")==0)
  {
    TopoDS_Face topods_face;
    OCC_FONCTION_V2017* occ_fonction_v2017 = (OCC_FONCTION_V2017*)&mggeo->get_occ_fonction();
    topods_face=occ_fonction_v2017->get_TopoDS_Face_id(atol(param[2].argument[0].c_str()));
    mgface = new OCC_FACE(param[2].argument[0],id,mgsurf,sens,topods_face,&mggeo->get_occ_fonction());
    occ_fonction_v2017->ajouter_OCC_FACE((OCC_FACE*)mgface); 
  }
  else mgface=new MG_FACE(param[2].argument[0],id,mgsurf,sens);
#else
  mgface=new MG_FACE(param[2].argument[0],id,mgsurf,sens);
#endif
  mggeo->ajouter_mg_face(mgface);
  int argccf=7;
  if (version_fichier>2.1)
      {
      argccf=8;
      int nbpole=atoi(param[6].argument[0].c_str());
      mgface->change_nb_pole(nbpole);
      }
  int nb=atoi(param[argccf-1].argument[0].c_str());
  if (nb!=0) lire_ccf(version_fichier,nb,argccf,parse,param,mgface);
}

void MG_FILE::lire_MG_BOUCLE(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data,MG_GEOMETRIE *mggeo)
{
  bool import_occ_2017=false;
  MG_BOUCLE* mgbou;
#ifdef ALL_OCC
  if(strcmp(mggeo->get_type_geometrie(),"OCCV2017")==0)
  {
    import_occ_2017=true;
    parse.decode(data.c_str(),"@,@,(@)",param+2);
    long ident=cid(param[2].argument[0]);
    long idori=stol(param[3].argument[0]);
    TopoDS_Wire topods_wire;
    OCC_FONCTION_V2017* occ_fonction_v2017 = (OCC_FONCTION_V2017*)&mggeo->get_occ_fonction();
    topods_wire=occ_fonction_v2017->get_TopoDS_Wire_id(idori);          
    if(ident!=-1)
    {
      MG_FACE* mgface=mggeo->get_mg_faceid(ident);
      MG_POUTRE* mgpoutre=mggeo->get_mg_poutreid(ident);
      if (mgface!=NULL)
      {
          mgbou=new OCC_BOUCLE(param[3].argument[0],id,mgface,topods_wire,&mggeo->get_occ_fonction());
          mggeo->ajouter_mg_boucle(mgbou,mgface);
          occ_fonction_v2017->ajouter_OCC_BOUCLE((OCC_BOUCLE*)mgbou);
      }
      if (mgpoutre!=NULL)
      {
          mgbou=new OCC_BOUCLE(param[3].argument[0],id,mgpoutre,topods_wire,&mggeo->get_occ_fonction());
          mggeo->ajouter_mg_boucle(mgbou,mgpoutre);
          occ_fonction_v2017->ajouter_OCC_BOUCLE((OCC_BOUCLE*)mgbou);
      }
    }
    else
    {
        mgbou=new OCC_BOUCLE(param[3].argument[0],id,topods_wire,&mggeo->get_occ_fonction());
        mggeo->ajouter_mg_boucle(mgbou);
        occ_fonction_v2017->ajouter_OCC_BOUCLE((OCC_BOUCLE*)mgbou);
    }
  }
#endif
  if(!import_occ_2017)
  {
    parse.decode(data.c_str(),"@,(@)",param+2);
    long ident=cid(param[2].argument[0]);
    MG_FACE* mgface=mggeo->get_mg_faceid(ident);
    MG_POUTRE* mgpoutre=mggeo->get_mg_poutreid(ident);
    if (mgface!=NULL)
    {
        mgbou=new MG_BOUCLE(id,mgface);
        mggeo->ajouter_mg_boucle(mgbou,mgface);
    }
    if (mgpoutre!=NULL)
    {
        mgbou=new MG_BOUCLE(id,mgpoutre);
        mggeo->ajouter_mg_boucle(mgbou,mgpoutre);
    }
  }
}

void MG_FILE::lire_MG_ARETE(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data,MG_GEOMETRIE *mggeo)
{
  parse.decode(data.c_str(),"@,@,@,@,@,@,(&)",param+2);
  long idcur=cid(param[3].argument[0]);
  int sens=atol(param[6].argument[0].c_str());
  long idori = stoi(param[2].argument[0]);
  MG_COURBE* mgcur=mggeo->get_mg_courbeid(idcur);
  MG_ARETE* mgarete;
#ifdef ALL_OCC
  if(strcmp(mggeo->get_type_geometrie(),"OCCV2017")==0)
  {
    TopoDS_Edge topods_edge;
    OCC_FONCTION_V2017* occ_fonction_v2017 = (OCC_FONCTION_V2017*)&mggeo->get_occ_fonction();
    topods_edge=occ_fonction_v2017->get_TopoDS_Edge_id(idori);
    mgarete= new OCC_ARETE(param[2].argument[0],id,mgcur,sens,topods_edge,&mggeo->get_occ_fonction());
    occ_fonction_v2017->ajouter_OCC_ARETE((OCC_ARETE*)mgarete);
  }
  else mgarete=new MG_ARETE(param[2].argument[0],id,mgcur,sens); 
#else
  mgarete=new MG_ARETE(param[2].argument[0],id,mgcur,sens);
#endif
  mggeo->ajouter_mg_arete(mgarete);
  int nb=atoi(param[7].argument[0].c_str());
  if (nb!=0) lire_ccf(version_fichier,nb,8,parse,param,mgarete);
}

void MG_FILE::lire_MG_SOMMET(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data,MG_GEOMETRIE *mggeo)
{
  if (version_fichier<2.2) parse.decode(data.c_str(),"@,@,@,(&)",param+2);
  else parse.decode(data.c_str(),"@,@,@,@,(&)",param+2);
  long idpoint=cid(param[3].argument[0]);
  long idori = stol(param[2].argument[0]);
  MG_POINT* mgpt=mggeo->get_mg_pointid(idpoint);
  MG_SOMMET* mgsom;
#ifdef ALL_OCC
  if(strcmp(mggeo->get_type_geometrie(),"OCCV2017")==0)
  {
    TopoDS_Vertex topods_vertex;
    OCC_FONCTION_V2017* occ_fonction_v2017 = (OCC_FONCTION_V2017*)&mggeo->get_occ_fonction();
    topods_vertex=occ_fonction_v2017->get_TopoDS_Vertex_id(idori);
    mgsom = new OCC_SOMMET(param[2].argument[0],id,mgpt,topods_vertex,&mggeo->get_occ_fonction());
    mggeo->ajouter_mg_sommet(mgsom);
    occ_fonction_v2017->ajouter_OCC_SOMMET((OCC_SOMMET*)mgsom);
  }
  else mgsom=new MG_SOMMET(param[2].argument[0],id,mgpt);
#else
  mgsom=new MG_SOMMET(param[2].argument[0],id,mgpt);
#endif
  mggeo->ajouter_mg_sommet(mgsom);
  int argccf=5;
  if (version_fichier>2.1)
      {
      argccf=6;
      int ipole=atoi(param[4].argument[0].c_str());
      if (ipole==1) mgsom->change_pole(true);
      }
  int nb=atoi(param[argccf-1].argument[0].c_str());
  if (nb!=0) lire_ccf(version_fichier,nb,argccf,parse,param,mgsom);
}


void MG_FILE::lire_MG_CG_MODELE(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data)
{
#ifdef ALL_OCC
  parse.decode(data.c_str(),"@,@,@,@,@",param+2);
  std::string nom=param[2].argument[0];
  long id_mg_geometrie = cid((char*)param[3].argument[0].c_str());
  int fusionner_entite_similaire = atoi((char*)param[4].argument[0].c_str());
  int importer_triangulation = atoi((char*)param[5].argument[0].c_str());
  double epsilon_triangulation = atof((char*)param[6].argument[0].c_str());
  MG_GEOMETRIE* mg_construction = get_mg_constructionid(id_mg_geometrie);
  MG_CG_MODELE* mgcg_modele=new MG_CG_MODELE(this,nom,mg_construction,id);
  mgcg_modele->change_fusionner_entite_similaire(fusionner_entite_similaire);
  mgcg_modele->change_importer_triangulation(importer_triangulation);
  mgcg_modele->change_epsilon_triangulation(epsilon_triangulation);
  ajouter_mgcg_modele(mgcg_modele);
#endif
}

void MG_FILE::lire_MG_CG_ASSEMBLAGE(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data)
{
#ifdef ALL_OCC  
  parse.decode(data.c_str(),"@,@,@,@,(&)",param+2);
  long id_modele = cid((char*)param[2].argument[0].c_str());
  std::string nom=param[3].argument[0];
  long id_mg_sous_geometrie = cid((char*)param[4].argument[0].c_str());
  long nb_mgcg_forme = atol((char*)param[5].argument[0].c_str());
  MG_CG_MODELE* mgcg_modele = get_mgcg_modeleid(id_modele);
  MG_SOUS_GEOMETRIE* mg_sous_geometrie;
  MG_GEOMETRIE* mg_geometrie = get_mg_geometrieid(id_mg_sous_geometrie);
  if(mg_geometrie!=NULL) mg_sous_geometrie = (MG_SOUS_GEOMETRIE*)mg_geometrie;
  else mg_sous_geometrie=NULL;
  MG_CG_ASSEMBLAGE *mgcg_assemblage=new MG_CG_ASSEMBLAGE(mgcg_modele,id,nom.c_str(),mg_sous_geometrie);
  for(long i=0;i<nb_mgcg_forme;i++)
  {
    unsigned long id2 = cid(param[6].argument[i]);
    mgcg_assemblage->ajouter_mgcg_forme(mgcg_modele->get_mgcg_formeid(id2),false);
  }           
  mgcg_modele->ajouter_mgcg_assemblage(mgcg_assemblage);
#endif
}

void MG_FILE::lire_MG_CG_GROUPE_FORME(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data)
{
#ifdef ALL_OCC
  // PARAM #                 2 3 4  5
  parse.decode(data.c_str(),"@,@,@,(&)",param+2);
  long id_mgcg_modele = cid(param[2].argument[0]);
  std::string nom=param[3].argument[0];
  long nb_forme = atol(param[4].argument[0].c_str());
  MG_CG_MODELE *mgcg_modele = get_mgcg_modeleid(id_mgcg_modele);
  MG_CG_GROUPE_FORME* mgcg_groupe_forme = MG_CG::creer_MG_CG_GROUPE_FORME(mgcg_modele,id,nom);  
  for(long i=0;i<nb_forme;i++)
  {
    long id_forme = cid(param[5].argument[i]);
    MG_CG_FORME* mgcg_forme = mgcg_modele->get_mgcg_formeid(id_forme);
    mgcg_groupe_forme->ajouter_mgcg_forme(mgcg_forme);
  }  
#endif
}

void MG_FILE::lire_MG_CG_FORME_ARETE(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data)
{
#ifdef ALL_OCC
  parse.decode(data.c_str(),"@,@,@,@,@,@,(&)",param+2);
  long id_modele = cid((char*)param[2].argument[0].c_str());
  MG_CG_MODELE* mgcg_modele = get_mgcg_modeleid(id_modele);
  int provenance_forme = atoi((char*)param[3].argument[0].c_str());
  int etat_forme = atoi((char*)param[4].argument[0].c_str());
  MG_ARETE* mg_arete;
  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()));
  MG_CG_OPERATEUR* mgcg_operateur_parent = mgcg_modele->get_mgcg_operateurid(cid((char*)param[6].argument[0].c_str()));
  MG_CG_FORME* forme = MG_CG::creer_MG_CG_FORME_ARETE(mgcg_modele,provenance_forme,etat_forme,id,mg_arete);
  forme->change_mgcg_operateur_parent(mgcg_operateur_parent);
  mgcg_operateur_parent->ajouter_mgcg_forme_sortie(forme);
#endif
}

void MG_FILE::lire_MG_CG_FORME_ARETE_DROITE(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data)
{
#ifdef ALL_OCC
  parse.decode(data.c_str(),"@,@,@,@,@,@,@,@,@,@,(&)",param+2);
  long id_modele = cid((char*)param[2].argument[0].c_str());
  MG_CG_MODELE* mgcg_modele = get_mgcg_modeleid(id_modele);
  int etat_forme = atoi((char*)param[3].argument[0].c_str());
  MG_ARETE* mg_arete;
  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()));
  double x1 = atof((char*)param[5].argument[0].c_str());
  double y1 = atof((char*)param[6].argument[0].c_str());
  double z1 = atof((char*)param[7].argument[0].c_str());
  double x2 = atof((char*)param[8].argument[0].c_str());
  double y2 = atof((char*)param[9].argument[0].c_str());
  double z2 = atof((char*)param[10].argument[0].c_str());
  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);
#endif
}

void MG_FILE::lire_MG_CG_FORME_VOLUME(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data)
{
#ifdef ALL_OCC
  parse.decode(data.c_str(),"@,@,@,@,@,@,(&)",param+2);
  long id_modele = cid((char*)param[2].argument[0].c_str());
  MG_CG_MODELE* mgcg_modele = get_mgcg_modeleid(id_modele);
  int provenance_forme = atoi((char*)param[3].argument[0].c_str());
  int etat_forme = atoi((char*)param[4].argument[0].c_str());
  MG_VOLUME* mg_volume;
  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()));
  MG_CG_OPERATEUR* mgcg_operateur_parent = mgcg_modele->get_mgcg_operateurid(cid((char*)param[6].argument[0].c_str()));
  MG_CG_FORME* forme = MG_CG::creer_MG_CG_FORME_VOLUME(mgcg_modele,provenance_forme,etat_forme,id,mg_volume);
  forme->change_mgcg_operateur_parent(mgcg_operateur_parent);
  if (mgcg_operateur_parent!=NULL) mgcg_operateur_parent->ajouter_mgcg_forme_sortie(forme);
#endif
}

void MG_FILE::lire_MG_CG_FORME_VOLUME_BOITE(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data)
{
#ifdef ALL_OCC
  parse.decode(data.c_str(),"@,@,@,@,@,@,@,@,@,@,(&)",param+2);
  long id_modele = cid((char*)param[2].argument[0].c_str());
  MG_CG_MODELE* mgcg_modele = get_mgcg_modeleid(id_modele);
  int etat_forme = atoi((char*)param[3].argument[0].c_str());
  MG_VOLUME* mg_volume;
  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()));
  double x1 = atof((char*)param[5].argument[0].c_str());
  double y1 = atof((char*)param[6].argument[0].c_str());
  double z1 = atof((char*)param[7].argument[0].c_str());
  double x2 = atof((char*)param[8].argument[0].c_str());
  double y2 = atof((char*)param[9].argument[0].c_str());
  double z2 = atof((char*)param[10].argument[0].c_str());
  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);
#endif
}

void MG_FILE::lire_MG_CG_FORME_VOLUME_SPHERE(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data)
{
#ifdef ALL_OCC
  // PARAM #                 2 3 4 5 6 7 8  
  parse.decode(data.c_str(),"@,@,@,@,@,@,@,@,@,@,(&)",param+2);
  long id_modele = cid((char*)param[2].argument[0].c_str());
  MG_CG_MODELE* mgcg_modele = get_mgcg_modeleid(id_modele);
  int etat_forme = atoi((char*)param[3].argument[0].c_str());
  MG_VOLUME* mg_volume;
  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()));
  double centre_x = atof((char*)param[5].argument[0].c_str());
  double centre_y = atof((char*)param[6].argument[0].c_str());
  double centre_z = atof((char*)param[7].argument[0].c_str());
  double rayon = atof((char*)param[8].argument[0].c_str());
  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);
#endif
}

void MG_FILE::lire_MG_CG_FORME_VOLUME_ELLIPSOIDE(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data)
{
#ifdef ALL_OCC
  // PARAM #                 2 3 4 5 6 7 8 9 101112
  parse.decode(data.c_str(),"@,@,@,@,@,@,@,@,@,@,@,(&)",param+2);
  long id_modele = cid((char*)param[2].argument[0].c_str());
  MG_CG_MODELE* mgcg_modele = get_mgcg_modeleid(id_modele);
  int etat_forme = atoi((char*)param[3].argument[0].c_str());
  MG_VOLUME* mg_volume;
  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()));
  double centre_x = atof((char*)param[5].argument[0].c_str());
  double centre_y = atof((char*)param[6].argument[0].c_str());
  double centre_z = atof((char*)param[7].argument[0].c_str());
  double direction_x = atof((char*)param[8].argument[0].c_str());
  double direction_y = atof((char*)param[9].argument[0].c_str());
  double direction_z = atof((char*)param[10].argument[0].c_str());
  double rayon_majeur = atof((char*)param[11].argument[0].c_str());
  double rayon_mineur = atof((char*)param[12].argument[0].c_str());
  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);
#endif
}

void MG_FILE::lire_MG_CG_FORME_VOLUME_CYLINDRE(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data)
{
#ifdef ALL_OCC
  // PARAM #                 2 3 4 5 6 7 8 9 101112
  parse.decode(data.c_str(),"@,@,@,@,@,@,@,@,@,@,@,(&)",param+2);
  long id_modele = cid((char*)param[2].argument[0].c_str());
  MG_CG_MODELE* mgcg_modele = get_mgcg_modeleid(id_modele);
  int etat_forme = atoi((char*)param[3].argument[0].c_str());
  MG_VOLUME* mg_volume;
  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()));
  double extremite_x = atof((char*)param[5].argument[0].c_str());
  double extremite_y = atof((char*)param[6].argument[0].c_str());
  double extremite_z = atof((char*)param[7].argument[0].c_str());
  double direction_x = atof((char*)param[8].argument[0].c_str());
  double direction_y = atof((char*)param[9].argument[0].c_str());
  double direction_z = atof((char*)param[10].argument[0].c_str());
  double rayon = atof((char*)param[11].argument[0].c_str());
  double longueur = atof((char*)param[12].argument[0].c_str());
  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);
#endif
}

void MG_FILE::lire_MG_CG_FORME_VOLUME_CONE(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data)
{
#ifdef ALL_OCC
  // PARAM #                 2 3 4 5 6 7 8 9 101112
  parse.decode(data.c_str(),"@,@,@,@,@,@,@,@,@,@,@,(&)",param+2);
  long id_modele = cid((char*)param[2].argument[0].c_str());
  MG_CG_MODELE* mgcg_modele = get_mgcg_modeleid(id_modele);
  int etat_forme = atoi((char*)param[3].argument[0].c_str());
  MG_VOLUME* mg_volume;
  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()));
  double extremite_x = atof((char*)param[5].argument[0].c_str());
  double extremite_y = atof((char*)param[6].argument[0].c_str());
  double extremite_z = atof((char*)param[7].argument[0].c_str());
  double direction_x = atof((char*)param[8].argument[0].c_str());
  double direction_y = atof((char*)param[9].argument[0].c_str());
  double direction_z = atof((char*)param[10].argument[0].c_str());
  double rayon = atof((char*)param[11].argument[0].c_str());
  double longueur = atof((char*)param[12].argument[0].c_str());
  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);
#endif
}

void MG_FILE::lire_MG_CG_FORME_VOLUME_TORE(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data)
{
#ifdef ALL_OCC
  // PARAM #                 2 3 4 5 6 7 8 9 1011121314
  parse.decode(data.c_str(),"@,@,@,@,@,@,@,@,@,@,@,@,@,(&)",param+2);
  long id_modele = cid((char*)param[2].argument[0].c_str());
  MG_CG_MODELE* mgcg_modele = get_mgcg_modeleid(id_modele);
  int etat_forme = atoi((char*)param[3].argument[0].c_str());
  MG_VOLUME* mg_volume;
  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()));
  double centre_x = atof((char*)param[5].argument[0].c_str());
  double centre_y = atof((char*)param[6].argument[0].c_str());
  double centre_z = atof((char*)param[7].argument[0].c_str());
  double direction_x = atof((char*)param[8].argument[0].c_str());
  double direction_y = atof((char*)param[9].argument[0].c_str());
  double direction_z = atof((char*)param[10].argument[0].c_str());
  double rayon_cercle = atof((char*)param[11].argument[0].c_str());
  double rayon_tore = atof((char*)param[12].argument[0].c_str());
  double angle_seg = atof((char*)param[13].argument[0].c_str());
  double angle_rotation = atof((char*)param[14].argument[0].c_str());
  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);
#endif
}

void MG_FILE::lire_MG_CG_FORME_MULTIPLE(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data)
{
#ifdef ALL_OCC
  // PARAM #                 2 3 4 5  6  7  8  9
  parse.decode(data.c_str(),"@,@,@,@,(&),@,(&),@",param+2);
  long id_modele = cid((char*)param[2].argument[0].c_str());
  MG_CG_MODELE* mgcg_modele = get_mgcg_modeleid(id_modele);
  int provenance_forme = atoi((char*)param[3].argument[0].c_str());
  int etat_forme = atoi((char*)param[4].argument[0].c_str());
  std::vector<MG_ELEMENT_TOPOLOGIQUE*> vector_mg_element_topologique;
  std::vector<MG_ELEMENT_COTOPOLOGIQUE*> vector_mg_element_cotopologique;
  long nb_mg_element_topologique = atol((char*)param[5].argument[0].c_str());
  for(long i=0;i<nb_mg_element_topologique;i++)
  {
    vector_mg_element_topologique.push_back(mgcg_modele->get_mg_geometrie()->get_mg_element_topologiqueid(cid((char*)param[6].argument[i].c_str())));
  }
  long nb_mg_element_cotopologique = atol((char*)param[7].argument[0].c_str());
  for(long i=0;i<nb_mg_element_cotopologique;i++)
  {
    vector_mg_element_cotopologique.push_back(mgcg_modele->get_mg_geometrie()->get_mg_element_cotopologiqueid(cid((char*)param[8].argument[i].c_str())));
  }
  MG_CG_OPERATEUR* mgcg_operateur_parent = mgcg_modele->get_mgcg_operateurid(cid((char*)param[9].argument[0].c_str()));
  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);
  forme->change_mgcg_operateur_parent(mgcg_operateur_parent);
#endif
}

void MG_FILE::lire_MG_CG_FORME_MULTI_VOLUME(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data)
{
#ifdef ALL_OCC
  // PARAM #                 2 3 4 5  6  7
  parse.decode(data.c_str(),"@,@,@,@,(&),@",param+2);
  long id_modele = cid((char*)param[2].argument[0].c_str());
  MG_CG_MODELE* mgcg_modele = get_mgcg_modeleid(id_modele);
  int provenance_forme = atoi((char*)param[3].argument[0].c_str());
  int etat_forme = atoi((char*)param[4].argument[0].c_str());
  std::vector<MG_VOLUME*> vector_mg_volume;
  long nb_mg_volume = atol((char*)param[5].argument[0].c_str());
  for(long i=0;i<nb_mg_volume;i++)
  {
    vector_mg_volume.push_back(mgcg_modele->get_mg_geometrie()->get_mg_volumeid(cid((char*)param[6].argument[i].c_str())));
  }
  MG_CG_OPERATEUR* mgcg_operateur_parent = mgcg_modele->get_mgcg_operateurid(cid((char*)param[7].argument[0].c_str()));
  MG_CG_FORME* forme = MG_CG::creer_MG_CG_FORME_MULTI_VOLUME(mgcg_modele,provenance_forme,etat_forme,id,vector_mg_volume);
  forme->change_mgcg_operateur_parent(mgcg_operateur_parent);
#endif
}

void MG_FILE::lire_MG_CG_OP_BOOL_UNION(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data)
{
#ifdef ALL_OCC
  // PARAM #                 2 3 4 5 6 7
  parse.decode(data.c_str(),"@,@,@,@,@,@",param+2);
  long id_modele = cid((char*)param[2].argument[0].c_str());
  MG_CG_MODELE* mgcg_modele = get_mgcg_modeleid(id_modele);
  int semantique = atoi((char*)param[3].argument[0].c_str());
  int etat_operateur = atoi((char*)param[4].argument[0].c_str());
  MG_CG_FORME* mgcg_forme_entree_1=NULL;
  MG_CG_FORME* mgcg_forme_entree_2=NULL;
  long id_forme_entree_1 = cid((char*)param[5].argument[0].c_str());
  if(id_forme_entree_1!=0) mgcg_forme_entree_1=mgcg_modele->get_mgcg_formeid(id_forme_entree_1);
  long id_forme_entree_2 = cid((char*)param[6].argument[0].c_str());
  if(id_forme_entree_2!=0) mgcg_forme_entree_2=mgcg_modele->get_mgcg_formeid(id_forme_entree_2);
  long id_forme_sortie = cid((char*)param[7].argument[0].c_str());
  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);
#endif
}

void MG_FILE::lire_MG_CG_OP_BOOL_DIFFERENCE(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data)
{
#ifdef ALL_OCC
  // PARAM #                 2 3 4 5 6 7
  parse.decode(data.c_str(),"@,@,@,@,@,@",param+2);
  long id_modele = cid((char*)param[2].argument[0].c_str());
  MG_CG_MODELE* mgcg_modele = get_mgcg_modeleid(id_modele);
  int semantique = atoi((char*)param[3].argument[0].c_str());
  int etat_operateur = atoi((char*)param[4].argument[0].c_str());
  MG_CG_FORME* mgcg_forme_entree_1=NULL;
  MG_CG_FORME* mgcg_forme_entree_2=NULL;
  long id_forme_entree_1 = cid((char*)param[5].argument[0].c_str());
  if(id_forme_entree_1!=0) mgcg_forme_entree_1=mgcg_modele->get_mgcg_formeid(id_forme_entree_1);
  long id_forme_entree_2 = cid((char*)param[6].argument[0].c_str());
  if(id_forme_entree_2!=0) mgcg_forme_entree_2=mgcg_modele->get_mgcg_formeid(id_forme_entree_2);
  long id_forme_sortie = cid((char*)param[7].argument[0].c_str());
  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);
#endif
}

void MG_FILE::lire_MG_CG_OP_BOOL_INTERSECTION(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data)
{
#ifdef ALL_OCC
  // PARAM #                 2 3 4 5 6 7
  parse.decode(data.c_str(),"@,@,@,@,@,@",param+2);
  long id_modele = cid((char*)param[2].argument[0].c_str());
  MG_CG_MODELE* mgcg_modele = get_mgcg_modeleid(id_modele);
  int semantique = atoi((char*)param[3].argument[0].c_str());
  int etat_operateur = atoi((char*)param[4].argument[0].c_str());
  MG_CG_FORME* mgcg_forme_entree_1=NULL;
  MG_CG_FORME* mgcg_forme_entree_2=NULL;
  long id_forme_entree_1 = cid((char*)param[5].argument[0].c_str());
  if(id_forme_entree_1!=0) mgcg_forme_entree_1=mgcg_modele->get_mgcg_formeid(id_forme_entree_1);
  long id_forme_entree_2 = cid((char*)param[6].argument[0].c_str());
  if(id_forme_entree_2!=0) mgcg_forme_entree_2=mgcg_modele->get_mgcg_formeid(id_forme_entree_2);
  long id_forme_sortie = cid((char*)param[7].argument[0].c_str());
  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);
#endif
}

void MG_FILE::lire_MG_CG_OP_BOOL_FRAGMENT(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data)
{
#ifdef ALL_OCC
  // PARAM #                 2 3 4 5 6 7
  parse.decode(data.c_str(),"@,@,@,@,@,@",param+2);
  long id_modele = cid((char*)param[2].argument[0].c_str());
  MG_CG_MODELE* mgcg_modele = get_mgcg_modeleid(id_modele);
  int semantique = atoi((char*)param[3].argument[0].c_str());
  int etat_operateur = atoi((char*)param[4].argument[0].c_str());
  MG_CG_FORME* mgcg_forme_entree_1=NULL;
  MG_CG_FORME* mgcg_forme_entree_2=NULL;
  long id_forme_entree_1 = cid((char*)param[5].argument[0].c_str());
  if(id_forme_entree_1!=0) mgcg_forme_entree_1=mgcg_modele->get_mgcg_formeid(id_forme_entree_1);
  long id_forme_entree_2 = cid((char*)param[6].argument[0].c_str());
  if(id_forme_entree_2!=0) mgcg_forme_entree_2=mgcg_modele->get_mgcg_formeid(id_forme_entree_2);
  long id_forme_sortie = cid((char*)param[7].argument[0].c_str());
  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);
#endif
}

void MG_FILE::lire_MG_CG_OP_INCLUSION_MATRICE(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data)
{
#ifdef ALL_OCC
  // PARAM #                 2 3 4 5 6 7 8
  parse.decode(data.c_str(),"@,@,@,@,@,@,@",param+2);
  long id_modele = cid((char*)param[2].argument[0].c_str());
  MG_CG_MODELE* mgcg_modele = get_mgcg_modeleid(id_modele);
  int semantique = atoi((char*)param[3].argument[0].c_str());
  int etat_operateur = atoi((char*)param[4].argument[0].c_str());
  MG_CG_FORME* mgcg_forme_inclusion_entree=NULL;
  MG_CG_FORME* mgcg_forme_matrice_entree=NULL;
  long id_forme_inclusion_entree = cid((char*)param[5].argument[0].c_str());
  if(id_forme_inclusion_entree!=0) mgcg_forme_inclusion_entree=mgcg_modele->get_mgcg_formeid(id_forme_inclusion_entree);
  long id_forme_matrice_entree = cid((char*)param[6].argument[0].c_str());
  if(id_forme_matrice_entree!=0) mgcg_forme_matrice_entree=mgcg_modele->get_mgcg_formeid(id_forme_matrice_entree);
  long id_forme_inclusion_sortie = cid((char*)param[7].argument[0].c_str());
  long id_forme_matrice_sortie = cid((char*)param[8].argument[0].c_str());
  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);
#endif
}

void MG_FILE::lire_MG_CG_OP_TRANSF_ROTATION(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data)
{
#ifdef ALL_OCC
  // PARAM #                 2 3 4 5 6 7 8 9 10  12
  // PARAM #                                   11  13
  parse.decode(data.c_str(),"@,@,@,@,@,@,@,@,@,@,@,@",param+2);
  long id_modele = cid((char*)param[2].argument[0].c_str());
  MG_CG_MODELE* mgcg_modele = get_mgcg_modeleid(id_modele);
  int semantique = atoi((char*)param[3].argument[0].c_str());
  int etat_operateur = atoi((char*)param[4].argument[0].c_str());
  MG_CG_FORME* mgcg_forme_entree=NULL;
  long id_forme_entree = cid((char*)param[5].argument[0].c_str());
  if(id_forme_entree!=0) mgcg_forme_entree=mgcg_modele->get_mgcg_formeid(id_forme_entree);
  long id_forme_sortie = cid((char*)param[6].argument[0].c_str());
  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);
  double x = atof((char*)param[7].argument[0].c_str());
  double y = atof((char*)param[8].argument[0].c_str());
  double z = atof((char*)param[9].argument[0].c_str());
  double w = atof((char*)param[10].argument[0].c_str());
  double centre_x = atof((char*)param[11].argument[0].c_str());
  double centre_y = atof((char*)param[12].argument[0].c_str());
  double centre_z = atof((char*)param[13].argument[0].c_str());
  OT_QUATERNION ot_quaternion(x,y,z,w);
  mgcg_op_transf_rotation->change_rotation(ot_quaternion);
  mgcg_op_transf_rotation->change_centre_rotation(centre_x,centre_y,centre_z);
#endif
}

void MG_FILE::lire_MG_CG_OP_TRANSF_TRANSLATION(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data)
{
#ifdef ALL_OCC
  // PARAM #                 2 3 4 5 6 7 8 9                  
  parse.decode(data.c_str(),"@,@,@,@,@,@,@,@,",param+2);
  long id_modele = cid((char*)param[2].argument[0].c_str());
  MG_CG_MODELE* mgcg_modele = get_mgcg_modeleid(id_modele);
  int semantique = atoi((char*)param[3].argument[0].c_str());
  int etat_operateur = atoi((char*)param[4].argument[0].c_str());
  MG_CG_FORME* mgcg_forme_entree=NULL;
  long id_forme_entree = cid((char*)param[5].argument[0].c_str());
  if(id_forme_entree!=0) mgcg_forme_entree=mgcg_modele->get_mgcg_formeid(id_forme_entree);
  long id_forme_sortie = cid((char*)param[6].argument[0].c_str());
  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);
  double x = atof((char*)param[7].argument[0].c_str());
  double y = atof((char*)param[8].argument[0].c_str());
  double z = atof((char*)param[9].argument[0].c_str());
  mgcg_op_transf_translation->change_translation(x,y,z);
#endif
}

void MG_FILE::lire_MG_CG_OP_TRANSF_ECHELLE(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data)
{
#ifdef ALL_OCC
  // PARAM #                 2 3 4 5 6 7 8 9 10                 
  parse.decode(data.c_str(),"@,@,@,@,@,@,@,@,@,",param+2);
  long id_modele = cid((char*)param[2].argument[0].c_str());
  MG_CG_MODELE* mgcg_modele = get_mgcg_modeleid(id_modele);
  int semantique = atoi((char*)param[3].argument[0].c_str());
  int etat_operateur = atoi((char*)param[4].argument[0].c_str());
  MG_CG_FORME* mgcg_forme_entree=NULL;
  long id_forme_entree = cid((char*)param[5].argument[0].c_str());
  if(id_forme_entree!=0) mgcg_forme_entree=mgcg_modele->get_mgcg_formeid(id_forme_entree);
  long id_forme_sortie = cid((char*)param[6].argument[0].c_str());
  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);
  double x = atof((char*)param[7].argument[0].c_str());
  double y = atof((char*)param[8].argument[0].c_str());
  double z = atof((char*)param[9].argument[0].c_str());
  double facteur = atof((char*)param[10].argument[0].c_str());
  mgcg_op_transf_echelle->change_centre_echelle(x,y,z);
  mgcg_op_transf_echelle->change_facteur_echelle(facteur);
#endif
}

void MG_FILE::lire_MG_CG_OP_TRANSF_DECALLAGE(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data)
{
#ifdef ALL_OCC
  // PARAM #                 2 3 4 5 6 7                  
  parse.decode(data.c_str(),"@,@,@,@,@,@,",param+2);
  long id_modele = cid((char*)param[2].argument[0].c_str());
  MG_CG_MODELE* mgcg_modele = get_mgcg_modeleid(id_modele);
  int semantique = atoi((char*)param[3].argument[0].c_str());
  int etat_operateur = atoi((char*)param[4].argument[0].c_str());
  MG_CG_FORME* mgcg_forme_entree=NULL;
  long id_forme_entree = cid((char*)param[5].argument[0].c_str());
  if(id_forme_entree!=0) mgcg_forme_entree=mgcg_modele->get_mgcg_formeid(id_forme_entree);
  long id_forme_sortie = cid((char*)param[6].argument[0].c_str());
  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);
  double decallage = atof((char*)param[7].argument[0].c_str());
  mgcg_op_transf_decallage->change_decallage(decallage);
#endif
}

void MG_FILE::lire_MG_CG_INFO_STRING(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data)
{
#ifdef ALL_OCC
  // PARAM #                 2 3                 
  parse.decode(data.c_str(),"@,@",param+2);
  std::string identifiant = param[2].argument[0];
  std::string valeur = param[3].argument[0];
  MG_IDENTIFICATEUR *mg_id=NULL;
  LISTE_MGCG_MODELE::iterator it_modele=lst_mgcg_modele.begin();
  while(mg_id==NULL && it_modele!=lst_mgcg_modele.end())
  {
    MG_CG_MODELE* modele = it_modele->second;
    if(modele->get_id()==id)
    {
      mg_id=modele;
    }
    else
    {
      mg_id=modele->get_mg_identificateur(id);
    }
    it_modele++;
  }
  if(mg_id!=NULL)
  {
    MG_CONSTRUCTION_GEOMETRIQUE* mg_constr_geo = (MG_CONSTRUCTION_GEOMETRIQUE*)mg_id;
    MG_CG_INFO_STRING* info_str = MG_CG::creer_MG_CG_INFO_STRING(mg_constr_geo,id,identifiant,valeur);
  }
#endif
}

void MG_FILE::lire_MG_CG_INFO_DOUBLE(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data)
{
#ifdef ALL_OCC  
  // PARAM #                 2 3                 
  parse.decode(data.c_str(),"@,@",param+2);
  std::string identifiant = param[2].argument[0];
  double valeur = atof(param[3].argument[0].c_str());
  MG_IDENTIFICATEUR *mg_id=NULL;
  LISTE_MGCG_MODELE::iterator it_modele=lst_mgcg_modele.begin();
  while(mg_id==NULL && it_modele!=lst_mgcg_modele.end())
  {
    MG_CG_MODELE* modele = it_modele->second;
    if(modele->get_id()==id)
    {
      mg_id=modele;
    }
    else
    {
      mg_id=modele->get_mg_identificateur(id);
    }
    it_modele++;
  }
  if(mg_id!=NULL)
  {
    MG_CONSTRUCTION_GEOMETRIQUE* mg_constr_geo = (MG_CONSTRUCTION_GEOMETRIQUE*)mg_id;
    MG_CG_INFO_DOUBLE* info_dbl = MG_CG::creer_MG_CG_INFO_DOUBLE(mg_constr_geo,id,identifiant,valeur);
  }
#endif
}

void MG_FILE::lire_MG_CG_INFO_VCT_DOUBLE(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data)
{
#ifdef ALL_OCC
  // PARAM #                 2 3  4               
  parse.decode(data.c_str(),"@,@,(&)",param+2);
  std::string identifiant = param[2].argument[0];
  long nb_valeur = atol(param[3].argument[0].c_str());
  std::vector<double> vector_valeur;
  for(long i=0;i<nb_valeur;i++)
  {
    double valeur = atof(param[4].argument[i].c_str());
    vector_valeur.push_back(valeur);
  }
  MG_IDENTIFICATEUR *mg_id=NULL;
  LISTE_MGCG_MODELE::iterator it_modele=lst_mgcg_modele.begin();
  while(mg_id==NULL && it_modele!=lst_mgcg_modele.end())
  {
    MG_CG_MODELE* modele = it_modele->second;
    if(modele->get_id()==id)
    {
      mg_id=modele;
    }
    else
    {
      mg_id=modele->get_mg_identificateur(id);
    }
    it_modele++;
  }
  if(mg_id!=NULL)
  {
    MG_CONSTRUCTION_GEOMETRIQUE* mg_constr_geo = (MG_CONSTRUCTION_GEOMETRIQUE*)mg_id;
    MG_CG_INFO_VCT_DOUBLE* info_dbl = MG_CG::creer_MG_CG_INFO_VCT_DOUBLE(mg_constr_geo,id,identifiant,vector_valeur);
  }
#endif
}


int MG_FILE::lire(char* chemin)
{
    FILE *in;
    //char ligne[3000];
    in=fopen(chemin,"rt");
    if (in==NULL) return 0;
    PARS_ARGUMENT param[100];
    PARSE parse;

    MG_GEOMETRIE *mggeo;
    MG_ARBRE* arbre;
#ifdef WINDOWS_VERSION
    std::multimap<CAD4FE::MCVertex*, unsigned long> mapMergedRefVertices;
#endif
    bool updatedMergedRefVertices = false;
    version_fichier=1.0;
    std::vector<unsigned long> volumemince;
    do
    {
        int ierr;
        std::string ligne=parse.lire(in,';',&ierr);
        parse.decode(ligne.c_str(),"@;",param);
        const char *chaine=param[0].argument[0].c_str();
        if ((chaine[0]=='/') && (chaine[1]=='/'))
        {
            if ((chaine[2]=='*')&&(chaine[3]=='i'))
            {
                unsigned long id;
                sscanf(chaine,"//*i:%lu;",&id);
                entiteidmax=id;
            }
            if ((chaine[2]=='*')&&(chaine[3]=='v'))
                sscanf(chaine,"//*v:%lf;",&version_fichier);
        }
        else if (param[0].argument[0]!="FIN")
        {
            parse.decode(ligne.c_str(),"%@=@(@);",param);
            std::string entite=param[1].argument[0];
            long id=atol(param[0].argument[0].c_str());
            std::string data=param[2].argument[0] ;
            MG_MAILLAGE *mgmai;
            FEM_MAILLAGE *femmai;
            if (entite=="GEOMETRIE")
            {
                parse.decode(data.c_str(),"@,@,@,@",param+2);
                double unite=atof(param[2].argument[0].c_str());
                std::string typegeo=param[3].argument[0];
                std::string chemin_geo=param[4].argument[0];
                if (typegeo=="VIRTUEL")
                  {     
                  mggeo=new MG_GEOMETRIE((char*)typegeo.c_str(),id,(char*)chemin_geo.c_str(),unite);
                  ajouter_mg_geometrie(mggeo);
                  }
#ifdef BREP_STEP
                if (typegeo=="STEP")
                {
                    mggeo=new MG_GEOMETRIE((char*)"STEP",id,(char *)chemin_geo.c_str(),unite);
                    ajouter_mg_geometrie(mggeo);
                }
#endif
#ifdef BREP_SAT
                if (typegeo=="ACIS")
                {
                    mggeo=new MG_GEOMETRIE((char*)"ACIS",id,(char *)chemin_geo.c_str(),unite);
                    ajouter_mg_geometrie(mggeo);
                }
#endif

#ifdef BREP_OCC
                if (typegeo=="OCC")
                {
                    mggeo=new MG_GEOMETRIE((char*)"OCC",id,chemin_geo.c_str(),unite);
                    ajouter_mg_geometrie(mggeo);
                }
                if (typegeo=="OCCV2015")
                {
                    mggeo=new MG_GEOMETRIE((char*)"OCCV2015",id,chemin_geo.c_str(),unite);
                    ajouter_mg_geometrie(mggeo);
                }
#endif
#ifdef ALL_OCC
                if (typegeo=="OCCV2017")
                {
                    mggeo=new MG_GEOMETRIE((char*)"OCCV2017",id,chemin_geo.c_str(),unite);
                    ajouter_mg_geometrie(mggeo);
                    OCC_FONCTION_V2017* occ_fonction_v2017 = (OCC_FONCTION_V2017*)&mggeo->get_occ_fonction();
                    std::string chemin_caf = str_dossier + chemin_geo + ".ocaf";
                    char* chemin_caf_char = (char*)chemin_caf.c_str();
                    occ_fonction_v2017->ouvrir_fichier_OCAF(chemin_caf_char);
                }
#endif
            std::string nommat="";
            if (param[5].argument[0]!="")
                    nommat=param[5].argument[0];
                mggeo->change_gest_materiau((char*)nommat.c_str());
            }
            if (entite=="CONSTRUCTION")
            {
              MG_GEOMETRIE * mgconstruction;
                parse.decode(data.c_str(),"@,@,@,@",param+2);
                double unite=atof(param[2].argument[0].c_str());
                std::string typegeo=param[3].argument[0];
                std::string chemin_geo=param[4].argument[0];
#ifdef ALL_OCC
                if (typegeo=="OCCV2017")
                {
                    mgconstruction=new MG_GEOMETRIE((char*)"OCCV2017",id,chemin_geo.c_str(),unite);
                    mggeo=mgconstruction;
                    mgconstruction->change_est_construction(true);
                    ajouter_mg_construction(mgconstruction);
                    OCC_FONCTION_V2017* occ_fonction_v2017 = (OCC_FONCTION_V2017*)&mgconstruction->get_occ_fonction();
                    std::string chemin_caf = str_dossier + chemin_geo + ".ocaf";
                    char* chemin_caf_char = (char*)chemin_caf.c_str();
                    occ_fonction_v2017->ouvrir_fichier_OCAF(chemin_caf_char);
                }
#endif
            if (typegeo=="VIRTUEL")
                {       
                mgconstruction=new MG_GEOMETRIE((char*)typegeo.c_str(),id,(char*)chemin_geo.c_str(),unite);
                mggeo=mgconstruction;
                mggeo->change_est_construction(true);
                ajouter_mg_construction(mggeo);
                }
            std::string nommat="";
                if (param[5].argument[0]!="")
                    nommat=param[5].argument[0];
                mgconstruction->change_gest_materiau((char*)nommat.c_str());
            }
#ifdef CSG_OCC           
            if (entite=="ARBRE")
              {
              parse.decode(data.c_str(),"@",param+2);
              std::string nom=param[2].argument[0];
              arbre=new MG_ARBRE(id,nom.c_str());
              ajouter_mg_arbre(arbre);
              }
            if  (entite == "ASSEMBLAGE")
              {
              parse.decode(data.c_str(),"@,@,(&)",param+2);
              std::string nom=param[2].argument[0];
              int nb_primitive = atoi((char*)param[3].argument[0].c_str());
              MG_ASSEMBLAGE *mgassembl=new MG_ASSEMBLAGE(id,nom.c_str());
              for(int i=0;i<nb_primitive;i++)
              {
                unsigned long id2 = cid(param[4].argument[i]);
                mgassembl->ajouter_mg_primitive(id2);
              }       
              arbre->ajouter_mg_assemblage(mgassembl);
              }
            if (entite=="BOITE")
              {
              parse.decode(data.c_str(),"@,@,@,@,@,@",param+2);
              double x1=atof((char*)param[2].argument[0].c_str());
              double y1=atof((char*)param[3].argument[0].c_str());
              double z1=atof((char*)param[4].argument[0].c_str());
              double x2=atof((char*)param[5].argument[0].c_str());
              double y2=atof((char*)param[6].argument[0].c_str());
              double z2=atof((char*)param[7].argument[0].c_str());
              MG_PRIMITIVE_BOITE *b=new MG_PRIMITIVE_BOITE(id,x1,y1,z1,x2,y2,z2);
              b->construit();
              arbre->ajouter_mg_primitive(b);
              }
            if (entite=="SPHERE")
              {
              parse.decode(data.c_str(),"@,@,@,@",param+2);
              double centre_x=atof((char*)param[2].argument[0].c_str());
              double centre_y=atof((char*)param[3].argument[0].c_str());
              double centre_z=atof((char*)param[4].argument[0].c_str());
              double rayon=atof((char*)param[5].argument[0].c_str());
              MG_PRIMITIVE_SPHERE *b=new MG_PRIMITIVE_SPHERE(id,centre_x,centre_y,centre_z,rayon);
              b->construit();
              arbre->ajouter_mg_primitive(b);
              }
            if (entite=="ELLIPSOIDE_REVOLUTION")
              {
              parse.decode(data.c_str(),"@,@,@,@,@,@,@,@",param+2);
              double centre_x=atof((char*)param[2].argument[0].c_str());
              double centre_y=atof((char*)param[3].argument[0].c_str());
              double centre_z=atof((char*)param[4].argument[0].c_str());
              double axe_x=atof((char*)param[5].argument[0].c_str());
              double axe_y=atof((char*)param[6].argument[0].c_str());
              double axe_z=atof((char*)param[7].argument[0].c_str());
              double rayon_majeur=atof((char*)param[8].argument[0].c_str());
              double rayon_mineur=atof((char*)param[9].argument[0].c_str());
              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);
              b->construit();
              arbre->ajouter_mg_primitive(b);
              }
            if (entite=="CYLINDRE")
              {
              parse.decode(data.c_str(),"@,@,@,@,@,@,@",param+2);
              double extremite_x=atof((char*)param[2].argument[0].c_str());
              double extremite_y=atof((char*)param[3].argument[0].c_str());
              double extremite_z=atof((char*)param[4].argument[0].c_str());
              double longitude=atof((char*)param[5].argument[0].c_str());
              double latitude=atof((char*)param[6].argument[0].c_str());
              double rayon=atof((char*)param[7].argument[0].c_str());
              double longueur=atof((char*)param[8].argument[0].c_str());
              MG_PRIMITIVE_CYLINDRE *b=new MG_PRIMITIVE_CYLINDRE(id,extremite_x,extremite_y,extremite_z,longitude,latitude,rayon,longueur);
              b->construit();
              arbre->ajouter_mg_primitive(b);
              }
             if (entite=="TORE")
              {
              parse.decode(data.c_str(),"@,@,@,@,@,@,@",param+2);
              double centre_x=atof((char*)param[2].argument[0].c_str());
              double centre_y=atof((char*)param[3].argument[0].c_str());
              double centre_z=atof((char*)param[4].argument[0].c_str());
              double longitude=atof((char*)param[5].argument[0].c_str());
              double latitude=atof((char*)param[6].argument[0].c_str());
              double rayon_cercle=atof((char*)param[7].argument[0].c_str());
              double rayon_tore=atof((char*)param[8].argument[0].c_str());
              MG_PRIMITIVE_TORE *b=new MG_PRIMITIVE_TORE(id,centre_x,centre_y,centre_z,longitude,latitude,rayon_cercle,rayon_tore);
              b->construit();
              arbre->ajouter_mg_primitive(b);
              }       
             if (entite=="CONE")
              {
              parse.decode(data.c_str(),"@,@,@,@,@,@,@",param+2);
              double base_x=atof((char*)param[2].argument[0].c_str());
              double base_y=atof((char*)param[3].argument[0].c_str());
              double base_z=atof((char*)param[4].argument[0].c_str());
              double longitude=atof((char*)param[5].argument[0].c_str());
              double latitude=atof((char*)param[6].argument[0].c_str());
              double rayon=atof((char*)param[7].argument[0].c_str());
              double hauteur=atof((char*)param[8].argument[0].c_str());
              MG_PRIMITIVE_CONE *b=new MG_PRIMITIVE_CONE(id,base_x,base_y,base_z,longitude,latitude,rayon,hauteur);
              b->construit();
              arbre->ajouter_mg_primitive(b);
              }
            if (entite=="UNION")
              {
              parse.decode(data.c_str(),"@,@,@",param+2);
              int sem=atoi((char*)param[2].argument[0].c_str());
              long id1=cid((char*)param[3].argument[0].c_str());
              long id2=cid((char*)param[4].argument[0].c_str());
              MG_PRIMITIVE *p1=arbre->get_mg_primitiveid(id1);
              MG_PRIMITIVE *p2=arbre->get_mg_primitiveid(id2);
              MG_OPERATEUR_BOOLEAN_UNION *op=new MG_OPERATEUR_BOOLEAN_UNION(id,sem,p1,p2);
              arbre->ajouter_mg_operateur_boolean(op);
              }
            if (entite=="DIFFERENCE")
              {
              parse.decode(data.c_str(),"@,@,@",param+2);
              int sem=atoi((char*)param[2].argument[0].c_str());
              long id1=cid((char*)param[3].argument[0].c_str());
              long id2=cid((char*)param[4].argument[0].c_str());
              MG_PRIMITIVE *p1=arbre->get_mg_primitiveid(id1);
              MG_PRIMITIVE *p2=arbre->get_mg_primitiveid(id2);
              MG_OPERATEUR_BOOLEAN_DIFFERENCE *op=new MG_OPERATEUR_BOOLEAN_DIFFERENCE(id,sem,p1,p2);
              arbre->ajouter_mg_operateur_boolean(op);
              }
            if (entite=="INTERSECTION")
              {
              parse.decode(data.c_str(),"@,@,@",param+2);
              int sem=atoi((char*)param[2].argument[0].c_str());
              long id1=cid((char*)param[3].argument[0].c_str());
              long id2=cid((char*)param[4].argument[0].c_str());
              MG_PRIMITIVE *p1=arbre->get_mg_primitiveid(id1);
              MG_PRIMITIVE *p2=arbre->get_mg_primitiveid(id2);
              MG_OPERATEUR_BOOLEAN_INTERSECTION *op=new MG_OPERATEUR_BOOLEAN_INTERSECTION(id,sem,p1,p2);
              arbre->ajouter_mg_operateur_boolean(op);
              }
           if (entite=="PRIM_COMPLEXE")
              {
              parse.decode(data.c_str(),"@",param+2);
              long id1=cid((char*)param[2].argument[0].c_str());
              MG_OPERATEUR_BOOLEAN *op=arbre->get_mg_operateur_booleanid(id1);
              MG_PRIMITIVE* p=op->construit(id);
              arbre->ajouter_mg_primitive(p);
              }
           
           if (entite=="MG_CG_MODELE")
              {
                lire_MG_CG_MODELE(id,parse,param,data);
              }
           if (entite =="MG_CG_ASSEMBLAGE")
              {
                lire_MG_CG_ASSEMBLAGE(id,parse,param,data);
              }
           if (entite =="MG_CG_INFO_DOUBLE")
              {
                lire_MG_CG_INFO_DOUBLE(id,parse,param,data);
              } 
           if (entite =="MG_CG_INFO_STRING")
              {
                lire_MG_CG_INFO_STRING(id,parse,param,data);
              }
           if (entite =="MG_CG_INFO_VCT_DOUBLE")
              {
                lire_MG_CG_INFO_VCT_DOUBLE(id,parse,param,data);
              }   
           if (entite =="MG_CG_GROUPE_FORME")
              {
                lire_MG_CG_GROUPE_FORME(id,parse,param,data);
              }   
           if (entite =="MG_CG_FORME_ARETE")
              {
                lire_MG_CG_FORME_ARETE(id,parse,param,data);
              }  
           if (entite =="MG_CG_FORME_ARETE_DROITE")
              {
                lire_MG_CG_FORME_ARETE_DROITE(id,parse,param,data);
              }  
           if (entite =="MG_CG_FORME_VOLUME")
              {
                lire_MG_CG_FORME_VOLUME(id,parse,param,data);
              }  
           if (entite =="MG_CG_FORME_VOLUME_BOITE")
              {
                lire_MG_CG_FORME_VOLUME_BOITE(id,parse,param,data);
              }
           if (entite =="MG_CG_FORME_VOLUME_SPHERE")
              {
                lire_MG_CG_FORME_VOLUME_SPHERE(id,parse,param,data);
              }
           if (entite =="MG_CG_FORME_VOLUME_ELLIPSOIDE")
              {
                lire_MG_CG_FORME_VOLUME_ELLIPSOIDE(id,parse,param,data);
              }
           if (entite =="MG_CG_FORME_VOLUME_CYLINDRE")
              {
                lire_MG_CG_FORME_VOLUME_CYLINDRE(id,parse,param,data);
              }
           if (entite =="MG_CG_FORME_VOLUME_CONE")
              {
                lire_MG_CG_FORME_VOLUME_CONE(id,parse,param,data);
              }
           if (entite =="MG_CG_FORME_VOLUME_TORE")
              {
                lire_MG_CG_FORME_VOLUME_TORE(id,parse,param,data);
              }
           if (entite =="MG_CG_FORME_MULTIPLE")
              {
                lire_MG_CG_FORME_MULTIPLE(id,parse,param,data);
              }
           if (entite =="MG_CG_FORME_MULTI_VOLUME")
              {
                lire_MG_CG_FORME_MULTI_VOLUME(id,parse,param,data);
              }     
           if (entite =="MG_CG_OP_BOOL_UNION")
              {
                lire_MG_CG_OP_BOOL_UNION(id,parse,param,data);
              }
           if (entite =="MG_CG_OP_BOOL_DIFFERENCE")
              {
                lire_MG_CG_OP_BOOL_DIFFERENCE(id,parse,param,data);
              }
           if (entite =="MG_CG_OP_BOOL_INTERSECTION")
              {
                lire_MG_CG_OP_BOOL_INTERSECTION(id,parse,param,data);
              }
           if (entite =="MG_CG_OP_BOOL_FRAGMENT")
              {
                lire_MG_CG_OP_BOOL_FRAGMENT(id,parse,param,data);
              }
           if (entite =="MG_CG_OP_INCLUSION_MATRICE")
              {
                lire_MG_CG_OP_INCLUSION_MATRICE(id,parse,param,data);
              }
           if (entite =="MG_CG_OP_TRANSF_ROTATION")
              {
                lire_MG_CG_OP_TRANSF_ROTATION(id,parse,param,data);
              }
           if (entite =="MG_CG_OP_TRANSF_TRANSLATION")
              {
                lire_MG_CG_OP_TRANSF_TRANSLATION(id,parse,param,data);
              }
           if (entite =="MG_CG_OP_TRANSF_ECHELLE")
              {
                lire_MG_CG_OP_TRANSF_ECHELLE(id,parse,param,data);
              }
       if (entite =="MG_CG_OP_TRANSF_DECALLAGE")
              {
                lire_MG_CG_OP_TRANSF_DECALLAGE(id,parse,param,data);
              }
           
#endif           
            if (entite =="MG_SOUS_GEOMETRIE")
              {
                lire_MG_SOUS_GEOMETRIE(id,parse,param,data);
              }
            if (entite=="GEOMETRIE_EPS")
            {
                parse.decode(data.c_str(),"@",param+2);
                double val=atof((char*)param[2].argument[0].c_str());
                mggeo->change_valeur_precision(val);
            }
            if (entite=="GROUPE_TOPOLOGIQUE")
            {
                parse.decode(data.c_str(),"@,(&)",param+2);
                MG_GROUPE_TOPOLOGIQUE* mggt=new MG_GROUPE_TOPOLOGIQUE(id);
                mggeo->ajouter_mg_groupe_topologique(mggt);
                int nb=atoi(param[2].argument[0].c_str());
                for (int i=0;i<nb;i++)
                {
                    unsigned long id2=cid(param[3].argument[i].c_str());
                    MG_ELEMENT_TOPOLOGIQUE* ele;
                    ele=mggeo->get_mg_sommetid(id2);
                    if (ele==NULL) ele=mggeo->get_mg_areteid(id2);
                    if (ele==NULL) ele=mggeo->get_mg_faceid(id2);
                    if (ele==NULL) ele=mggeo->get_mg_volumeid(id2);
                    if (ele!=NULL) mggt->ajouter(ele);
                }

            }
            if (entite=="GEOM_FONCTION")
            {
                parse.decode(data.c_str(),"@,@,(&)",param+2);
                int dim=atoi((char*)param[2].argument[0].c_str());
                MG_GEOM_FONCTION *gf=new MG_GEOM_FONCTION(id,dim);
                mggeo->ajouter_mg_geom_fonction(gf);
                int nb=atoi(param[3].argument[0].c_str());
                for (int i=0;i<nb;i++)
                {
                    parse.decode(param[4].argument[i].c_str(),"(&)",param+5);
                    double *coo=new double[dim];
                    for (int j=0;j<dim;j++)
                      coo[j]=atof(param[5].argument[j].c_str());
                    gf->ajouter_point(coo);
                    delete [] coo;
                }

            }
            
            if (entite=="VOLUME")
            {
              lire_MG_VOLUME(id,parse,param,data,mggeo,volumemince);
              
                /*{
                    for (int i=0;i<nb;i++)
                    {
                        parse.decode(param[6].argument[i].c_str(),"(@,@)",param+7);
                        char nom[3];
                        double val;
                        strcpy(nom,param[7].argument[0].c_str());
                        val=atof(param[8].argument[0].c_str());
                        mgvol->ajouter_ccf(nom,val);
                    }
                }*/
            }
            if (entite=="COQUE")
            {
                if (version_fichier<2)
                {
                parse.decode(data.c_str(),"@,@,@,@,(&)",param+2);
                MG_COQUE* mgcoq=new MG_COQUE(param[2].argument[0],id);
                mggeo->ajouter_mg_coque(mgcoq);
                int nummat=atoi((char*)param[4].argument[0].c_str());
                mgcoq->change_num_materiau(nummat);
                int nb=atoi(param[5].argument[0].c_str());
                if (nb!=0) lire_ccf(version_fichier,nb,6,parse,param,mgcoq);
                }
                else
                {
                parse.decode(data.c_str(),"@,@,@,(&)",param+2);
                MG_COQUE* mgcoq=new MG_COQUE(param[2].argument[0],id);
                mggeo->ajouter_mg_coque(mgcoq);
                int nb=atoi(param[4].argument[0].c_str());
                if (nb!=0) lire_ccf(version_fichier,nb,5,parse,param,mgcoq);  
                }
                /*if (nb!=0)
                {
                    for (int i=0;i<nb;i++)
                    {
                        parse.decode(param[6].argument[i].c_str(),"(@,@)",param+7);
                        char nom[3];
                        double val;
                        strcpy(nom,param[7].argument[0].c_str());
                        val=atof(param[8].argument[0].c_str());
                        mgcoq->ajouter_ccf(nom,val);
                    }
                }*/
            }
            if (entite=="POUTRE")
            {
               if (version_fichier<2)
                {
                parse.decode(data.c_str(),"@,@,@,@,(&)",param+2);
                MG_POUTRE* mgpoutre=new MG_POUTRE(param[2].argument[0],id);
                mggeo->ajouter_mg_poutre(mgpoutre);
                int nummat=atoi((char*)param[4].argument[0].c_str());
                mgpoutre->change_num_materiau(nummat);
                int nb=atoi(param[5].argument[0].c_str());
                if (nb!=0) lire_ccf(version_fichier,nb,6,parse,param,mgpoutre);
                }
                else
                {
                parse.decode(data.c_str(),"@,@,@,(&)",param+2);
                MG_POUTRE* mgpou=new MG_POUTRE(param[2].argument[0],id);
                mggeo->ajouter_mg_poutre(mgpou);
                int nb=atoi(param[4].argument[0].c_str());
                if (nb!=0) lire_ccf(version_fichier,nb,5,parse,param,mgpou);  
                }
                
                /*if (nb!=0)
                {
                    for (int i=0;i<nb;i++)
                    {
                        parse.decode(param[6].argument[i].c_str(),"(@,@)",param+7);
                        char nom[3];
                        double val;
                        strcpy(nom,param[7].argument[0].c_str());
                        val=atof(param[8].argument[0].c_str());
                        mgpoutre->ajouter_ccf(nom,val);
                    }
                }*/
            }
            if (entite=="COQUILLE")
            {
              lire_MG_COQUILLE(id,parse,param,data,mggeo);
            }
            
#ifdef BREP_STEP
            if (entite=="SURFACE_STEP")
            {
                parse.decode(data.c_str(),"@",param+2);
                long idstepsuf=atol(param[2].argument[0].c_str());
                ST_SURFACE *stsurf=mggeo->get_gest_step().lst_surface.getid(idstepsuf);
                STEP_SURFACE* stepsurf=new STEP_SURFACE(id,stsurf);
                mggeo->ajouter_mg_surface(stepsurf);
            }
            if (entite=="COURBE_STEP")
            {
                parse.decode(data.c_str(),"@",param+2);
                long idstepcur=atol(param[2].argument[0].c_str());
                ST_COURBE *stcur=mggeo->get_gest_step().lst_courbe.getid(idstepcur);
                STEP_COURBE* stepcur=new STEP_COURBE(id,stcur);
                mggeo->ajouter_mg_courbe(stepcur);
            }

            if (entite=="POINT_STEP")
            {
                parse.decode(data.c_str(),"@",param+2);
                long idsteppt=atol(param[2].argument[0].c_str());
                ST_POINT *stpt=mggeo->get_gest_step().lst_point.getid(idsteppt);
                STEP_POINT* steppt=new STEP_POINT(id,stpt);
                mggeo->ajouter_mg_point(steppt);
            }

#endif
#ifdef BREP_SAT
            if (entite=="SURFACE_SAT")
            {
                parse.decode(data.c_str(),"@",param+2);
                long idsatsuf=atol(param[2].argument[0].c_str());
                SAT_SURFACE *satsurf=mggeo->get_gest_sat().lst_surface.getid(idsatsuf);
                ACIS_SURFACE* acissurf=new ACIS_SURFACE(id,satsurf);
                mggeo->ajouter_mg_surface(acissurf);
            }
            if (entite=="COURBE_SAT")
            {
                parse.decode(data.c_str(),"@",param+2);
                long idsatcur=atol(param[2].argument[0].c_str());
                SAT_COURBE *satcur=mggeo->get_gest_sat().lst_courbe.getid(idsatcur);
                ACIS_COURBE* aciscur=new ACIS_COURBE(id,satcur);
                mggeo->ajouter_mg_courbe(aciscur);
            }

            if (entite=="POINT_SAT")
            {
                parse.decode(data.c_str(),"@",param+2);
                long idsatpt=atol(param[2].argument[0].c_str());
                SAT_POINT *satpt=mggeo->get_gest_sat().lst_point.getid(idsatpt);
                ACIS_POINT* acispt=new ACIS_POINT(id,satpt);
                mggeo->ajouter_mg_point(acispt);
            }

#endif

#ifdef ALL_OCC

            if (entite=="SURFACE_OCC")
            {
                parse.decode(data.c_str(),"@",param+2);
                long idocc=atol(param[2].argument[0].c_str());
                TopoDS_Face occface;
                if(mggeo->get_occ_fonction().get_version()=="OCCV2017")
                {
                  OCC_FONCTION_V2017* occ_fonction_2017 = (OCC_FONCTION_V2017*)&mggeo->get_occ_fonction();
                  occface=occ_fonction_2017->get_TopoDS_Face_id(idocc);
                }
                else
                {
                  const TopoDS_Shape& occshape=mggeo->get_occ_fonction().GetShape(idocc);
                  occface=TopoDS::Face(occshape);
                }                
                mggeo->get_occ_fonction().change_precision(mggeo->get_valeur_precision());
                OCC_SURFACE* occsurf=new OCC_SURFACE(id,occface,&mggeo->get_occ_fonction());
                occsurf->change_idoriginal(std::to_string(idocc));
                mggeo->ajouter_mg_surface(occsurf);
            }
            if (entite=="COURBE_OCC")
            {
                parse.decode(data.c_str(),"@",param+2);
                long idocc=atol(param[2].argument[0].c_str());
                TopoDS_Edge occedge;
                if(mggeo->get_occ_fonction().get_version()=="OCCV2017")
                {
                  OCC_FONCTION_V2017* occ_fonction_2017 = (OCC_FONCTION_V2017*)&mggeo->get_occ_fonction();
                  occedge=occ_fonction_2017->get_TopoDS_Edge_id(idocc);
                }
                else
                {
                  const TopoDS_Shape& occshape=mggeo->get_occ_fonction().GetShape(idocc);
                  occedge=TopoDS::Edge(occshape);
                }                
                OCC_COURBE* occcrb=new OCC_COURBE(id,occedge, &mggeo->get_occ_fonction());
                mggeo->ajouter_mg_courbe(occcrb);
                occcrb->change_idoriginal(std::to_string(idocc));
            }
            if (entite=="POINT_OCC")
            {
                parse.decode(data.c_str(),"@",param+2);
                long idocc=atol(param[2].argument[0].c_str());
                TopoDS_Vertex occvertex;
                if(mggeo->get_occ_fonction().get_version()=="OCCV2017")
                {
                  OCC_FONCTION_V2017* occ_fonction_2017 = (OCC_FONCTION_V2017*)&mggeo->get_occ_fonction();
                  occvertex = occ_fonction_2017->get_TopoDS_Vertex_id(idocc);
                }
                else
                {
                  const TopoDS_Shape& occshape=mggeo->get_occ_fonction().GetShape(idocc);
                  occvertex=TopoDS::Vertex(occshape);
                }
                
                OCC_POINT* occpoint=new OCC_POINT(id,occvertex, &mggeo->get_occ_fonction());
                mggeo->ajouter_mg_point(occpoint);
                occpoint->change_idoriginal((std::to_string(idocc)));
            }
#endif
#ifdef WINDOWS_VERSION
            if (entite=="CAD4FE_POLYCURVE")
            {
                CAD4FE::PolyCurve * polycurve = NULL;
                parse.decode(data.c_str(),"@,(&)",param+2);
                int nb = atoi(param[2].argument[0].c_str());

                if (nb == 0)
                {
                    printf("PolyCurve %d is formed with reference vertex : ", id);
                    parse.decode(param[3].argument[0].c_str(),"@",param+4);
                    int idRefVertex;
                    idRefVertex=cid(param[4].argument[0].c_str());
                    printf("%d ;\n ", idRefVertex);
                    MG_SOMMET * refVertex = mggeo->get_mg_sommetid(idRefVertex);
                    polycurve = new CAD4FE::PolyCurve(refVertex);
                }
                else
                {
                    printf("PolyCurve %d is formed with reference edges : ", id);
                    polycurve = new CAD4FE::PolyCurve;
                    for (int i=0;i<nb;i++)
                    {
                        parse.decode(param[3].argument[i].c_str(),"@",param+4);
                        int idRefEdge;
                        idRefEdge=cid(param[4].argument[0].c_str());
                        printf("%d ; ", idRefEdge);
                        MG_ARETE * refEdge = mggeo->get_mg_areteid(idRefEdge);
                        CAD4FE::PolyCurve tmpPC(refEdge);
                        polycurve->Merge(tmpPC);
                    }
                    printf("\n");
                }

                polycurve->change_id(id);
                mggeo->ajouter_mg_courbe(polycurve);
            }


            if (entite=="CAD4FE_POLYSURFACE")
            {
                CAD4FE::PolySurface * polysurface = new CAD4FE::PolySurface;
                polysurface->change_id(id);
                mggeo->ajouter_mg_surface(polysurface);

                parse.decode(data.c_str(),"@,(&)",param+2);

                int nb = atoi(param[2].argument[0].c_str());
                printf("PolySurface %d is formed with reference faces : ", id);
                for (int i=0;i<nb;i++)
                {
                    parse.decode(param[3].argument[i].c_str(),"@",param+4);
                    int idRefFace;
                    idRefFace=cid(param[4].argument[0].c_str());
                    printf("%d ; ", idRefFace);

                    MG_FACE * refFace = mggeo->get_mg_faceid(idRefFace);
                    CAD4FE::PolySurface tmpSF(refFace);
                    polysurface->Merge(tmpSF);
                }

                printf("\n");
            }
            if (entite=="CAD4FE_MCEDGE")
            {
                parse.decode(data.c_str(),"@,@,@,@,@,@,(&)",param+2);

                std::string idOriginal = param[2].argument[0];
                long idPolyCurve=cid(param[3].argument[0]);
                CAD4FE::PolyCurve * polycurve = (CAD4FE::PolyCurve *) mggeo->get_mg_courbeid(idPolyCurve);

                // sense is not used because a MCEdge always has
                // a sense = 1 !
                // (because polycurve domain is equal to mcEdge domain)
                CAD4FE::MCEdge * mcEdge = new CAD4FE::MCEdge(idOriginal, polycurve);
                mcEdge->change_id(id);
                mggeo->ajouter_mg_arete(mcEdge);

                int nb=atoi(param[7].argument[0].c_str());
                if (nb!=0)
                {
                    for (int i=0;i<nb;i++)
                    {
                        parse.decode(param[8].argument[i].c_str(),"(@,@)",param+9);
                        char nom[3];
                        double val;
                        strcpy(nom,param[9].argument[0].c_str());
                        val=atof(param[10].argument[0].c_str());
                        mcEdge->ajouter_ccf(nom,val);
                    }
                }
            }
            if (entite=="CAD4FE_MCFACE")
            {
                parse.decode(data.c_str(),"@,@,@,@,@,(&)",param+2);

                std::string idOriginal = param[2].argument[0];
                long idPolySurface=cid(param[3].argument[0]);
                CAD4FE::PolySurface * polysurface = (CAD4FE::PolySurface *) mggeo->get_mg_surfaceid(idPolySurface);

                CAD4FE::MCFace * mcFace = new CAD4FE::MCFace(idOriginal, polysurface);
                mcFace->change_id(id);
                mggeo->ajouter_mg_face(mcFace);

                int nb=atoi(param[6].argument[0].c_str());
                if (nb!=0)
                {
                    for (int i=0;i<nb;i++)
                    {
                        parse.decode(param[7].argument[i].c_str(),"(@,@)",param+8);
                        char nom[3];
                        double val;
                        strcpy(nom,param[8].argument[0].c_str());
                        val=atof(param[9].argument[0].c_str());
                        mcFace->ajouter_ccf(nom,val);
                    }
                }
            }
            if (entite=="CAD4FE_MCVERTEX")
            {
                parse.decode(data.c_str(),"@,@,@,(&),@,(&)",param+2);
                std::string idOriginal = param[2].argument[0];
                long idsom=cid(param[3].argument[0]);
                MG_SOMMET * mgsom = mggeo->get_mg_sommetid(idsom);
                CAD4FE::MCVertex * mcVertex = new CAD4FE::MCVertex(mgsom);
                mcVertex->change_id(id);
                mggeo->ajouter_mg_sommet(mcVertex);
                int nb_ref_vertex=atoi(param[4].argument[0].c_str());
                if (nb_ref_vertex!=0)
                {
                    for (int i=0;i<nb_ref_vertex;i++)
                    {
                        unsigned long idRefVertex=cid(param[5].argument[i]);
                        mcVertex->GetMergedRefVertices()[idRefVertex] = NULL;
                        mapMergedRefVertices.insert(std::make_pair(mcVertex,idRefVertex));
                    }
                }
                int nb_ccf=atoi(param[4+2].argument[0].c_str());
                if (nb_ccf!=0)
                {
                    for (int i=0;i<nb_ccf;i++)
                    {
                        parse.decode(param[5+2].argument[i].c_str(),"(@,@)",param+6+2);
                        char nom_ccf[3];
                        double val_ccf;
                        strcpy(nom_ccf,param[6+2].argument[0].c_str());
                        val_ccf=atof(param[7+2].argument[0].c_str());
                        mgsom->ajouter_ccf(nom_ccf,val_ccf);
                    }
                }
            }
#endif
            if (entite=="FACE")
            {
              lire_MG_FACE(id,parse,param,data,mggeo);
                /*if (nb!=0)
                {
                    for (int i=0;i<nb;i++)
                    {
                        parse.decode(param[7].argument[i].c_str(),"(@,@)",param+8);
                        char nom[3];
                        double val;
                        strcpy(nom,param[8].argument[0].c_str());
                        val=atof(param[9].argument[0].c_str());
                        mgface->ajouter_ccf(nom,val);
                    }
                }*/
            }
            if (entite=="COFACE")
            {
                parse.decode(data.c_str(),"@,@,@",param+2);
                long idface=cid(param[2].argument[0]);
                long idcoq=cid(param[3].argument[0]);
                int sens=atoi(param[4].argument[0].c_str());
                MG_FACE* mgface=mggeo->get_mg_faceid(idface);
                MG_COQUILLE* mgcoq=mggeo->get_mg_coquilleid(idcoq);
                MG_COFACE* mgcoface=mggeo->ajouter_mg_coface(id,mgface,mgcoq,sens);
                mgcoq->ajouter_mg_coface(mgcoface);
            }
            if (entite=="BOUCLE")
            {
              lire_MG_BOUCLE(id,parse,param,data,mggeo);
            }
            if (entite=="POINT")
            {
                parse.decode(data.c_str(),"@,@,@",param+2);
                double xyz[3];
                xyz[0]=atof(param[2].argument[0].c_str());
                xyz[1]=atof(param[3].argument[0].c_str());
                xyz[2]=atof(param[4].argument[0].c_str());
                LC_POINT* point=new LC_POINT(id,xyz);
                mggeo->ajouter_mg_point(point);
            }
            if (entite=="SOMMET")
            {
              lire_MG_SOMMET(id,parse,param,data,mggeo);
            }
#ifdef ALL_OCC            
            if (entite=="OCC_SOMMET")
            {
                parse.decode(data.c_str(),"@,@,@,@,(&)",param+2);
                long idpoint=cid(param[3].argument[0]);
                MG_POINT* mgpt=mggeo->get_mg_pointid(idpoint);
                TopoDS_Vertex topods_vertex;
                long idori = stol(param[2].argument[0]);
                OCC_SOMMET* occ_sommet;
                if(mggeo->get_occ_fonction().get_version()=="OCCV2017")
                {
                  OCC_FONCTION_V2017* occ_fonction_v2017 = (OCC_FONCTION_V2017*)&mggeo->get_occ_fonction();
                  topods_vertex=occ_fonction_v2017->get_TopoDS_Vertex_id(idori);
                  occ_sommet = new OCC_SOMMET(param[2].argument[0],id,mgpt,topods_vertex,&mggeo->get_occ_fonction());
                  mggeo->ajouter_mg_sommet(occ_sommet);
                  occ_fonction_v2017->ajouter_OCC_SOMMET(occ_sommet);
                }
                else
                {
                  std::cout << "*** MG_FILE : ERREUR lecture OCC_SOMMET : Mauvaise OCC_FONCTION ! ***" << std::endl;
                }
                int argccf=5;
                if (version_fichier>2.1)
                    {
                    argccf=6;
                    int ipole=atoi(param[4].argument[0].c_str());
                    if (ipole==1) occ_sommet->change_pole(true);
                    }
                int nb=atoi(param[argccf-1].argument[0].c_str());
                if (nb!=0) lire_ccf(version_fichier,nb,argccf,parse,param,occ_sommet);
            }
            if (entite=="OCC_ARETE")
            {
                parse.decode(data.c_str(),"@,@,@,@,@,@,(&)",param+2);
                long idcur=cid(param[3].argument[0]);
                int sens=atol(param[6].argument[0].c_str());
                long idori = stoi(param[2].argument[0]);
                TopoDS_Edge topods_edge;
                OCC_ARETE* occ_arete;
                MG_COURBE* mgcur=mggeo->get_mg_courbeid(idcur);
                if(mggeo->get_occ_fonction().get_version()=="OCCV2017")
                {
                  OCC_FONCTION_V2017* occ_fonction_v2017 = (OCC_FONCTION_V2017*)&mggeo->get_occ_fonction();
                  topods_edge=occ_fonction_v2017->get_TopoDS_Edge_id(idori);
                  occ_arete= new OCC_ARETE(param[2].argument[0],id,mgcur,sens,topods_edge,&mggeo->get_occ_fonction());
                  mggeo->ajouter_mg_arete(occ_arete);
                  occ_fonction_v2017->ajouter_OCC_ARETE(occ_arete);
                }
                else
                {
                  std::cout << "*** MG_FILE : ERREUR lecture OCC_ARETE : Mauvaise OCC_FONCTION ! ***" << std::endl;
                }                
                int nb=atoi(param[7].argument[0].c_str());
                if (nb!=0) lire_ccf(version_fichier,nb,8,parse,param,occ_arete);
            }
            if (entite=="OCC_BOUCLE")
            {
                parse.decode(data.c_str(),"@,@,(@)",param+2);
                long ident=cid(param[2].argument[0]);
                long idori=stol(param[3].argument[0]);
                TopoDS_Wire topods_wire;
                OCC_BOUCLE* occ_boucle;
                if(mggeo->get_occ_fonction().get_version()=="OCCV2017")
                {
                  OCC_FONCTION_V2017* occ_fonction_v2017 = (OCC_FONCTION_V2017*)&mggeo->get_occ_fonction();
                  topods_wire=occ_fonction_v2017->get_TopoDS_Wire_id(idori);            
                  if(ident!=-1)
                  {
                    MG_FACE* mgface=mggeo->get_mg_faceid(ident);
                    MG_POUTRE* mgpoutre=mggeo->get_mg_poutreid(ident);
                    if (mgface!=NULL)
                    {
                        OCC_BOUCLE* occ_boucle=new OCC_BOUCLE(param[3].argument[0],id,mgface,topods_wire,&mggeo->get_occ_fonction());
                        mggeo->ajouter_mg_boucle(occ_boucle,mgface);
                        occ_fonction_v2017->ajouter_OCC_BOUCLE(occ_boucle);
                    }
                    if (mgpoutre!=NULL)
                    {
                        OCC_BOUCLE* occ_boucle=new OCC_BOUCLE(param[3].argument[0],id,mgpoutre,topods_wire,&mggeo->get_occ_fonction());
                        mggeo->ajouter_mg_boucle(occ_boucle,mgpoutre);
                        occ_fonction_v2017->ajouter_OCC_BOUCLE(occ_boucle);
                    }
                  }
                  else
                  {
                      OCC_BOUCLE* occ_boucle=new OCC_BOUCLE(param[3].argument[0],id,topods_wire,&mggeo->get_occ_fonction());
                      mggeo->ajouter_mg_boucle(occ_boucle);
                      occ_fonction_v2017->ajouter_OCC_BOUCLE(occ_boucle);
                  }
                }
                else
                {
                  std::cout << "*** MG_FILE : ERREUR lecture OCC_BOUCLE : Mauvaise OCC_FONCTION ! ***" << std::endl;
                }   
                
            }
            if (entite=="OCC_FACE")
            {
                parse.decode(data.c_str(),"@,@,(@),@,@,@,(&)",param+2);
                long idsurf=cid(param[3].argument[0]);
                int sens=atoi(param[5].argument[0].c_str());
                long idori = stol(param[2].argument[0]);
                TopoDS_Face topods_face;
                OCC_FACE* occ_face;
                MG_SURFACE* mgsurf=mggeo->get_mg_surfaceid(idsurf);
                if(mggeo->get_occ_fonction().get_version()=="OCCV2017")
                {
                  OCC_FONCTION_V2017* occ_fonction_v2017 = (OCC_FONCTION_V2017*)&mggeo->get_occ_fonction();
                  topods_face=occ_fonction_v2017->get_TopoDS_Face_id(idori);
                  occ_face = new OCC_FACE(param[2].argument[0],id,mgsurf,sens,topods_face,&mggeo->get_occ_fonction());
                  mggeo->ajouter_mg_face(occ_face);
                  occ_fonction_v2017->ajouter_OCC_FACE(occ_face);                 
                }
                else
                {
                  std::cout << "*** MG_FILE : ERREUR lecture OCC_FACE : Mauvaise OCC_FONCTION ! ***" << std::endl;
                }                   
                int argccf=7;
                if (version_fichier>2.1)
                    {
                    argccf=8;
                    int nbpole=atoi(param[6].argument[0].c_str());
                    occ_face->change_nb_pole(nbpole);
                    }
                int nb=atoi(param[argccf-1].argument[0].c_str());
                if (nb!=0) lire_ccf(version_fichier,nb,argccf,parse,param,occ_face);
            }
            if (entite=="OCC_COQUILLE")
            {
                parse.decode(data.c_str(),"@,@,@",param+2);
                long ident=cid(param[2].argument[0]);
                long idori = stol(param[3].argument[0]);
                TopoDS_Shell topods_shell;
                OCC_COQUILLE* occ_coquille;
                if(mggeo->get_occ_fonction().get_version()=="OCCV2017")
                {
                  OCC_FONCTION_V2017* occ_fonction_v2017 = (OCC_FONCTION_V2017*)&mggeo->get_occ_fonction();
                  topods_shell=occ_fonction_v2017->get_TopoDS_Shell_id(idori);          
                  if(idori!=-1)
                  {
                    MG_VOLUME* mgvol=mggeo->get_mg_volumeid(ident);
                    MG_COQUE* mgcoq=mggeo->get_mg_coqueid(ident);
                    if (mgvol!=NULL)
                    {
                        OCC_COQUILLE* occ_coquille = new OCC_COQUILLE(param[3].argument[0],id,mgvol,topods_shell,&mggeo->get_occ_fonction());
                        mggeo->ajouter_mg_coquille(occ_coquille,mgvol);
                        occ_fonction_v2017->ajouter_OCC_COQUILLE(occ_coquille);
                    }
                    if (mgcoq!=NULL)
                    {
                        OCC_COQUILLE* occ_coquille = new OCC_COQUILLE(param[3].argument[0],id,mgcoq,topods_shell,&mggeo->get_occ_fonction());
                        mggeo->ajouter_mg_coquille(occ_coquille,mgcoq);
                        occ_fonction_v2017->ajouter_OCC_COQUILLE(occ_coquille);
                    }
                  }
                  else
                  {
                      OCC_COQUILLE* occ_coquille = new OCC_COQUILLE(param[3].argument[0],id,topods_shell,&mggeo->get_occ_fonction());
                      mggeo->ajouter_mg_coquille(occ_coquille);
                      occ_fonction_v2017->ajouter_OCC_COQUILLE(occ_coquille);
                  }
                }
                else
                {
                  std::cout << "*** MG_FILE : ERREUR lecture OCC_COQUILLE : Mauvaise OCC_FONCTION ! ***" << std::endl;
                } 
            }
            if (entite=="OCC_VOLUME")
            {

                parse.decode(data.c_str(),"@,@,@,@",param+2);
                long idori = stol(param[2].argument[0]);
                TopoDS_Solid topods_solid;
                OCC_VOLUME* occ_volume;
                if(mggeo->get_occ_fonction().get_version()=="OCCV2017")
                {
                  OCC_FONCTION_V2017* occ_fonction_v2017 = (OCC_FONCTION_V2017*)&mggeo->get_occ_fonction();
                  topods_solid=occ_fonction_v2017->get_TopoDS_Solid_id(idori);
                  occ_volume = new OCC_VOLUME(param[2].argument[0],id,topods_solid,&mggeo->get_occ_fonction());
                  mggeo->ajouter_mg_volume(occ_volume);
                  occ_fonction_v2017->ajouter_OCC_VOLUME(occ_volume);
                }
                else
                {
                  std::cout << "*** MG_FILE : ERREUR lecture OCC_VOLUME : Mauvaise OCC_FONCTION ! ***" << std::endl;
                }
                int mince=atoi(param[4].argument[0].c_str());
                if (mince==0)
                      {
                      std::string data2=param[5].argument[0];
                      parse.decode(data2.c_str(),"@,(&)",param+5);
                      int nb=atoi(param[5].argument[0].c_str());
                      if (nb!=0) lire_ccf(version_fichier,nb,6,parse,param,occ_volume);
                      }
                else
                      {
                      std::string data2=param[5].argument[0];
                      parse.decode(data2.c_str(),"(&),@,(&)",param+5);
                      int nb_face=param[5].argument.size();
                      for (int i=0;i<nb_face;i=i+2)
                                  {
                                  unsigned long idn1=cid(param[5].argument[i]);
                                  unsigned long idn2=cid(param[5].argument[i+1]);
                                  volumemince.push_back(id);
                                  volumemince.push_back(idn1);
                                  volumemince.push_back(idn2);
                                  }
                      int nb=atoi(param[6].argument[0].c_str());
                      if (nb!=0) lire_ccf(version_fichier,nb,7,parse,param,occ_volume);
                      }
            }
            
            
#endif
          if (entite=="ARETE_ELEMENT")
            {
            if (version_fichier<2.35)
              parse.decode(data.c_str(),"@,(&),@,(&)",param+2);
            else
              parse.decode(data.c_str(),"@,(&),(&),@,(&)",param+2);
            MG_ARETE_ELEMENT* are=new MG_ARETE_ELEMENT(id);    
            mggeo->ajouter_mg_arete(are);
            int numparamnb=4;
            if (version_fichier>2.35)
              {
              numparamnb=5;
              lire_contrainte(4,param,are);
              }
            int nb=atoi(param[numparamnb].argument[0].c_str());
            if (nb!=0) lire_ccf(version_fichier,nb,5,parse,param,are);
            
              
            }
          if (entite=="FACE_ELEMENT")
            {
            if (version_fichier<2.35)
          parse.decode(data.c_str(),"@,(&),@,(&)",param+2);
        else
          parse.decode(data.c_str(),"@,(&),(&),@,(&)",param+2);
            MG_FACE_ELEMENT* face=new MG_FACE_ELEMENT(id);    
            mggeo->ajouter_mg_face(face);
        int numparamnb=4;
            if (version_fichier>2.35)
          {
          numparamnb=5;
          lire_contrainte(4,param,face);
            
          }
        int nb=atoi(param[numparamnb].argument[0].c_str());
            if (nb!=0) 
              lire_ccf(version_fichier,nb,numparamnb+1,parse,param,face);
              
            }
          if (entite=="COQUE_ELEMENT")
            {
            parse.decode(data.c_str(),"@,(&),@,(&)",param+2);
            MG_COQUE_ELEMENT* coq=new MG_COQUE_ELEMENT(id);    
            mggeo->ajouter_mg_coque(coq);
            int nbele=atoi(param[2].argument[0].c_str());
            for (int i=0;i<nbele;i++)
            {
            unsigned long idele=cid(param[3].argument[i].c_str());
            coq->ajouter_element(idele);
            }
            int nb=atoi(param[4].argument[0].c_str());
            if (nb!=0) lire_ccf(version_fichier,nb,5,parse,param,coq);
            /*   if (nb!=0)
                {
                    for (int i=0;i<nb;i++)
                    {
                        parse.decode(param[5].argument[i].c_str(),"(@,@)",param+6);
                        char nom[3];
                        double val;
                        strcpy(nom,param[6].argument[0].c_str());
                        val=atof(param[7].argument[0].c_str());
                        coq->ajouter_ccf(nom,val);
                    }
                }*/
            }
           if (entite=="POUTRE_ELEMENT")
            {
            parse.decode(data.c_str(),"@,(&),@,(&)",param+2);
            MG_POUTRE_ELEMENT* pou=new MG_POUTRE_ELEMENT(id);    
            mggeo->ajouter_mg_poutre(pou);
            int nbele=atoi(param[2].argument[0].c_str());
            for (int i=0;i<nbele;i++)
            {
            unsigned long idele=cid(param[3].argument[i].c_str());
            pou->ajouter_element(idele);
            }
            int nb=atoi(param[4].argument[0].c_str());
            if (nb!=0) lire_ccf(version_fichier,nb,5,parse,param,pou);
            /*if (nb!=0)
                {
                    for (int i=0;i<nb;i++)
                    {
                        parse.decode(param[5].argument[i].c_str(),"(@,@)",param+6);
                        char nom[3];
                        double val;
                        strcpy(nom,param[6].argument[0].c_str());
                        val=atof(param[7].argument[0].c_str());
                        pou->ajouter_ccf(nom,val);
                    }
                }*/
            }
            if (entite=="VOLUME_ELEMENT")
            {
            if (version_fichier<2.35)
              parse.decode(data.c_str(),"@,(&),@,(&)",param+2);
            else
              parse.decode(data.c_str(),"@,(&),(&),@,(&)",param+2);
            MG_VOLUME_ELEMENT* vol=new MG_VOLUME_ELEMENT(id);    
            mggeo->ajouter_mg_volume(vol);
            int numparamnb=4;
            if (version_fichier>2.35)
          {
          numparamnb=5;
          lire_contrainte(4,param,vol);
            
          }
        int nb=atoi(param[numparamnb].argument[0].c_str());
            if (nb!=0) lire_ccf(version_fichier,nb,numparamnb+1,parse,param,vol);
            
            }
          if (entite=="SOMMET_NOEUD")
            {
            if (version_fichier<2.35)
              parse.decode(data.c_str(),"@,@,(&)",param+2);
            else
              parse.decode(data.c_str(),"@,(&),@,(&)",param+2);
                long idnoeud=cid(param[2].argument[0]);
                MG_SOMMET_NOEUD* mgsom=new MG_SOMMET_NOEUD(id,idnoeud);
                mggeo->ajouter_mg_sommet(mgsom);
                int numparamnb=3;
                if (version_fichier>2.35)
                  {
                  numparamnb=4;
                  lire_contrainte(3,param,mgsom);
                    
                  }
                int nb=atoi(param[numparamnb].argument[0].c_str());
                if (nb!=0) lire_ccf(version_fichier,nb,numparamnb+1,parse,param,mgsom);
                    }
            if (entite=="ARETE")
            {
              lire_MG_ARETE(id,parse,param,data,mggeo);
            }
            if (entite=="COSOMMET")
            {
                parse.decode(data.c_str(),"@,@,@",param+2);
                long idsom=cid(param[2].argument[0]);
                long idarete=cid(param[3].argument[0]);
                int num=atoi(param[4].argument[0].c_str());
                MG_SOMMET* mgsom=mggeo->get_mg_sommetid(idsom);
                MG_ARETE* mgarete=mggeo->get_mg_areteid(idarete);
                MG_COSOMMET* mgcosom=mggeo->ajouter_mg_cosommet(id,mgarete,mgsom);
                if (num==1) mgarete->changer_cosommet1(mgcosom);
                if (num==2) mgarete->changer_cosommet2(mgcosom);
            }
            if (entite=="COARETE")
            {
                parse.decode(data.c_str(),"@,@,@",param+2);
                long idarete=cid(param[2].argument[0]);
                long idboucle=cid(param[3].argument[0]);
                int sens=atoi(param[4].argument[0].c_str());
                MG_ARETE* mgarete=mggeo->get_mg_areteid(idarete);
                MG_BOUCLE* mgboucle=mggeo->get_mg_boucleid(idboucle);
                MG_COARETE* mgcoarete=mggeo->ajouter_mg_coarete(id,mgarete,mgboucle,sens);
                mgboucle->ajouter_mg_coarete(mgcoarete);
            }
            if (entite=="VISU_COURBE")
            {
                parse.decode(data.c_str(),"@,@,@,@,@,@",param+2);
                double xyz1[3];
                double xyz2[3];
                xyz1[0]=atof(param[2].argument[0].c_str());
                xyz1[1]=atof(param[3].argument[0].c_str());
                xyz1[2]=atof(param[4].argument[0].c_str());
                xyz2[0]=atof(param[5].argument[0].c_str());
                xyz2[1]=atof(param[6].argument[0].c_str());
                xyz2[2]=atof(param[7].argument[0].c_str());
                MG_VISU_COURBE* mgcrb=new MG_VISU_COURBE(id,xyz1,xyz2);
                mggeo->ajouter_mg_visu_courbe(mgcrb);
            }
            if (entite=="MAILLAGE")
            {
                parse.decode(data.c_str(),"@",param+2);
                long idgeo=cid(param[2].argument[0]);
                mggeo=get_mg_geometrieid(idgeo);
                if(mggeo==NULL) mggeo=get_mg_constructionid(idgeo);
                mgmai=new MG_MAILLAGE(id,mggeo);
                ajouter_mg_maillage(mgmai);
            }
            if (entite=="MAILLAGE_STRUCTURE")
            {
                parse.decode(data.c_str(),"@,@,@,@,@,@,@,@,@,@",param+2);
                long idgeo=cid(param[2].argument[0]);
                mggeo=get_mg_geometrieid(idgeo);
                mgmai=new MG_MAILLAGE(id,mggeo);
                ajouter_mg_maillage(mgmai);
                double xmin=atof(param[3].argument[0].c_str());
                double ymin=atof(param[4].argument[0].c_str());
                double zmin=atof(param[5].argument[0].c_str());
                double xmax=atof(param[6].argument[0].c_str());
                double ymax=atof(param[7].argument[0].c_str());
                double zmax=atof(param[8].argument[0].c_str());
                int nx=atoi(param[9].argument[0].c_str());
                int ny=atoi(param[10].argument[0].c_str());
                int nz=atoi(param[11].argument[0].c_str());
                BOITE_3D b(xmin,ymin,zmin,xmax,ymax,zmax);
                mgmai->change_param_structure(b,nx,ny,nz);
            }
            if (entite=="FEM_MAILLAGE")
            {
                parse.decode(data.c_str(),"@,@,@",param+2);
                int degre=atoi(param[2].argument[0].c_str());
                long idmai=cid(param[3].argument[0]);
                long idgeo=cid(param[4].argument[0]);
                mggeo=get_mg_geometrieid(idgeo);
                if (mggeo==NULL) mggeo=get_mg_constructionid(idgeo);
                mgmai=get_mg_maillageid(idmai);
                femmai=new FEM_MAILLAGE(id,mggeo,mgmai,degre);
                ajouter_fem_maillage(femmai);
            }
            if (entite=="FEM_MAILLAGE_STRUCTURE")
            {
                parse.decode(data.c_str(),"@,@,@,@,@,@,@,@,@,@,@,@",param+2);
                int degre=atoi(param[2].argument[0].c_str());
                long idmai=cid(param[3].argument[0]);
                long idgeo=cid(param[4].argument[0]);
                mggeo=get_mg_geometrieid(idgeo);
                mgmai=get_mg_maillageid(idmai);
                femmai=new FEM_MAILLAGE(id,mggeo,mgmai,degre);
                ajouter_fem_maillage(femmai);
                double xmin=atof(param[5].argument[0].c_str());
                double ymin=atof(param[6].argument[0].c_str());
                double zmin=atof(param[7].argument[0].c_str());
                double xmax=atof(param[8].argument[0].c_str());
                double ymax=atof(param[9].argument[0].c_str());
                double zmax=atof(param[10].argument[0].c_str());
                int nx=atoi(param[11].argument[0].c_str());
                int ny=atoi(param[12].argument[0].c_str());
                int nz=atoi(param[13].argument[0].c_str());
                BOITE_3D b(xmin,ymin,zmin,xmax,ymax,zmax);
                femmai->change_param_structure(b,nx,ny,nz);
            }
            if (entite=="NOEUD") lire_NOEUD(id,parse,param,data,mgmai,mggeo);
            if (entite=="FEM_NOEUD")
            {
                parse.decode(data.c_str(),"@,@,@,@,@,@,@",param+2);
                long idtopo=cid(param[2].argument[0]);
                long idmai=cid(param[3].argument[0]);
                double x=atof(param[4].argument[0].c_str());
                double y=atof(param[5].argument[0].c_str());
                double z=atof(param[6].argument[0].c_str());
                int num=atoi(param[7].argument[0].c_str());
                int numopt=atoi(param[8].argument[0].c_str());
                MG_ELEMENT_MAILLAGE* elmai;
                if (idmai>-1)
                {
                    elmai=mgmai->get_mg_noeudid(idmai);
                    if (elmai==NULL) elmai=mgmai->get_mg_segmentid(idmai);
                    if (elmai==NULL) elmai=mgmai->get_mg_triangleid(idmai);
                    if (elmai==NULL) elmai=mgmai->get_mg_tetraid(idmai);
                }
                else elmai=NULL;
                FEM_NOEUD* noeud;
                if (elmai!=NULL) noeud=new FEM_NOEUD(id,elmai,x,y,z);
                else
                {
                    MG_ELEMENT_TOPOLOGIQUE* topo;
                    if (idtopo>-1)
                    {
                        topo=mggeo->get_mg_sommetid(idtopo);
                        if (topo==NULL) topo=mggeo->get_mg_areteid(idtopo);
                        if (topo==NULL) topo=mggeo->get_mg_faceid(idtopo);
                        if (topo==NULL) topo=mggeo->get_mg_volumeid(idtopo);
                    }
                    else topo=NULL;
                    noeud=new FEM_NOEUD(id,topo,x,y,z);
                }
                noeud->change_numero(num);
                noeud->change_numero_opt(numopt);
                femmai->ajouter_fem_noeud(noeud);
            }
            if (entite=="FEM_NOEUD_DEF")
            {
                parse.decode(data.c_str(),"@,@,@",param+2);
                double x=atof(param[2].argument[0].c_str());
                double y=atof(param[3].argument[0].c_str());
                double z=atof(param[4].argument[0].c_str());
                FEM_NOEUD* noeud=femmai->get_fem_noeudid(id);
                noeud->change_dx(x);
                noeud->change_dy(y);
                noeud->change_dz(z);
                femmai->active_deforme();
            }
            if (entite=="FEM_NOEUD_REAC")
            {
                parse.decode(data.c_str(),"@,@,@",param+2);
                double x=atof(param[2].argument[0].c_str());
                double y=atof(param[3].argument[0].c_str());
                double z=atof(param[4].argument[0].c_str());
                FEM_NOEUD* noeud=femmai->get_fem_noeudid(id);
                noeud->change_rx(x);
                noeud->change_ry(y);
                noeud->change_rz(z);
                femmai->active_reaction();;
            }
            if (entite=="SEGMENT") lire_SEGMENT(id,parse,param,data,mgmai,mggeo);
            if (entite=="FEM_ELEMENT_NOEUD")
            {
                parse.decode(data.c_str(),"@,@,@",param+2);
                long idtopo=cid(param[2].argument[0]);
                long idmai=cid(param[3].argument[0]);
                long idn1=cid(param[4].argument[0]);
                FEM_NOEUD* tab[1];
                tab[0]=femmai->get_fem_noeudid(idn1);
                MG_ELEMENT_TOPOLOGIQUE* topo=NULL;
                if (idtopo>-1)
                  topo=mggeo->get_mg_sommetid(idtopo);
                MG_ELEMENT_MAILLAGE* elmai;
                if (idmai>-1)
                    elmai=mgmai->get_mg_noeudid(idmai);
                else elmai=NULL;
                FEM_ELEMENT0* fem=new FEM_ELEMENT0(id,topo,elmai,tab);
                femmai->ajouter_fem_element0(fem);
            }
            if (entite=="FEM_SEGMENT2")
            {
                parse.decode(data.c_str(),"@,@,@,@",param+2);
                long idtopo=cid(param[2].argument[0]);
                long idmai=cid(param[3].argument[0]);
                long idn1=cid(param[4].argument[0]);
                long idn2=cid(param[5].argument[0]);
                FEM_NOEUD* tab[2];
                tab[0]=femmai->get_fem_noeudid(idn1);
                tab[1]=femmai->get_fem_noeudid(idn2);
                MG_ELEMENT_TOPOLOGIQUE* topo=NULL;
                if (idtopo>-1)
                  topo=mggeo->get_mg_areteid(idtopo);
                  if (topo==NULL) topo=mggeo->get_mg_poutreid(idtopo);
                MG_ELEMENT_MAILLAGE* elmai;
                if (idmai>-1)
                    elmai=mgmai->get_mg_segmentid(idmai);
                else elmai=NULL;
                FEM_SEGMENT2* seg=new FEM_SEGMENT2(id,topo,elmai,tab);
                femmai->ajouter_fem_element1(seg);
            }
            if (entite=="FEM_MINI_SEGMENT2")
            {
                parse.decode(data.c_str(),"@,@",param+2);
                long idn1=cid(param[2].argument[0]);
                long idn2=cid(param[3].argument[0]);
                FEM_NOEUD* tab[2];
                tab[0]=femmai->get_fem_noeudid(idn1);
                tab[1]=femmai->get_fem_noeudid(idn2);
                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());
                FEM_MINI_SEGMENT2* seg=new FEM_MINI_SEGMENT2(id,mseg,tab);
                femmai->ajouter_fem_element1(seg);
            }
            if (entite=="FEM_SEGMENT3")
            {
                parse.decode(data.c_str(),"@,@,@,@,@",param+2);
                long idtopo=cid(param[2].argument[0]);
                 long idmai=cid(param[3].argument[0]);
                long idn1=cid(param[4].argument[0]);
                long idn2=cid(param[5].argument[0]);
                long idn3=cid(param[6].argument[0]);
                FEM_NOEUD* tab[3];
                tab[0]=femmai->get_fem_noeudid(idn1);
                tab[1]=femmai->get_fem_noeudid(idn2);
                tab[2]=femmai->get_fem_noeudid(idn3);
                MG_ELEMENT_MAILLAGE* elmai;
                MG_ELEMENT_TOPOLOGIQUE* topo=NULL;
                if (idtopo>-1)
                  topo=mggeo->get_mg_areteid(idtopo);
                if (idmai>-1)
                    elmai=mgmai->get_mg_segmentid(idmai);
                else elmai=NULL;
                FEM_SEGMENT3* seg=new FEM_SEGMENT3(id,topo,elmai,tab);
                femmai->ajouter_fem_element1(seg);
            }
            if (entite=="TRIANGLE") lire_TRIANGLE(id,parse,param,data,mgmai,mggeo);
            if (entite=="QUADRANGLE") lire_QUADRANGLE(id,parse,param,data,mgmai,mggeo);
            if (entite=="FEM_TRIANGLE3")
            {
                parse.decode(data.c_str(),"@,@,@,@,@",param+2);
                long idtopo=cid(param[2].argument[0]);
                long idmai=cid(param[3].argument[0]);
                long idn1=cid(param[4].argument[0]);
                long idn2=cid(param[5].argument[0]);
                long idn3=cid(param[6].argument[0]);
                FEM_NOEUD* tab[3];
                tab[0]=femmai->get_fem_noeudid(idn1);
                tab[1]=femmai->get_fem_noeudid(idn2);
                tab[2]=femmai->get_fem_noeudid(idn3);
                MG_ELEMENT_MAILLAGE* elmai;
                if (idmai>-1)
                    elmai=mgmai->get_mg_triangleid(idmai);
                else elmai=NULL;
                MG_ELEMENT_TOPOLOGIQUE* topo=NULL;
                if (idtopo>-1)
                  topo=mggeo->get_mg_faceid(idtopo);
                FEM_TRIANGLE3* tri=new FEM_TRIANGLE3(id,topo,elmai,tab);
                femmai->ajouter_fem_element2(tri);
            }
            if (entite=="FEM_TRIANGLE6")
            {
                parse.decode(data.c_str(),"@,@,@,@,@,@,@,@",param+2);
                long idtopo=cid(param[2].argument[0]);
                long idmai=cid(param[3].argument[0]);
                long idn1=cid(param[4].argument[0]);
                long idn2=cid(param[5].argument[0]);
                long idn3=cid(param[6].argument[0]);
                long idn4=cid(param[7].argument[0]);
                long idn5=cid(param[8].argument[0]);
                long idn6=cid(param[9].argument[0]);
                FEM_NOEUD* tab[6];
                tab[0]=femmai->get_fem_noeudid(idn1);
                tab[1]=femmai->get_fem_noeudid(idn2);
                tab[2]=femmai->get_fem_noeudid(idn3);
                tab[3]=femmai->get_fem_noeudid(idn4);
                tab[4]=femmai->get_fem_noeudid(idn5);
                tab[5]=femmai->get_fem_noeudid(idn6);
                MG_ELEMENT_MAILLAGE* elmai;
                if (idmai>-1)
                    elmai=mgmai->get_mg_triangleid(idmai);
                else elmai=NULL;
                MG_ELEMENT_TOPOLOGIQUE* topo=NULL;
                if (idtopo>-1)
                  topo=mggeo->get_mg_faceid(idtopo);
                 FEM_TRIANGLE6* tri=new FEM_TRIANGLE6(id,topo,elmai,tab);
                femmai->ajouter_fem_element2(tri);
            }
            if (entite=="FEM_QUADRANGLE4")
            {
                parse.decode(data.c_str(),"@,@,@,@,@,@",param+2);
                long idtopo=cid(param[2].argument[0]);
                 long idmai=cid(param[3].argument[0]);
                long idn1=cid(param[4].argument[0]);
                long idn2=cid(param[5].argument[0]);
                long idn3=cid(param[6].argument[0]);
                long idn4=cid(param[7].argument[0]);
                FEM_NOEUD* tab[4];
                tab[0]=femmai->get_fem_noeudid(idn1);
                tab[1]=femmai->get_fem_noeudid(idn2);
                tab[2]=femmai->get_fem_noeudid(idn3);
                tab[3]=femmai->get_fem_noeudid(idn4);
                MG_ELEMENT_MAILLAGE* elmai;
                if (idmai>-1)
                    elmai=mgmai->get_mg_quadrangleid(idmai);
                else elmai=NULL;
                MG_ELEMENT_TOPOLOGIQUE* topo=NULL;
                if (idtopo>-1)
                  topo=mggeo->get_mg_faceid(idtopo);
                 FEM_QUADRANGLE4* quad=new FEM_QUADRANGLE4(id,topo,elmai,tab);
                femmai->ajouter_fem_element2(quad);
            }
            if (entite=="FEM_QUADRANGLE8")
            {
                parse.decode(data.c_str(),"@,@,@,@,@,@,@,@,@,@",param+2);
                long idtopo=cid(param[2].argument[0]);
                 long idmai=cid(param[3].argument[0]);
                long idn1=cid(param[4].argument[0]);
                long idn2=cid(param[5].argument[0]);
                long idn3=cid(param[6].argument[0]);
                long idn4=cid(param[7].argument[0]);
                long idn5=cid(param[8].argument[0]);
                long idn6=cid(param[9].argument[0]);
                long idn7=cid(param[10].argument[0]);
                long idn8=cid(param[11].argument[0]);
                FEM_NOEUD* tab[8];
                tab[0]=femmai->get_fem_noeudid(idn1);
                tab[1]=femmai->get_fem_noeudid(idn2);
                tab[2]=femmai->get_fem_noeudid(idn3);
                tab[3]=femmai->get_fem_noeudid(idn4);
                tab[4]=femmai->get_fem_noeudid(idn5);
                tab[5]=femmai->get_fem_noeudid(idn6);
                tab[6]=femmai->get_fem_noeudid(idn7);
                tab[7]=femmai->get_fem_noeudid(idn8);
                MG_ELEMENT_MAILLAGE* elmai;
                if (idmai>-1)
                    elmai=mgmai->get_mg_quadrangleid(idmai);
                else elmai=NULL;
                MG_ELEMENT_TOPOLOGIQUE* topo=NULL;
                if (idtopo>-1)
                  topo=mggeo->get_mg_faceid(idtopo);
                 FEM_QUADRANGLE8* quad=new FEM_QUADRANGLE8(id,topo,elmai,tab);
                femmai->ajouter_fem_element2(quad);
            }
            if (entite=="TETRAEDRE") lire_TETRA(id,parse,param,data,mgmai,mggeo);
            
            if (entite=="HEXAEDRE") lire_HEXA(id,parse,param,data,mgmai,mggeo);
            if (entite=="PENTAEDRE") lire_PENTA(id,parse,param,data,mgmai,mggeo);
            if (entite=="PYRAMIDE") lire_PYRAMIDE(id,parse,param,data,mgmai,mggeo);
            if (entite=="FEM_TETRA4")
            {
                parse.decode(data.c_str(),"@,@,@,@,@,@,@",param+2);
                long idtopo=cid(param[2].argument[0]);
                 long idmai=cid(param[3].argument[0]);
                long idn1=cid(param[4].argument[0]);
                long idn2=cid(param[5].argument[0]);
                long idn3=cid(param[6].argument[0]);
                long idn4=cid(param[7].argument[0]);
                long etat=atoi(param[8].argument[0].c_str());
                FEM_NOEUD* tab[4];
                tab[0]=femmai->get_fem_noeudid(idn1);
                tab[1]=femmai->get_fem_noeudid(idn2);
                tab[2]=femmai->get_fem_noeudid(idn3);
                tab[3]=femmai->get_fem_noeudid(idn4);
                MG_ELEMENT_MAILLAGE* elmai;
                if (idmai>-1)
                    elmai=mgmai->get_mg_tetraid(idmai);
                else elmai=NULL;
                MG_ELEMENT_TOPOLOGIQUE* topo=NULL;
                if (idtopo>-1)
                  topo=mggeo->get_mg_volumeid(idtopo);
                FEM_TETRA4* tet=new FEM_TETRA4(id,topo,elmai,tab);
                tet->change_etat(0,etat);
                femmai->ajouter_fem_element3(tet);
            }
            if (entite=="XFEM_ELEMENT_NOEUD")
            {
                parse.decode(data.c_str(),"@,@,@,@",param+2);
                unsigned long idele=cid(param[2].argument[0]);
                unsigned long idtopo=cid(param[3].argument[0]);
                unsigned long idn1=cid(param[4].argument[0]);
                int etat=atoi(param[5].argument[0].c_str());
                MG_ELEMENT_TOPOLOGIQUE* topo=mggeo->get_mg_sommetid(idtopo);
                 FEM_ELEMENT_MAILLAGE* mai=femmai->get_fem_element0id(idele);
                 if (mai==NULL) mai=femmai->get_fem_element1id(idele);
                if (mai==NULL) mai=femmai->get_fem_element2id(idele);
                if (mai==NULL) mai=femmai->get_fem_element3id(idele);
                FEM_NOEUD* tab[4];
                tab[0]=femmai->get_fem_noeudid(idn1);
                XFEM_ELEMENT0* xele=new XFEM_ELEMENT0(id,mai,topo,tab);
                femmai->ajouter_xfem_element0(xele);
                xele->change_etat(etat);
             }
             if (entite=="XFEM_SEGMENT2")
            {
                parse.decode(data.c_str(),"@,@,@,@,@",param+2);
                unsigned long idele=cid(param[2].argument[0]);
                unsigned long idtopo=cid(param[3].argument[0]);
                unsigned long idn1=cid(param[4].argument[0]);
                unsigned long idn2=cid(param[5].argument[0]);
                int etat=atoi(param[6].argument[0].c_str());
                  FEM_ELEMENT_MAILLAGE* mai=femmai->get_fem_element1id(idele);
                if (mai==NULL) mai=femmai->get_fem_element2id(idele);
                if (mai==NULL) mai=femmai->get_fem_element3id(idele);
                MG_ELEMENT_TOPOLOGIQUE* topo=mggeo->get_mg_areteid(idtopo);
                FEM_NOEUD* tab[4];
                tab[0]=femmai->get_fem_noeudid(idn1);
                tab[1]=femmai->get_fem_noeudid(idn2);
                XFEM_SEGMENT2* xseg=new XFEM_SEGMENT2(id,mai,topo,tab);
                femmai->ajouter_xfem_element1(xseg);
                xseg->change_etat(etat);
             }
             if (entite=="XFEM_TRIANGLE3")
            {
                parse.decode(data.c_str(),"@,@,@,@,@,@",param+2);
                unsigned long idtet=cid(param[2].argument[0]);
                unsigned long idtopo=cid(param[3].argument[0]);
                unsigned long idn1=cid(param[4].argument[0]);
                unsigned long idn2=cid(param[5].argument[0]);
                unsigned long idn3=cid(param[6].argument[0]);
                int etat=atoi(param[7].argument[0].c_str());
                FEM_ELEMENT_MAILLAGE* mai=femmai->get_fem_element3id(idtet);
                MG_ELEMENT_TOPOLOGIQUE* topo=mggeo->get_mg_volumeid(idtopo);
                FEM_NOEUD* tab[3];
                tab[0]=femmai->get_fem_noeudid(idn1);
                tab[1]=femmai->get_fem_noeudid(idn2);
                tab[2]=femmai->get_fem_noeudid(idn3);
                XFEM_TRIANGLE3* xtri=new XFEM_TRIANGLE3(id,mai,topo,tab);
                femmai->ajouter_xfem_element2(xtri);
                xtri->change_etat(etat);
             }
             if (entite=="XFEM_TETRA4")
            {
                parse.decode(data.c_str(),"@,@,@,@,@,@,@",param+2);
                unsigned long idtet=cid(param[2].argument[0]);
                unsigned long idtopo=cid(param[3].argument[0]);
                unsigned long idn1=cid(param[4].argument[0]);
                unsigned long idn2=cid(param[5].argument[0]);
                unsigned long idn3=cid(param[6].argument[0]);
                unsigned long idn4=cid(param[7].argument[0]);
                int etat=atoi(param[8].argument[0].c_str());
                FEM_ELEMENT_MAILLAGE* mai=femmai->get_fem_element3id(idtet);
                MG_ELEMENT_TOPOLOGIQUE* topo=mggeo->get_mg_volumeid(idtopo);
                FEM_NOEUD* tab[4];
                tab[0]=femmai->get_fem_noeudid(idn1);
                tab[1]=femmai->get_fem_noeudid(idn2);
                tab[2]=femmai->get_fem_noeudid(idn3);
                tab[3]=femmai->get_fem_noeudid(idn4);
                 XFEM_TETRA4* xtet=new XFEM_TETRA4(id,mai,topo,tab);
                femmai->ajouter_xfem_element3(xtet);
                xtet->change_etat(etat);
             }
            if (entite=="FEM_TETRA10")
            {
                parse.decode(data.c_str(),"@,@,@,@,@,@,@,@,@,@,@,@",param+2);
                long idtopo=cid(param[2].argument[0]);
                 long idmai=cid(param[3].argument[0]);
                long idn1=cid(param[4].argument[0]);
                long idn2=cid(param[5].argument[0]);
                long idn3=cid(param[6].argument[0]);
                long idn4=cid(param[7].argument[0]);
                long idn5=cid(param[8].argument[0]);
                long idn6=cid(param[9].argument[0]);
                long idn7=cid(param[10].argument[0]);
                long idn8=cid(param[11].argument[0]);
                long idn9=cid(param[12].argument[0]);
                long idn10=cid(param[13].argument[0]);
                FEM_NOEUD* tab[10];
                tab[0]=femmai->get_fem_noeudid(idn1);
                tab[1]=femmai->get_fem_noeudid(idn2);
                tab[2]=femmai->get_fem_noeudid(idn3);
                tab[3]=femmai->get_fem_noeudid(idn4);
                tab[4]=femmai->get_fem_noeudid(idn5);
                tab[5]=femmai->get_fem_noeudid(idn6);
                tab[6]=femmai->get_fem_noeudid(idn7);
                tab[7]=femmai->get_fem_noeudid(idn8);
                tab[8]=femmai->get_fem_noeudid(idn9);
                tab[9]=femmai->get_fem_noeudid(idn10);
                MG_ELEMENT_MAILLAGE* elmai;
                if (idmai>-1)
                    elmai=mgmai->get_mg_tetraid(idmai);
                else elmai=NULL;
                MG_ELEMENT_TOPOLOGIQUE* topo=NULL;
                if (idtopo>-1)
                  topo=mggeo->get_mg_volumeid(idtopo);
                 FEM_TETRA10* tet=new FEM_TETRA10(id,topo,elmai,tab);
                femmai->ajouter_fem_element3(tet);
            }
            if (entite=="FEM_HEXA8")
            {
                parse.decode(data.c_str(),"@,@,@,@,@,@,@,@,@,@",param+2);
                long idtopo=cid(param[2].argument[0]);
                 long idmai=cid(param[3].argument[0]);
                long idn1=cid(param[4].argument[0]);
                long idn2=cid(param[5].argument[0]);
                long idn3=cid(param[6].argument[0]);
                long idn4=cid(param[7].argument[0]);
                long idn5=cid(param[8].argument[0]);
                long idn6=cid(param[9].argument[0]);
                long idn7=cid(param[10].argument[0]);
                long idn8=cid(param[11].argument[0]);
                FEM_NOEUD* tab[8];
                tab[0]=femmai->get_fem_noeudid(idn1);
                tab[1]=femmai->get_fem_noeudid(idn2);
                tab[2]=femmai->get_fem_noeudid(idn3);
                tab[3]=femmai->get_fem_noeudid(idn4);
                tab[4]=femmai->get_fem_noeudid(idn5);
                tab[5]=femmai->get_fem_noeudid(idn6);
                tab[6]=femmai->get_fem_noeudid(idn7);
                tab[7]=femmai->get_fem_noeudid(idn8);
                MG_ELEMENT_MAILLAGE* elmai;
                if (idmai>-1)
                    elmai=mgmai->get_mg_hexaid(idmai);
                else elmai=NULL;
                MG_ELEMENT_TOPOLOGIQUE* topo=NULL;
                if (idtopo>-1)
                  topo=mggeo->get_mg_volumeid(idtopo);
                 FEM_HEXA8* hex=new FEM_HEXA8(id,topo,elmai,tab);
                femmai->ajouter_fem_element3(hex);
            }
           if (entite=="FEM_HEXA20")
            {
                parse.decode(data.c_str(),"@,@,@,@,@,@,@,@,@,@,@,@,@,@,@,@,@,@,@,@,@,@",param+2);
                long idtopo=cid(param[2].argument[0]);
                long idmai=cid(param[3].argument[0]);
                long idn1=cid(param[4].argument[0]);
                long idn2=cid(param[5].argument[0]);
                long idn3=cid(param[6].argument[0]);
                long idn4=cid(param[7].argument[0]);
                long idn5=cid(param[8].argument[0]);
                long idn6=cid(param[9].argument[0]);
                long idn7=cid(param[10].argument[0]);
                long idn8=cid(param[11].argument[0]);
                long idn9=cid(param[12].argument[0]);
                long idn10=cid(param[13].argument[0]);
                long idn11=cid(param[14].argument[0]);
                long idn12=cid(param[15].argument[0]);
                long idn13=cid(param[16].argument[0]);
                long idn14=cid(param[17].argument[0]);
                long idn15=cid(param[18].argument[0]);
                long idn16=cid(param[19].argument[0]);
                long idn17=cid(param[20].argument[0]);
                long idn18=cid(param[21].argument[0]);
                long idn19=cid(param[22].argument[0]);
                long idn20=cid(param[23].argument[0]);
                FEM_NOEUD* tab[20];
                tab[0]=femmai->get_fem_noeudid(idn1);
                tab[1]=femmai->get_fem_noeudid(idn2);
                tab[2]=femmai->get_fem_noeudid(idn3);
                tab[3]=femmai->get_fem_noeudid(idn4);
                tab[4]=femmai->get_fem_noeudid(idn5);
                tab[5]=femmai->get_fem_noeudid(idn6);
                tab[6]=femmai->get_fem_noeudid(idn7);
                tab[7]=femmai->get_fem_noeudid(idn8);
                tab[8]=femmai->get_fem_noeudid(idn9);
                tab[9]=femmai->get_fem_noeudid(idn10);
                tab[10]=femmai->get_fem_noeudid(idn11);
                tab[11]=femmai->get_fem_noeudid(idn12);
                tab[12]=femmai->get_fem_noeudid(idn13);
                tab[13]=femmai->get_fem_noeudid(idn14);
                tab[14]=femmai->get_fem_noeudid(idn15);
                tab[15]=femmai->get_fem_noeudid(idn16);
                tab[16]=femmai->get_fem_noeudid(idn17);
                tab[17]=femmai->get_fem_noeudid(idn18);
                tab[18]=femmai->get_fem_noeudid(idn19);
                tab[19]=femmai->get_fem_noeudid(idn20);
                MG_ELEMENT_MAILLAGE* elmai;
                if (idmai>-1)
                    elmai=mgmai->get_mg_hexaid(idmai);
                else elmai=NULL;
                MG_ELEMENT_TOPOLOGIQUE* topo=NULL;
                if (idtopo>-1)
                  topo=mggeo->get_mg_volumeid(idtopo);
                 FEM_HEXA20* hex=new FEM_HEXA20(id,topo,elmai,tab);
                femmai->ajouter_fem_element3(hex);
            }
            if (entite=="FEM_PENTA6")
            {
                parse.decode(data.c_str(),"@,@,@,@,@,@,@,@",param+2);
                long idtopo=cid(param[2].argument[0]);
                 long idmai=cid(param[3].argument[0]);
                long idn1=cid(param[4].argument[0]);
                long idn2=cid(param[5].argument[0]);
                long idn3=cid(param[6].argument[0]);
                long idn4=cid(param[7].argument[0]);
                long idn5=cid(param[8].argument[0]);
                long idn6=cid(param[9].argument[0]);
                FEM_NOEUD* tab[6];
                tab[0]=femmai->get_fem_noeudid(idn1);
                tab[1]=femmai->get_fem_noeudid(idn2);
                tab[2]=femmai->get_fem_noeudid(idn3);
                tab[3]=femmai->get_fem_noeudid(idn4);
                tab[4]=femmai->get_fem_noeudid(idn5);
                tab[5]=femmai->get_fem_noeudid(idn6);
                MG_ELEMENT_MAILLAGE* elmai;
                if (idmai>-1)
                    elmai=mgmai->get_mg_pentaid(idmai);
                else elmai=NULL;
                MG_ELEMENT_TOPOLOGIQUE* topo=NULL;
                if (idtopo>-1)
                  topo=mggeo->get_mg_volumeid(idtopo);
                 FEM_PENTA6* pen=new FEM_PENTA6(id,topo,elmai,tab);
                femmai->ajouter_fem_element3(pen);
            }
           if (entite=="FEM_PENTA15")
            {
                parse.decode(data.c_str(),"@,@,@,@,@,@,@,@,@,@,@,@,@,@,@,@,@",param+2);
                long idtopo=cid(param[2].argument[0]);
                 long idmai=cid(param[3].argument[0]);
                long idn1=cid(param[4].argument[0]);
                long idn2=cid(param[5].argument[0]);
                long idn3=cid(param[6].argument[0]);
                long idn4=cid(param[7].argument[0]);
                long idn5=cid(param[8].argument[0]);
                long idn6=cid(param[9].argument[0]);
                long idn7=cid(param[10].argument[0]);
                long idn8=cid(param[11].argument[0]);
                long idn9=cid(param[12].argument[0]);
                long idn10=cid(param[13].argument[0]);
                long idn11=cid(param[14].argument[0]);
                long idn12=cid(param[15].argument[0]);
                long idn13=cid(param[16].argument[0]);
                long idn14=cid(param[17].argument[0]);
                long idn15=cid(param[18].argument[0]);
                FEM_NOEUD* tab[15];
                tab[0]=femmai->get_fem_noeudid(idn1);
                tab[1]=femmai->get_fem_noeudid(idn2);
                tab[2]=femmai->get_fem_noeudid(idn3);
                tab[3]=femmai->get_fem_noeudid(idn4);
                tab[4]=femmai->get_fem_noeudid(idn5);
                tab[5]=femmai->get_fem_noeudid(idn6);
                tab[6]=femmai->get_fem_noeudid(idn7);
                tab[7]=femmai->get_fem_noeudid(idn8);
                tab[8]=femmai->get_fem_noeudid(idn9);
                tab[9]=femmai->get_fem_noeudid(idn10);
                tab[10]=femmai->get_fem_noeudid(idn11);
                tab[11]=femmai->get_fem_noeudid(idn12);
                tab[12]=femmai->get_fem_noeudid(idn13);
                tab[13]=femmai->get_fem_noeudid(idn14);
                tab[14]=femmai->get_fem_noeudid(idn15);
                MG_ELEMENT_MAILLAGE* elmai;
                if (idmai>-1)
                    elmai=mgmai->get_mg_pentaid(idmai);
                else elmai=NULL;
                MG_ELEMENT_TOPOLOGIQUE* topo=NULL;
                if (idtopo>-1)
                  topo=mggeo->get_mg_volumeid(idtopo);
                 FEM_PENTA15* pen=new FEM_PENTA15(id,topo,elmai,tab);
                femmai->ajouter_fem_element3(pen);
            }
           if (entite=="SOLUTION")
            {
                parse.decode(data.c_str(),"@,@,@,@,@,@,(&)",param+2);
                int typeentite=atoi(param[2].argument[0].c_str());
                int typesolution=atoi(param[3].argument[0].c_str());
                  std::string nomsol=param[4].argument[0];
                long idmai=cid(param[5].argument[0]);
                int nb=atoi(param[6].argument[0].c_str());
                std::string chemin=param[7].argument[0];
                MG_MAILLAGE* mai=get_mg_maillageid(idmai);
                MG_SOLUTION* sol=new MG_SOLUTION(id,mai,nb,(char*)chemin.c_str(),SOL_EXISTANTE,nomsol,typeentite,typesolution);
                ajouter_mg_solution(sol);
                for (int i=0;i<nb;i++)
                    sol->change_legende(i,param[8].argument[i]);
            }
            if (entite=="FEM_SOLUTION")
            {
                parse.decode(data.c_str(),"@,@,@,@,@,@,(&)",param+2);
                int typeentite=atoi(param[2].argument[0].c_str());
                int typesolution=atoi(param[3].argument[0].c_str());
                std::string nomsol=param[4].argument[0];
                long idmai=cid(param[5].argument[0]);
                int nb=atoi(param[6].argument[0].c_str());
                std::string chemin_sol=param[7].argument[0];
                FEM_MAILLAGE* mai=get_fem_maillageid(idmai);
                FEM_SOLUTION* sol=new FEM_SOLUTION(id,mai,nb,(char*)chemin_sol.c_str(),SOL_EXISTANTE,nomsol,typeentite,typesolution);
                ajouter_fem_solution(sol);
                for (int i=0;i<nb;i++)
                    sol->change_legende(i,param[8].argument[i]);
            }
#ifdef WINDOWS_VERSION
            if (entite=="CAD4FE_MCSEGMENT")
            {
                parse.decode(data.c_str(),"@,@,@",param+2);
                long idtopo=cid(param[2].argument[0]);
                long idn1=cid(param[3].argument[0]);
                long idn2=cid(param[4].argument[0]);
                CAD4FE::MCNode* noeud1=(CAD4FE::MCNode*)mgmai->get_mg_noeudid(idn1);
                CAD4FE::MCNode* noeud2=(CAD4FE::MCNode*)mgmai->get_mg_noeudid(idn2);
                MG_ELEMENT_TOPOLOGIQUE* topo;
                if (idtopo>-1)
                {
                    topo=mggeo->get_mg_areteid(idtopo);
                    if (topo==NULL) topo=mggeo->get_mg_faceid(idtopo);
                    if (topo==NULL) topo=mggeo->get_mg_volumeid(idtopo);
                }
                else topo=NULL;
                CAD4FE::MCSegment * seg = new CAD4FE::MCSegment(id,topo,noeud1,noeud2);
                mgmai->ajouter_mg_segment(seg);
            }
            if (entite=="CAD4FE_MCNODE")
            {
                parse.decode(data.c_str(),"@,@,@,@,@",param+2);
                long idRefTopo=cid(param[2].argument[0]);
                long idMCTopo=cid(param[3].argument[0]);
                double x=atof(param[4].argument[0].c_str());
                double y=atof(param[5].argument[0].c_str());
                double z=atof(param[6].argument[0].c_str());
                MG_ELEMENT_TOPOLOGIQUE* refTopo=NULL;
                if (refTopo==NULL) refTopo=mggeo->get_mg_sommetid(idRefTopo);
                if (refTopo==NULL) refTopo=mggeo->get_mg_areteid(idRefTopo);
                if (refTopo==NULL) refTopo=mggeo->get_mg_faceid(idRefTopo);
                if (refTopo==NULL) refTopo=mggeo->get_mg_volumeid(idRefTopo);
                MG_ELEMENT_TOPOLOGIQUE* mcTopo=NULL;
                if (mcTopo==NULL) mcTopo=mggeo->get_mg_sommetid(idMCTopo);
                if (mcTopo==NULL) mcTopo=mggeo->get_mg_areteid(idMCTopo);
                if (mcTopo==NULL) mcTopo=mggeo->get_mg_faceid(idMCTopo);
                if (mcTopo==NULL) mcTopo=mggeo->get_mg_volumeid(idMCTopo);

                if (mcTopo->get_dimension()==0)
                {
                    if (updatedMergedRefVertices == false)
                    {
                        for (std::multimap<CAD4FE::MCVertex * , unsigned long>::iterator itMergedRefVertices = mapMergedRefVertices.begin();
                                itMergedRefVertices != mapMergedRefVertices.end();
                                itMergedRefVertices++)
                        {
                            CAD4FE::MCVertex * v = itMergedRefVertices->first;
                            MG_SOMMET * refV = NULL;
                            unsigned long id = itMergedRefVertices->second;
                            refV = (MG_SOMMET *) mggeo->get_mg_sommetid(id);
                            v->MergeRefVertex(refV);
                        }

                        updatedMergedRefVertices = true;
                    }
                }

                CAD4FE::MCNode* noeud=new CAD4FE::MCNode(id,mcTopo,refTopo,x,y,z);
                mgmai->ajouter_mg_noeud(noeud);
            }
            if (entite=="CAD4FE_MCTRIANGLE")
            {
                parse.decode(data.c_str(),"@,@,@,@",param+2);
                long idtopo=cid(param[2].argument[0]);
                long idn1=cid(param[3].argument[0]);
                long idn2=cid(param[4].argument[0]);
                long idn3=cid(param[5].argument[0]);
                CAD4FE::MCNode* noeud1=(CAD4FE::MCNode*)mgmai->get_mg_noeudid(idn1);
                CAD4FE::MCNode* noeud2=(CAD4FE::MCNode*)mgmai->get_mg_noeudid(idn2);
                CAD4FE::MCNode* noeud3=(CAD4FE::MCNode*)mgmai->get_mg_noeudid(idn3);
                CAD4FE::MCSegment* mgsegment[3];
                CAD4FE::MCNode *mgnoeud[3]={noeud1,noeud2,noeud3};
                // la topo. d'un MCTriangle est obligatoirement une MCFace
                CAD4FE::MCFace* mcFace=(CAD4FE::MCFace*)mggeo->get_mg_faceid(idtopo);
                for (int i=0;i<3;i++)
                {
                    mgsegment[i]=(CAD4FE::MCSegment*)mgmai->get_mg_segment(mgnoeud[i]->get_id(),mgnoeud[(i+1)%3]->get_id());
                    if (mgsegment[i]==NULL)
                    {
                        mgsegment[i]=new CAD4FE::MCSegment(mcFace,mgnoeud[i],mgnoeud[(i+1)%3]);
                        mgmai->ajouter_mg_segment(mgsegment[i]);
                    }
                }
                CAD4FE::M3D_MCTriangle *triangle = new CAD4FE::M3D_MCTriangle(id,mcFace,noeud1,noeud2,noeud3,mgsegment[0],mgsegment[1],mgsegment[2]);
                mgmai->ajouter_mg_triangle(triangle);
            }
#endif
        }
    }
    while (param[0].argument[0]!="FIN");
    
    for (int i=0;i<volumemince.size();i=i+3)
        {
        MG_VOLUME *vol=mggeo->get_mg_volumeid(volumemince[i]);  
        MG_FACE* face1=mggeo->get_mg_faceid(volumemince[i+1]);
        MG_FACE* face2=mggeo->get_mg_faceid(volumemince[i+2]);
        vol->ajouter_face_correspondante(face1,face2);
        }
    
    
    LISTE_MG_ARBRE::iterator itarbre;
    for (MG_ARBRE* arb=get_premier_arbre(itarbre);arb!=NULL;arb=get_suivant_arbre(itarbre))
      {
      LISTE_MG_ASSEMBLAGE::iterator itass;
      for (MG_ASSEMBLAGE *ass=arb->get_premier_assemblage(itass);ass!=NULL;ass=arb->get_suivant_assemblage(itass))
        ass->ini_donne(arb);
      }
    TPL_MAP_ENTITE<MG_GEOMETRIE*> lst;
    LISTE_MG_GEOMETRIE::iterator itgeo; 
    for (MG_GEOMETRIE* geo=get_premier_geometrie(itgeo);geo;geo=get_suivant_geometrie(itgeo))
        lst.ajouter(geo);
    LISTE_MG_CONSTRUCTION::iterator itcon;      
    for (MG_GEOMETRIE* geo=get_premier_construction(itcon);geo;geo=get_suivant_construction(itcon))
        lst.ajouter(geo);
    TPL_MAP_ENTITE<MG_GEOMETRIE*>::ITERATEUR it;
    for (MG_GEOMETRIE* geo=lst.get_premier(it);geo;geo=lst.get_suivant(it))
      {
      LISTE_MG_SOMMET::iterator itsom;  
      for (MG_SOMMET* som=geo->get_premier_sommet(itsom);som;som=geo->get_suivant_sommet(itsom))
          if (som->est_une_topo_element())
          {
              MG_SOMMET_NOEUD* somno=(MG_SOMMET_NOEUD*)som;
              unsigned long idnoeud=somno->get_id_mg_noeud();
              MG_NOEUD* noeud;
              LISTE_MG_MAILLAGE::iterator itmai;        
              for (MG_MAILLAGE* mai=get_premier_mg_maillage(itmai);mai;mai=get_suivant_mg_maillage(itmai))
                  if (mai->get_mg_noeudid(idnoeud)!=NULL) noeud=mai->get_mg_noeudid(idnoeud);
              somno->change_mg_noeud(noeud);
          }
      LISTE_MG_COQUE::iterator itcoq;   
      for (MG_COQUE* coq=geo->get_premier_coque(itcoq);coq;coq=geo->get_suivant_coque(itcoq))
          if (coq->est_une_topo_element())
          {
          MG_COQUE_ELEMENT* coque=(MG_COQUE_ELEMENT*)coq;
          int nbele=coque->get_nb_liste_id();
          MG_MAILLAGE* mgmai=NULL;
          for (int i=0;i<nbele;i++)
            {
             unsigned long eleid=coque->get_liste_id(i);
             if (i==0)
              {
               LISTE_MG_MAILLAGE::iterator itmai;       
               for (MG_MAILLAGE* mai=get_premier_mg_maillage(itmai);mai;mai=get_suivant_mg_maillage(itmai))
                {
                 if (mai->get_mg_triangleid(eleid)!=NULL) mgmai=mai;
                 if (mai->get_mg_quadrangleid(eleid)!=NULL) mgmai=mai;
                }
              }
            MG_ELEMENT_MAILLAGE* ele=NULL;
            if (ele==NULL) ele=mgmai->get_mg_triangleid(eleid);
            if (ele==NULL) ele=mgmai->get_mg_quadrangleid(eleid);
            coque->ajouter_element(ele);
            }
            
          }
      LISTE_MG_POUTRE::iterator itpou;  
      for (MG_POUTRE* pou=geo->get_premier_poutre(itpou);pou;pou=geo->get_suivant_poutre(itpou))
          if (pou->est_une_topo_element())
          {
          MG_POUTRE_ELEMENT* poutre=(MG_POUTRE_ELEMENT*)pou;
          int nbele=poutre->get_nb_liste_id();
          MG_MAILLAGE* mgmai=NULL;
          for (int i=0;i<nbele;i++)
            {
             unsigned long eleid=poutre->get_liste_id(i);
             if (i==0)
              {
               LISTE_MG_MAILLAGE::iterator itmai;       
               for (MG_MAILLAGE* mai=get_premier_mg_maillage(itmai);mai;mai=get_suivant_mg_maillage(itmai))
                {
                 if (mai->get_mg_segmentid(eleid)!=NULL) mgmai=mai;
                }
              }
            MG_ELEMENT_MAILLAGE* ele=NULL;
            if (ele==NULL) ele=mgmai->get_mg_segmentid(eleid);
            poutre->ajouter_element(ele);
            }
            
          }
      }
#ifdef WINDOWS_VERSION
    if (updatedMergedRefVertices == false)
    {
        for (std::multimap<CAD4FE::MCVertex * , unsigned long>::iterator itMergedRefVertices = mapMergedRefVertices.begin();
                itMergedRefVertices != mapMergedRefVertices.end();
                itMergedRefVertices++)
        {
            CAD4FE::MCVertex * v = itMergedRefVertices->first;
            MG_SOMMET * refV = NULL;
            unsigned long id = itMergedRefVertices->second;
            refV = (MG_SOMMET *) mggeo->get_mg_sommetid(id);
            v->MergeRefVertex(refV);
        }

        updatedMergedRefVertices = true;
    }

#endif
    fclose(in);
    return 1;
}


Revision:	1185
Committed:	Mon Nov 11 21:29:00 2024 UTC (6 months, 1 week ago) by francois
File size:	145244 byte(s)
Log Message:	finition de l'enregistrement des contraintes