Back to index

salome-smesh  6.5.0
MeshCut_Maillage.cxx
Go to the documentation of this file.
00001 // Copyright (C) 2006-2012  EDF R&D
00002 //
00003 // This library is free software; you can redistribute it and/or
00004 // modify it under the terms of the GNU Lesser General Public
00005 // License as published by the Free Software Foundation; either
00006 // version 2.1 of the License.
00007 //
00008 // This library is distributed in the hope that it will be useful,
00009 // but WITHOUT ANY WARRANTY; without even the implied warranty of
00010 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00011 // Lesser General Public License for more details.
00012 //
00013 // You should have received a copy of the GNU Lesser General Public
00014 // License along with this library; if not, write to the Free Software
00015 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
00016 //
00017 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
00018 //
00019 
00020 #include "MeshCut_Maillage.hxx"
00021 #include "MeshCut_Cube.hxx"
00022 
00023 #include <iostream>
00024 #include <sstream>
00025 #include <list>
00026 #include <algorithm>
00027 #include <cmath>
00028 #include <cstring>
00029 
00030 using namespace MESHCUT;
00031 using namespace std;
00032 
00033 Maillage::Maillage(std::string _ID)
00034 {
00035   ID = _ID;
00036   nombreNoeudsMaillage = 0;
00037   nombreMaillesMaillage = 0;
00038   //nPOI1=0; nSEG2=0; nSEG3=0; nTRIA3=0; nTRIA6=0; nQUAD4=0; nQUAD8=0; nTETRA4=0; nTETRA10=0; nPYRAM5=0; nPYRAM13=0; nPENTA6=0; nPENTA15=0; nHEXA8=0; nHEXA20=0;
00039   GM.clear();
00040   GN.clear();
00041   for (int itm = (int) POI1; itm <= (int) HEXA20; itm++)
00042     EFFECTIFS_TYPES[(TYPE_MAILLE) itm] = 0;
00043 }
00044 
00045 Maillage::~Maillage()
00046 {
00047 }
00048 
00049 void Maillage::creationGMtype(TYPE_MAILLE tm, std::string nomGMtype)
00050 {
00051   //cout << "Creation GM type, groupe " << nomGMtype << endl;
00052   for (int nl = 0; nl < EFFECTIFS_TYPES[tm]; nl++)
00053     GM[nomGMtype][tm].push_back(nl);
00054   GM[nomGMtype][tm].resize(EFFECTIFS_TYPES[tm]);
00055   sort(GM[nomGMtype][tm].begin(), GM[nomGMtype][tm].end());
00056 }
00057 
00058 void Maillage::afficheMailles(TYPE_MAILLE tm)
00059 {
00060   cout << "Affichage des mailles du type " << TM2string(tm) << " (effectif " << EFFECTIFS_TYPES[tm] << "): " << endl;
00061   if (EFFECTIFS_TYPES[tm])
00062     {
00063       // Boucle sur les connectivités d'un type tm
00064       int nnoeuds = Nnoeuds(tm);
00065       for (int i = 0; i < EFFECTIFS_TYPES[tm]; i++)
00066         {
00067           cout << "\tMaille " << i << " :" << endl;
00068           //Boucle sur les noeuds de la maille de numéro local i dans le type tm
00069           int * offset = CNX[tm] + nnoeuds * i;
00070           for (int j = 0; j < nnoeuds; j++)
00071             {
00072               int ngnoeud = *(offset + j);
00073               //cout << "\t\t" << X[ngnoeud-1] << " " << Y[ngnoeud-1] << " " << Z[ngnoeud-1] << endl;
00074               cout << "\t" << ngnoeud << "\t" << *(XX + ngnoeud - 1) << " " << *(YY + ngnoeud - 1) << " " << *(ZZ + ngnoeud - 1) << endl;
00075             }
00076         }
00077       cout << endl;
00078     }
00079 }
00080 
00081 void Maillage::listeMaillesType(TYPE_MAILLE tm)
00082 {
00083   cout << "La fonction \"Restitution des mailles par type\" est obsolète " << endl;
00084 
00085   //  cout << "Restitution des mailles du type " << TM2string(tm) << " (effectif " << EFFECTIFS_TYPES[tm] << "): " << endl;
00086   //  if (EFFECTIFS_TYPES[tm])
00087   //    for (int i = 0; i < IDS_MAILLES[tm].size(); i++)
00088   //      cout << IDS_MAILLES[tm][i] << " ";
00089   //  cout << endl;
00090 }
00091 
00092 void Maillage::listeMaillesTousTypes()
00093 {
00094   for (int itm = (int) POI1; itm <= (int) HEXA20; itm++)
00095     {
00096       TYPE_MAILLE tm = (TYPE_MAILLE) itm;
00097       listeMaillesType(tm);
00098     }
00099 }
00100 
00101 void Maillage::listeMaillesParGM()
00102 {
00103   cout << "Liste des mailles par GM : " << endl;
00104   for (map<string, map<TYPE_MAILLE, vector<int> > >::iterator I = GM.begin(); I != GM.end(); I++)
00105     listeMaillesGM(I->first);
00106 }
00107 
00108 void Maillage::listeMaillesGM(std::string nomGM)
00109 {
00110   cout << "Liste des mailles du groupe " << nomGM << " : " << endl;
00111   for (int itm = (int) POI1; itm <= (int) HEXA20; itm++)
00112     {
00113       TYPE_MAILLE tm = (TYPE_MAILLE) itm;
00114       if (GM[nomGM][tm].size())
00115         {
00116           cout << "\t" << TM2string(tm) << " : ";
00117           for (unsigned int j = 0; j < GM[nomGM][tm].size(); j++)
00118             cout << GM[nomGM][tm][j] << " ";
00119           cout << endl;
00120         }
00121     }
00122 }
00123 
00124 //void Maillage::listeMaillesGMordonne(std::string nomGM)
00125 //{
00126 //  cout << "Liste ordonnée des mailles du groupe " << nomGM << " (" << GM[nomGM].size() << " mailles) : ";
00127 //  sort(GM[nomGM].begin(), GM[nomGM].end());
00128 //  for (int j = 0; j < GM[nomGM].size(); j++)
00129 //    cout << GM[nomGM][j] << " ";
00130 //  cout << endl;
00131 //}
00132 
00133 void Maillage::listeNoeuds()
00134 {
00135   cout << "Liste des noeuds du maillage : " << endl;
00136   for (int i = 0; i < nombreNoeudsMaillage; i++)
00137     cout << "\t" << *(XX + i) << " " << *(YY + i) << " " << *(ZZ + i) << endl;
00138   cout << endl;
00139 }
00140 
00141 void Maillage::listeNoeudsGN(std::string nomGN)
00142 {
00143   cout << "Liste brute des noeuds du groupe " << nomGN << " (" << GN[nomGN].size() << " noeuds) : ";
00144   for (unsigned int j = 0; j < GN[nomGN].size(); j++)
00145     cout << GN[nomGN][j] << " ";
00146   cout << endl;
00147 }
00148 
00149 void Maillage::listeNoeudsGNordonne(std::string nomGN)
00150 {
00151   cout << "Liste ordonnée des noeuds du groupe " << nomGN << " (" << GN[nomGN].size() << " noeuds) : ";
00152   sort(GN[nomGN].begin(), GN[nomGN].end());
00153   for (unsigned int j = 0; j < GN[nomGN].size(); j++)
00154     cout << GN[nomGN][j] << " ";
00155   cout << endl;
00156 }
00157 
00158 std::vector<float> Maillage::G(int i, TYPE_MAILLE tm)
00159 {
00160   vector<float> G;
00161   float x = 0.0;
00162   float y = 0.0;
00163   float z = 0.0;
00164   int nn = NnoeudsGeom(tm);
00165   for (int j = 0; j < nn; j++)
00166     {
00167       int ng = CNX[tm][nn * i + j];
00168       x += XX[ng - 1];
00169       y += YY[ng - 1];
00170       z += ZZ[ng - 1];
00171     }
00172   G.push_back(x / nn);
00173   G.push_back(y / nn);
00174   G.push_back(z / nn);
00175   G.resize(3);
00176   return G;
00177 }
00178 
00179 float Maillage::distanceNoeudMaille(int ngnoeud, int imaille, TYPE_MAILLE tm)
00180 {
00181   float x, y, z;
00182   float x0 = XX[ngnoeud - 1];
00183   float y0 = YY[ngnoeud - 1];
00184   float z0 = ZZ[ngnoeud - 1];
00185   int nn = NnoeudsGeom(tm);
00186   float d1 = 1000000000000.0;
00187   float d;
00188   for (int j = 0; j < nn; j++)
00189     {
00190       int ng = CNX[tm][nn * imaille + j]; // Noeud courant dans la maille
00191       x = XX[ng - 1];
00192       y = YY[ng - 1];
00193       z = ZZ[ng - 1];
00194       d = sqrt((x - x0) * (x - x0) + (y - y0) * (y - y0) + (z - z0) * (z - z0));
00195       if (d < d1)
00196         d1 = d;
00197     }
00198   return d1;
00199 }
00200 
00204 int Maillage::noeudVoisin(int ngnoeud, int imaille, TYPE_MAILLE tm)
00205 {
00206   float x, y, z;
00207   int ngv;
00208   float x0 = XX[ngnoeud - 1];
00209   float y0 = YY[ngnoeud - 1];
00210   float z0 = ZZ[ngnoeud - 1];
00211   int nn = NnoeudsGeom(tm);
00212   float d1 = 1000000000000.0;
00213   float d;
00214   for (int j = 0; j < nn; j++)
00215     {
00216       int ng = CNX[tm][nn * imaille + j]; // Noeud courant dans la maille
00217       x = XX[ng - 1];
00218       y = YY[ng - 1];
00219       z = ZZ[ng - 1];
00220       d = sqrt((x - x0) * (x - x0) + (y - y0) * (y - y0) + (z - z0) * (z - z0));
00221       if (d < d1)
00222         {
00223           d1 = d;
00224           ngv = ng;
00225         }
00226     }
00227   return ngv;
00228 }
00229 
00230 float Maillage::distanceNoeudNoeud(int ng1, int ng2)
00231 {
00232   float x1, x2, y1, y2, z1, z2;
00233   x1 = XX[ng1 - 1];
00234   y1 = YY[ng1 - 1];
00235   z1 = ZZ[ng1 - 1];
00236   x2 = XX[ng2 - 1];
00237   y2 = YY[ng2 - 1];
00238   z2 = ZZ[ng2 - 1];
00239   return sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2) + (z1 - z2) * (z1 - z2));
00240 }
00241 
00242 //void Maillage::encombrements()
00243 //{
00244 //  float ex = 0.0;
00245 //  float ey = 0.0;
00246 //  float ez = 0.0;
00247 //
00248 //  for (int itm = (int) SEG2; itm <= (int) HEXA20; itm++)
00249 //    {
00250 //      TYPE_MAILLE tm = (TYPE_MAILLE) itm;
00251 //      if (MAILLAGE->EFFECTIFS_TYPES[tm])
00252 //        {
00253 //          int nnoeuds = Nnoeuds(tm);
00254 //          for (int i = 0; i < CON[tm].size() / nnoeuds; i++)
00255 //            {
00256 //              //Boucle sur les noeuds de la maille de numéro local i dans le type tm
00257 //              for (int j = 0; j < nnoeuds; j++)
00258 //                {
00259 //                  //..... CON[tm][nnoeuds*i+j];
00260 //                }
00261 //            }
00262 //        }
00263 //    }
00264 //  // Boucle sur les connectivités d'un type tm
00265 //}
00266 
00267 void Maillage::inputMED(std::string fichierMED)
00268 {
00269   //cout << endl << "Début procédure inputMED, fichier "<< fichierMED << endl;
00270 
00271   //  int i, j, k, ichamp, igauss, ipt, ival;
00272   int j;
00273   //  med_err ret = 0; // Code retour
00274   med_idt fid; // Descripteur de fichier MED
00275   char maa[MED_NAME_SIZE + 1]; // nom du maillage de longueur maxi MED_NAME_SIZE
00276   med_int spacedim;
00277   med_int mdim; // Dimension du maillage
00278   med_mesh_type type;
00279   char desc[MED_COMMENT_SIZE + 1]; // Description du maillage
00280 
00281   // Profils
00282   //  med_int nprofils;
00283   //  int iprofil;
00284   //  char nomprofil[MED_NAME_SIZE + 1] = "";
00285   //  med_int nvalprofil, nvalprofil2;
00286   //  med_int *pflval;
00287 
00288   // Champs
00289   //  med_int nChamps, nCompChamp, nval;
00290   //  char *compChamp, *unitChamp, *nomChamp;
00291   //char nomChamp [ MED_NAME_SIZE+1 ] = "";
00292   //  med_field_type typeChamp;
00293   //  med_int nGauss, ngpdt, numdt, numo;
00294   med_int nPasTemps;
00295   //  char locname[MED_NAME_SIZE + 1] = "";
00296   //  med_geometry_type type_geo;
00297   //  med_int ngauss;
00298   char dtunit[MED_SNAME_SIZE + 1] = "";
00299   //  med_float dt = 0.0;
00300   //  med_bool local;
00301   //  med_int nbrefmaa;
00302 
00303   med_sorting_type sortingtype;
00304   med_axis_type axistype;
00305 
00306   // Initialisations
00307   FAMILLES.clear();
00308   FAM_TYPES.clear();
00309   FAMILLES_NOEUDS.clear();
00310   GROUPES_MAILLES.clear();
00311   GROUPES_NOEUDS.clear();
00312   RESIDU.clear(); // Sera initialisé à 1 par la routine acquisitionTYPE_inputMED
00313   tailleFAMILLES.clear();
00314   tailleGROUPES.clear();
00315 
00316   // Ouverture du fichier MED en lecture seule
00317   fid = MEDfileOpen(string2char(fichierMED), MED_ACC_RDONLY);
00318   if (fid < 0)
00319     {
00320       ERREUR("Error file open\n");
00321     }
00322   //cout << chrono() << " --- inputMED: MEDfileOpen: ouverture du maillage en lecture seule, OK" << endl;
00323 
00324   // Lecture des infos concernant le premier maillage
00325   if (MEDmeshInfo(fid, 1, maa, &spacedim, &mdim, &type, desc, dtunit, &sortingtype, &nPasTemps, &axistype, axisname,
00326                   unitname) < 0)
00327     ERREUR("Error while reading mesh informations ");
00328   //cout << chrono() << " --- inputMED: MEDmeshInfo: OK" << endl;
00329 
00330 //  cerr << "maa=" << maa << endl;
00331 //  cerr << "spacedim=" << spacedim << endl;
00332 //  cerr << "mdim=" << mdim << endl;
00333 //  cerr << "type=" << type << endl;
00334 //  cerr << "desc=" << desc << endl;
00335 //  cerr << "dtunit=" << dtunit << endl;
00336 //  cerr << "sortingtype=" << sortingtype << endl;
00337 //  cerr << "nPasTemps=" << nPasTemps << endl;
00338 //  cerr << "axistype=" << axistype << endl;
00339 //  cerr << "axisname=" << axisname << endl;
00340 //  cerr << "unitname=" << unitname << endl;
00341 
00342   dimensionMaillage = mdim;
00343   dimensionEspace = spacedim;
00344 
00345   ID = (string) maa;
00346 
00347   //  nGauss = MEDnGauss(fid);
00348   //  if (debug > 0)
00349   //    cout << "Nombre d'éléments portant des points de Gauss: " << (int) nGauss << endl;
00350   //  map<string, int> REFGAUSS;
00351   //  map<string, int>::iterator iterGAUSS;
00352   //  for (igauss = 1; igauss <= nGauss; igauss++)
00353   //    {
00354   //      if (MEDgaussInfo(fid, igauss, locname, &type_geo, &ngauss) < 0)
00355   //        ERREUR("Erreur MEDgaussInfo");
00356   //      if (debug == 2)
00357   //        {
00358   //          cout << endl << "  Retour MEDgaussInfo, localisation gauss n°" << igauss << " : " << endl;
00359   //          cout << "    locname  = " << locname << endl;
00360   //          cout << "    type_geo = " << type_geo << endl;
00361   //          cout << "    ngauss   = " << ngauss << endl;
00362   //          cout << endl;
00363   //        }
00364   //      REFGAUSS[(string) locname] = (int) ngauss;
00365   //    }
00366   //
00367   //  if (debug == 2)
00368   //    {
00369   //      cout << endl << "Restitution de la table REFGAUSS:" << endl;
00370   //      for (iterGAUSS = REFGAUSS.begin(); iterGAUSS != REFGAUSS.end(); iterGAUSS++)
00371   //        {
00372   //          cout << iterGAUSS->first << " : " << iterGAUSS->second << endl;
00373   //        }
00374   //    }
00375   //
00376   //  nprofils = MEDnProfil(fid);
00377   //  if (debug)
00378   //    cout << endl << endl << "Nombre de profils: " << nprofils << endl;
00379   //  for (iprofil = 1; iprofil <= nprofils; iprofil++)
00380   //    {
00381   //      if (MEDprofilInfo(fid, iprofil, nomprofil, &nvalprofil) < 0)
00382   //        ERREUR("ERREUR MEDprofilInfo");
00383   //      nvalprofil2 = MEDnValProfil(fid, nomprofil);
00384   //      if (debug == 2)
00385   //        {
00386   //          cout << "Profil " << iprofil << " : " << endl;
00387   //          cout << "    Nom profil : " << nomprofil << endl;
00388   //          cout << "    Nombre de valeurs profil (par MEDprofilInfo) : " << nvalprofil << endl;
00389   //          cout << "    Nombre de valeurs profil (par MEDnValProfil) : " << nvalprofil2 << endl;
00390   //        }
00391   //      if (nvalprofil != nvalprofil2)
00392   //        ERREUR("Discordance nvalprofil (entre MEDprofilInfo et MEDnValProfil)");
00393   //      pflval = (med_int*) malloc(sizeof(med_int) * nvalprofil);
00394   //      if (MEDprofilLire(fid, pflval, nomprofil) < 0)
00395   //        ERREUR("ERREUR MEDprofilLire");
00396   //      //cout << "    Affichage des 100 premières valeurs:" << endl;
00397   //      //for (ival=0;ival<min(100,nvalprofil);ival++) cout << " " << *(pflval+ival) ;
00398   //      free(pflval);
00399   //    }
00400   //
00401   //  nChamps = MEDnChamp(fid, 0);
00402   //  cout << "Nombre de champs : " << (int) nChamps << endl;
00403   //
00404   //  if (nChamps > 0)
00405   //    {
00406   //
00407   //      for (ichamp = 1; ichamp <= nChamps; ichamp++)
00408   //        {
00409   //          //for (ichamp=4; ichamp<=4; ichamp++ ) {
00410   //          cout << endl << endl;
00411   //          cout << endl << endl << " ====================================================================" << endl;
00412   //          cout << endl << endl << "                             CHAMP " << ichamp << endl;
00413   //          cout << endl << endl << " ====================================================================" << endl;
00414   //          cout << endl << endl;
00415   //
00416   //          nCompChamp = MEDnChamp(fid, ichamp);
00417   //          if (nCompChamp < 0)
00418   //            ERREUR("Erreur Ncomposantes champ");
00419   //          cout << "Nombre de composantes du champ " << ichamp << " : " << (int) nCompChamp << endl;
00420   //
00421   //          nomChamp = (char*) malloc(MED_NAME_SIZE + 1);
00422   //          compChamp = (char*) malloc(nCompChamp * MED_SNAME_SIZE + 1);
00423   //          unitChamp = (char*) malloc(nCompChamp * MED_SNAME_SIZE + 1);
00424   //
00425   //          if (MEDchampInfo(fid, ichamp, nomChamp, &typeChamp, compChamp, unitChamp, nCompChamp) < 0)
00426   //            ERREUR("Erreur MEDchampInfo");
00427   //
00428   //          cout << "Infos sur le champ " << ichamp << " : " << endl;
00429   //          cout << "  Nom:  " << (string) nomChamp << endl;
00430   //          cout << "  Type:  " << typeChamp << endl;
00431   //          cout << "  Noms des composantes:  " << (string) compChamp << endl;
00432   //          cout << "  Unités des composantes:  " << (string) unitChamp << endl;
00433   //
00434   //          infoChamps((string) "NOEUDS", MED_NODE, MED_NONE, fid, maa, nomChamp, typeChamp, nCompChamp, REFGAUSS);
00435   //          infoChamps((string) "POI1", MED_CELL, MED_POINT1, fid, maa, nomChamp, typeChamp, nCompChamp, REFGAUSS);
00436   //          infoChamps((string) "SEG2", MED_CELL, MED_SEG2, fid, maa, nomChamp, typeChamp, nCompChamp, REFGAUSS);
00437   //          infoChamps((string) "SEG3", MED_CELL, MED_SEG3, fid, maa, nomChamp, typeChamp, nCompChamp, REFGAUSS);
00438   //          infoChamps((string) "TRIA3", MED_CELL, MED_TRIA3, fid, maa, nomChamp, typeChamp, nCompChamp, REFGAUSS);
00439   //          infoChamps((string) "TRIA6", MED_CELL, MED_TRIA6, fid, maa, nomChamp, typeChamp, nCompChamp, REFGAUSS);
00440   //          infoChamps((string) "QUAD4", MED_CELL, MED_QUAD4, fid, maa, nomChamp, typeChamp, nCompChamp, REFGAUSS);
00441   //          infoChamps((string) "QUAD8", MED_CELL, MED_QUAD8, fid, maa, nomChamp, typeChamp, nCompChamp, REFGAUSS);
00442   //          infoChamps((string) "TETRA4", MED_CELL, MED_TETRA4, fid, maa, nomChamp, typeChamp, nCompChamp, REFGAUSS);
00443   //          infoChamps((string) "TETRA10", MED_CELL, MED_TETRA10, fid, maa, nomChamp, typeChamp, nCompChamp, REFGAUSS);
00444   //          infoChamps((string) "PYRAM5", MED_CELL, MED_PYRA5, fid, maa, nomChamp, typeChamp, nCompChamp, REFGAUSS);
00445   //          infoChamps((string) "PYRAM13", MED_CELL, MED_PYRA13, fid, maa, nomChamp, typeChamp, nCompChamp, REFGAUSS);
00446   //          infoChamps((string) "PENTA6", MED_CELL, MED_PENTA6, fid, maa, nomChamp, typeChamp, nCompChamp, REFGAUSS);
00447   //          infoChamps((string) "PENTA15", MED_CELL, MED_PENTA15, fid, maa, nomChamp, typeChamp, nCompChamp, REFGAUSS);
00448   //          infoChamps((string) "HEXA8", MED_CELL, MED_HEXA8, fid, maa, nomChamp, typeChamp, nCompChamp, REFGAUSS);
00449   //          infoChamps((string) "HEXA20", MED_CELL, MED_HEXA20, fid, maa, nomChamp, typeChamp, nCompChamp, REFGAUSS);
00450   //
00451   //        }
00452   //
00453   //      cout << endl << "Rappel des codes de géométries: " << endl;
00454   //      cout << " TETRA4 = " << MED_TETRA4 << endl;
00455   //      cout << " PENTA6 = " << MED_PENTA6 << endl;
00456   //      cout << " HEXA8 = " << MED_HEXA8 << endl;
00457   //
00458   //    }
00459   //  else
00460   //    cout << "Pas de champs dans ce maillage" << endl;
00461 
00462   // ##################################################################################################
00463   // ##################################################################################################
00464   //
00465   //                  A C Q U I S I T I O N     D E S     F A M I L L E S
00466   //
00467   // ##################################################################################################
00468   // ##################################################################################################
00469 
00470 
00471   med_int nFamilles;
00472   char nomGroupeChar[MED_LNAME_SIZE + 1];
00473   if ((nFamilles = MEDnFamily(fid, maa)) < 0)
00474     ERREUR("ERROR MEDnFamily");
00475 
00476   // Initialisation des tailles:   tailleFAMILLES  et  tailleGROUPES
00477 
00478   //   for (int i = 0; i < nFamilles; i++)
00479   //    {
00480   //      char nomfam[MED_NAME_SIZE + 1];
00481   //      char *attdes, *gro;
00482   //      med_int numfam, *attide, *attval, natt, ngro;
00483   //
00484   //      if ((ngro = MEDnFamilyGroup(fid, maa, i + 1)) < 0)
00485   //        ERREUR("ERREUR MEDnFamilyGroup");
00486   //      if ((natt = MEDnFamily23Attribute(fid, maa, i + 1)) < 0)
00487   //        ERREUR("ERREUR MEDnFamily23Attribute");
00488   //
00489   //      attide = (med_int *) malloc(sizeof(med_int) * natt);
00490   //      attval = (med_int *) malloc(sizeof(med_int) * natt);
00491   //      attdes = (char *) malloc(MED_COMMENT_SIZE * natt + 1);
00492   //      gro = (char *) malloc(MED_LNAME_SIZE * ngro + 1);
00493   //
00494   //      if (MEDfamilyInfo(fid, maa, (med_int)(i + 1), nomfam, &numfam, attide, attval, attdes, &natt, gro, &ngro) < 0)
00495   //        ERREUR("ERREUR MEDfamilyInfo");
00496   //
00497   //      free(attide);
00498   //      free(attval);
00499   //      free(attdes);
00500   //      free(gro);
00501   //    }
00502 
00503   for (int i = 0; i < nFamilles; i++)
00504     {
00505       char nomfam[MED_NAME_SIZE + 1];
00506       char *attdes, *gro;
00507       med_int numfam, *attide, *attval, natt, ngro;
00508 
00509       if ((ngro = MEDnFamilyGroup(fid, maa, i + 1)) < 0)
00510         ERREUR("ERROR MEDnFamilyGroup");
00511       if ((natt = MEDnFamily23Attribute(fid, maa, i + 1)) < 0)
00512         ERREUR("ERROR MEDnFamily23Attribute");
00513 
00514       attide = (med_int *) malloc(sizeof(med_int) * natt);
00515       attval = (med_int *) malloc(sizeof(med_int) * natt);
00516       attdes = (char *) malloc(MED_COMMENT_SIZE * natt + 1);
00517       gro = (char *) malloc(MED_LNAME_SIZE * ngro + 1);
00518 
00519       if (MEDfamilyInfo(fid, maa, (med_int) (i + 1), nomfam, &numfam, gro) < 0)
00520         ERREUR("ERROR MEDfamilyInfo");
00521 
00522       for (int ig = 1; ig <= ngro; ig++)
00523         {
00524           for (j = 0; j < MED_LNAME_SIZE; j++)
00525             nomGroupeChar[j] = gro[(ig - 1) * MED_LNAME_SIZE + j];
00526           nomGroupeChar[MED_LNAME_SIZE] = '\0';
00527           //cout << "Groupe lu : " << (string)nomGroupeChar << endl;
00528           tailleGROUPES[strip((string) nomGroupeChar)]++;
00529           if (numfam > 0)
00530             GROUPES_NOEUDS[strip((string) nomGroupeChar)].push_back((int) numfam);
00531           else if (numfam < 0)
00532             GROUPES_MAILLES[strip((string) nomGroupeChar)].push_back((int) numfam);
00533         }
00534 
00535       free(attide);
00536       free(attval);
00537       free(attdes);
00538       free(gro);
00539     }
00540 
00541   // ##################################################################################################
00542   // ##################################################################################################
00543   //
00544   //                  A C Q U I S I T I O N     D E S     N O E U D S
00545   //
00546   // ##################################################################################################
00547   // ##################################################################################################
00548 
00549   //  class Noeud *n;
00550   //  list<Noeud*> listeNoeuds;
00551   //  float x, y, z, rx, ry, rz, tx, ty, tz;
00552   string line, IDnoeud;
00553   float x0, x1, y0, y1, z0, z1;
00554 
00555   vector<int> RESIDU_NOEUDS; // Table de vérité du résidu des noeuds
00556 
00557   ostringstream OSCOORD;
00558 
00559   med_int nnoe = 0; // Nbre de noeuds
00560   med_float *coo1; // Table des coordonnées
00561   //  char nomcoo[mdim * MED_SNAME_SIZE + 1]; // Table des noms des coordonnées
00562   //  char unicoo[mdim * MED_SNAME_SIZE + 1]; // Table des unités des coordonnées
00563   char *nomnoe;
00564 
00565   med_int *numnoe;
00566   med_int *nufano;
00567   //  med_grid_type rep;
00568   //  med_bool inonoe, inunoe;
00569   //  med_int profil[2] = { 2, 3 };
00570   med_bool coordinatechangement;
00571   med_bool geotransformation;
00572 
00573   // Combien de noeuds a lire ?
00574   nnoe = MEDmeshnEntity(fid, maa, MED_NO_DT, MED_NO_IT, MED_NODE, MED_NO_GEOTYPE, MED_COORDINATE, MED_NO_CMODE,
00575                         &coordinatechangement, &geotransformation);
00576 
00577   if (nnoe < 0)
00578     ERREUR("Error while reading number of nodes");
00579 
00580   nombreNoeudsMaillage = nnoe;
00581 
00582   // Lecture des familles des noeuds
00583   med_int *famNoeuds = (med_int*) malloc(sizeof(med_int) * nnoe);
00584   if (nnoe > 0)
00585     {
00586       if (MEDmeshEntityFamilyNumberRd(fid, maa, MED_NO_DT, MED_NO_IT, MED_NODE, MED_NONE, famNoeuds) < 0)
00587         ERREUR("Error while reading family node number (MEDmeshEntityFamilyNumberRd)");
00588     }
00589 
00590   /* Allocations memoires */
00591   if (nnoe > 0)
00592     {
00593       // table des coordonnees - profil : (dimension * nombre de noeuds )
00594       coo1 = (med_float*) calloc(nnoe * mdim, sizeof(med_float));
00595       // table des des numeros, des numeros de familles des noeuds - profil : (nombre de noeuds)
00596       numnoe = (med_int*) malloc(sizeof(med_int) * nnoe);
00597       nufano = (med_int*) malloc(sizeof(med_int) * nnoe);
00598       // table des noms des noeuds - profil : (nnoe*MED_SNAME_SIZE+1)
00599       nomnoe = (char*) malloc(MED_SNAME_SIZE * nnoe + 1);
00600     }
00601 
00602   // Lecture des composantes des coordonnees des noeuds
00603   if (nnoe > 0)
00604     if (MEDmeshNodeCoordinateRd(fid, maa, MED_NO_DT, MED_NO_IT, MED_FULL_INTERLACE, coo1) < 0)
00605       ERREUR("Error while reading nodes coordinates");
00606 
00607   //   // Les noeuds ont-ils un nom? un numéro?
00608   //  if (nnoe > 0)
00609   //    {
00610   //      if (MEDnomLire(fid, maa, nomnoe, nnoe, MED_NODE, (med_geometry_type) 0) < 0)
00611   //        inonoe = MED_FALSE;
00612   //      else
00613   //        inonoe = MED_TRUE;
00614   //      if (MEDnumLire(fid, maa, numnoe, nnoe, MED_NODE, (med_geometry_type) 0) < 0)
00615   //        inunoe = MED_FALSE;
00616   //      else
00617   //        inunoe = MED_TRUE;
00618   //    }
00619   //
00620   //  if (inonoe)
00621   //    cout << "WARNING input MED : les noms des noeuds sont ignorés" << endl;
00622   //  if (inunoe)
00623   //    cout << "WARNING input MED : les numéros des noeuds sont ignorés" << endl;
00624   //
00625   //  if (inonoe)
00626   //    {
00627   //      char str[MED_SNAME_SIZE + 1];
00628   //      for (int inoeud = 0; inoeud < nnoe; inoeud++)
00629   //        {
00630   //          strncpy(str, nomnoe + inoeud * MED_SNAME_SIZE, MED_SNAME_SIZE);
00631   //          str[MED_SNAME_SIZE] = '\0';
00632   //          IDS_NOEUDS.push_back((string) str);
00633   //        }
00634   //    }
00635   //  else if (inunoe)
00636   //    {
00637   //      for (int inoeud = 0; inoeud < nnoe; inoeud++)
00638   //        {
00639   //          int numnoeud = *(numnoe + inoeud);
00640   //          IDS_NOEUDS.push_back((string) "N" + int2string(numnoeud));
00641   //        }
00642   //    }
00643   //  else
00644   //    for (int inoeud = 0; inoeud < nnoe; inoeud++)
00645   //      IDS_NOEUDS.push_back((string) "N" + int2string(inoeud + 1));
00646   //  IDS_NOEUDS.resize(nnoe);
00647 
00648   /* ====================================================================== */
00649   /*               BOUCLE SUR LES NOEUDS LUS DANS LE FICHIER MED            */
00650   /* ====================================================================== */
00651 
00652   //  X.resize(nnoe);
00653   //  Y.resize(nnoe);
00654   //  Z.resize(nnoe);
00655 
00656   // Initialisation de l'enveloppe
00657   x0 = coo1[0];
00658   x1 = coo1[0];
00659   y0 = coo1[1];
00660   y1 = coo1[1];
00661   if (mdim == 3)
00662     {
00663       z0 = coo1[2];
00664       z1 = coo1[2];
00665     }
00666   else
00667     {
00668       z0 = 0.0;
00669       z1 = 0.0;
00670     }
00671 
00672   // Allocation mémoire pour les coordonnées XX YY ZZ
00673   XX = (float*) malloc(sizeof(float) * nombreNoeudsMaillage);
00674   if (mdim > 1)
00675     YY = (float*) malloc(sizeof(float) * nombreNoeudsMaillage);
00676   if (mdim > 2)
00677     ZZ = (float*) malloc(sizeof(float) * nombreNoeudsMaillage);
00678 
00679   for (int i = 0; i < nnoe; i++)
00680     {
00681 
00682       // Chargement des coordonnées X, Y et Z
00683       // Calcul de l'enveloppe du maillage
00684 
00685       FAMILLES_NOEUDS[*(famNoeuds + i)].push_back(i + 1); // ATTENTION! Les num. de noeuds commencent à 1
00686       tailleFAMILLES[*(famNoeuds + i)]++;
00687 
00688       // IDnoeud = "N"+int2string(i+1);
00689 
00690       float * XXi = XX + i;
00691       float * YYi = YY + i;
00692       float * ZZi = ZZ + i;
00693 
00694       if (mdim == 3)
00695         {
00696           *XXi = (float) coo1[3 * i];
00697           *YYi = (float) coo1[3 * i + 1];
00698           *ZZi = (float) coo1[3 * i + 2];
00699           if (*XXi < x0)
00700             x0 = *XXi;
00701           else if (*XXi > x1)
00702             x1 = *XXi;
00703           if (*YYi < y0)
00704             y0 = *YYi;
00705           else if (*YYi > y1)
00706             y1 = *YYi;
00707           if (*ZZi < z0)
00708             z0 = *ZZi;
00709           else if (*ZZi > z1)
00710             z1 = *ZZi;
00711         }
00712       else if (mdim == 2)
00713         {
00714           *XXi = (float) coo1[2 * i];
00715           *YYi = (float) coo1[2 * i + 1];
00716           if (*XXi < x0)
00717             x0 = *XXi;
00718           else if (*XXi > x1)
00719             x1 = *XXi;
00720           if (*YYi < y0)
00721             y0 = *YYi;
00722           else if (*YYi > y1)
00723             y1 = *YYi;
00724         }
00725       else if (mdim == 1)
00726         {
00727           *XXi = (float) coo1[1 * i];
00728           if (*XXi < x0)
00729             x0 = *XXi;
00730           else if (*XXi > x1)
00731             x1 = *XXi;
00732         }
00733 
00734       // Chargement des numéros de noeuds
00735       //      if (inunoe)
00736       //        NUM_NOEUDS.push_back(*(numnoe + i));
00737       //      else
00738       //        NUM_NOEUDS.push_back(i + 1);
00739 
00740     } // boucle sur les noeuds
00741 
00742   //  NUM_NOEUDS.resize(nnoe);
00743 
00744   // Enveloppe du maillage
00745   enveloppeMaillage = new Cube(x0, x1, y0, y1, z0, z1);
00746 
00747   // Libération mémoire
00748   if (nnoe > 0)
00749     {
00750       free(coo1);
00751       free(nomnoe);
00752       free(numnoe);
00753       free(nufano);
00754     }
00755 
00756   // ##################################################################################################
00757   // ##################################################################################################
00758   //
00759   //                  A C Q U I S I T I O N     D E S     M A I L L E S
00760   //
00761   // ##################################################################################################
00762   // ##################################################################################################
00763 
00764   for (int itm = (int) POI1; itm <= (int) HEXA20; itm++)
00765     {
00766       TYPE_MAILLE tm = (TYPE_MAILLE) itm;
00767       EFFECTIFS_TYPES[tm] = MEDmeshnEntity(fid, maa, MED_NO_DT, MED_NO_IT, MED_CELL, InstanceMGE(tm), MED_CONNECTIVITY,
00768                                            MED_NODAL, &coordinatechangement, &geotransformation);
00769       if (EFFECTIFS_TYPES[tm])
00770         acquisitionTYPE_inputMED(tm, EFFECTIFS_TYPES[tm], fid, maa, mdim);
00771     }
00772 
00773   // Resize des vecteurs des maps FAMILLES et FAM_TYPES
00774   map<int, vector<int> >::iterator IF;
00775   for (IF = FAMILLES.begin(); IF != FAMILLES.end(); IF++)
00776     {
00777       IF->second.resize(tailleFAMILLES[IF->first]);
00778       FAM_TYPES[IF->first].resize(tailleFAMILLES[IF->first]);
00779     }
00780 
00781   for (int itm = (int) POI1; itm <= (int) HEXA20; itm++)
00782     nombreMaillesMaillage += EFFECTIFS_TYPES[(TYPE_MAILLE) itm];
00783 
00784   // ##################################################################################################
00785   // ##################################################################################################
00786   //
00787   //          A C Q U I S I T I O N     D E S     G R O U P E S
00788   //          D E    M A I L L E S    E T    D E    N O E U D S
00789   //
00790   // ##################################################################################################
00791   // ##################################################################################################
00792 
00793   // =============================================================================================
00794   //                 Chargement des groupes dans GM et GN
00795   // =============================================================================================
00796 
00797   string nomGM;
00798   vector<int> vfam;
00799   map<string, vector<int> >::iterator iterGRO;
00800 
00801   int cptGM = 0;
00802   for (iterGRO = GROUPES_MAILLES.begin(); iterGRO != GROUPES_MAILLES.end(); iterGRO++)
00803     {
00804       nomGM = iterGRO->first;
00805       vfam = iterGRO->second;
00806       cptGM++;
00807       map<TYPE_MAILLE, int> effectifGroupeType;
00808       for (unsigned int i = 0; i < vfam.size(); i++)
00809         {
00810           int numf = vfam[i];
00811           // Parcours simultané des vecteurs FAMILLES[numf] et FAM_TYPES[numfam] pour obtention du num local
00812           // et du type des mailles de la famille numf
00813           for (unsigned int imaille = 0; imaille < FAMILLES[numf].size(); imaille++)
00814             {
00815               TYPE_MAILLE tm = FAM_TYPES[numf][imaille];
00816               int nl = FAMILLES[numf][imaille];
00817               GM[nomGM][tm].push_back(nl);
00818               effectifGroupeType[tm]++;
00819             }
00820         }
00821 
00822       // Resize d'un GM
00823       for (map<TYPE_MAILLE, vector<int> >::iterator I = GM[nomGM].begin(); I != GM[nomGM].end(); I++)
00824         {
00825           TYPE_MAILLE tm = I->first;
00826           GM[nomGM][tm].resize(effectifGroupeType[tm]);
00827           sort(GM[nomGM][tm].begin(), GM[nomGM][tm].end());
00828         }
00829     }
00830 
00831   int cptGN = 0;
00832   for (iterGRO = GROUPES_NOEUDS.begin(); iterGRO != GROUPES_NOEUDS.end(); iterGRO++)
00833     {
00834       nomGM = iterGRO->first;
00835       vfam = iterGRO->second;
00836       cptGN++;
00837       int cptNoeudsGN = 0;
00838       for (unsigned int i = 0; i < vfam.size(); i++)
00839         {
00840           int numf = vfam[i];
00841           // Parcours vecteurs FAMILLES_NOEUDS[numf]
00842           for (unsigned int inoeud = 0; inoeud < FAMILLES_NOEUDS[numf].size(); inoeud++)
00843             {
00844               GN[nomGM].push_back(FAMILLES_NOEUDS[numf][inoeud]);
00845               cptNoeudsGN++;
00846             }
00847         }
00848       GN[nomGM].resize(cptNoeudsGN);
00849       sort(GN[nomGM].begin(), GN[nomGM].end());
00850     }
00851 
00852   MEDfileClose(fid);
00853   //  cout << "Fin procédure inputMED" << endl << endl;
00854 }
00855 
00856 void Maillage::acquisitionTYPE_inputMED(TYPE_MAILLE TYPE, int nTYPE, med_idt fid, char maa[MED_NAME_SIZE + 1],
00857                                         med_int mdim)
00858 {
00859 
00860   //  int taille, numeromaille, numeroFamille;
00861   int numeroFamille;
00862   string line, IDmaille, IDnoeud, typeMaille;
00863   //  char str[MED_SNAME_SIZE + 1]; // Conteneur pour un nom de maille
00864   //  bool rejetMaille;
00865   med_int tTYPE = (med_int) Nnoeuds(TYPE);
00866   char *nomTYPE = (char*) malloc(MED_SNAME_SIZE * nTYPE + 1);
00867   med_int *numTYPE = (med_int*) malloc(sizeof(med_int) * nTYPE);
00868   med_int *famTYPE = (med_int*) malloc(sizeof(med_int) * nTYPE);
00869 
00870   //med_int *conTYPE = (med_int*) malloc(sizeof(med_int)*tTYPE*nTYPE);
00871   CNX[TYPE] = (int*) malloc(sizeof(int) * tTYPE * nTYPE);
00872 
00873   med_bool inomTYPE, inumTYPE, ifamTYPE;
00874   med_geometry_type typeBanaliseMED = InstanceMGE(TYPE);
00875 
00876   if (MEDmeshElementRd(fid, maa, MED_NO_DT, MED_NO_IT, MED_CELL, typeBanaliseMED, MED_NODAL, MED_FULL_INTERLACE,
00877                        CNX[TYPE], &inomTYPE, nomTYPE, &inumTYPE, numTYPE, &ifamTYPE, famTYPE) < 0)
00878     ERREUR("Error while reading elements");
00879 
00880   // Conversion HL
00881   conversionCNX(CNX[TYPE], TYPE, nTYPE);
00882 
00883   //  CON[TYPE].resize(tTYPE * nTYPE);
00884   //  for (int i = 0; i < tTYPE * nTYPE; i++)
00885   //    CON[TYPE][i] = (int) *(conTYPE + i);
00886   //  CNX[TYPE] = (int*) malloc(sizeof(int) * tTYPE * nTYPE);
00887   //  for (int i = 0; i < tTYPE * nTYPE; i++)
00888   //    *(CNX[TYPE] + i) = (int) *(conTYPE + i);
00889 
00890   for (int i = 0; i < nTYPE; i++)
00891     {
00892       numeroFamille = (int) *(famTYPE + i);
00893       FAMILLES[numeroFamille].push_back(i);
00894       tailleFAMILLES[numeroFamille]++;
00895       FAM_TYPES[numeroFamille].push_back(TYPE);
00896 
00897       // Chargement des numéros de mailles
00898       //      if (inumTYPE)
00899       //        NUM_MAILLES[TYPE].push_back(*(numTYPE + i));
00900       //      else
00901       //        NUM_MAILLES[TYPE].push_back(NGLOBAL(TYPE, i));
00902 
00903     }
00904   //  NUM_MAILLES[TYPE].resize(nTYPE);
00905 
00906   //   if (inomTYPE)
00907   //    {
00908   //      char str[MED_SNAME_SIZE + 1];
00909   //      for (int imaille = 0; imaille < nTYPE; imaille++)
00910   //        {
00911   //          strncpy(str, nomTYPE + imaille * MED_SNAME_SIZE, MED_SNAME_SIZE);
00912   //          str[MED_SNAME_SIZE] = '\0';
00913   //          IDS_MAILLES[TYPE].push_back((string) str);
00914   //        }
00915   //    }
00916   //  else if (inumTYPE)
00917   //    {
00918   //      for (int imaille = 0; imaille < nTYPE; imaille++)
00919   //        {
00920   //          int nummaille = *(numTYPE + imaille);
00921   //          IDS_MAILLES[TYPE].push_back((string) "M" + int2string(nummaille));
00922   //        }
00923   //    }
00924   //  else
00925   //    {
00926   //      for (int imaille = 0; imaille < nTYPE; imaille++)
00927   //        {
00928   //          IDS_MAILLES[TYPE].push_back((string) "M" + int2string(imaille + 1));
00929   //        }
00930   //    }
00931   //  IDS_MAILLES[TYPE].resize(nTYPE);
00932 }
00933 
00934 void Maillage::outputMED(std::string fichierMED)
00935 {
00936   // int i, j, k;
00937   int nTYPE, tTYPE;
00938   string line, s, stype, nomnoeud;
00939   //  med_err ret = 0; // Code retour
00940   //  int ig, jg;
00941   //  cout << endl << endl << "Début procédure outputMED, fichier " << fichierMED << endl;
00942 
00943   // Sortie sur erreur en cas de maillage sans noeuds
00944   if (nombreNoeudsMaillage <= 0)
00945     {
00946       ERREUR("This mesh does not contain any node\n"); /* cout << "Maillage sans noeuds" << endl; */
00947     }
00948 
00949   // ########################################################################
00950   //    Ouverture du fichier MED et création du maillage
00951   // ########################################################################
00952 
00953   // Ouverture du fichier MED en création
00954   med_idt fid = MEDfileOpen(string2char(fichierMED), MED_ACC_CREAT);
00955   if (fid < 0)
00956     {
00957       ERREUR("Error MEDfileOpen\n");
00958       cout << "Error MEDfileOpen" << endl;
00959     }
00960 
00961   // Création du maillage
00962   char maa[MED_NAME_SIZE + 1]; // Nom du maillage de longueur maxi MED_NAME_SIZE
00963   strcpy(maa, string2char(ID));
00964 
00965   med_int mdim; // Dimension du maillage
00966   if (dimensionMaillage == 0)
00967     {
00968       mdim = 3;
00969       cout << "ATTENTION, dimension 3 attribuée par défaut!" << endl;
00970     }
00971   else
00972     mdim = dimensionMaillage;
00973   med_int spacedim = 3;
00974   if (dimensionEspace)
00975     spacedim = dimensionEspace;
00976 
00977   //med_int profil[2] = { 2, 3 };
00978   char desc[MED_COMMENT_SIZE + 1]; // Description du maillage
00979   strcpy(desc, string2char(ID));
00980   med_mesh_type type = MED_UNSTRUCTURED_MESH;
00981 //  cerr << "maa=" << maa << endl;
00982 //  cerr << "spacedim=" << spacedim << endl;
00983 //  cerr << "mdim=" << mdim << endl;
00984 //  cerr << "type=" << type << endl;
00985 //  cerr << "axisname=" << axisname << endl;
00986 //  cerr << "unitname=" << unitname << endl;
00987   if (MEDmeshCr(fid, maa, spacedim, mdim, type, desc, "s", MED_SORT_DTIT, MED_CARTESIAN, axisname, unitname) < 0)
00988     {
00989       ERREUR("Error MEDmeshCr");
00990       cout << "Error MEDmeshCr" << endl;
00991     }
00992 
00993   // =============================  CREATION FAMILLE ZERO
00994   char nomfam[MED_NAME_SIZE + 1];
00995   med_int numfam;
00996   //  char attdes[MED_COMMENT_SIZE + 1];
00997   //  med_int natt, attide, attval;
00998   int ngro;
00999   //  char gro[MED_LNAME_SIZE + 1];
01000 
01001   strcpy(nomfam, "FAMILLE_0");
01002   numfam = 0;
01003   if (MEDfamilyCr(fid, maa, nomfam, numfam, 0, MED_NO_GROUP) < 0)
01004     ERREUR("Error MEDfamilyCr (create family 0)");
01005 
01006   // ########################################################################
01007   //          GROUPES DE NOEUDS
01008   // ########################################################################
01009 
01010   int nGroupesNoeuds = GN.size();
01011 
01012   vector<vector<int> > ETIQUETTES_N;
01013   ETIQUETTES_N.resize(nombreNoeudsMaillage);
01014   vector<unsigned int> INDEX_N;
01015   INDEX_N.resize(GN.size());
01016   vector<string> NOMSFAM;
01017   vector<vector<int> > ETIQFAM;
01018   int cptNOMFAM = 0;
01019   map<string, int> NUMFAMETIQ; //  clé = étiquette  -  valeur = numéros de familles
01020 
01021 
01022   if (nGroupesNoeuds)
01023     {
01024 
01025       // Pérennisation d'un ordre sur les GM dans le vecteur NOMS_GROUPES_MAILLES
01026       vector<string> NOMS_GROUPES_NOEUDS;
01027       for (map<string, vector<int> >::iterator ITGN = GN.begin(); ITGN != GN.end(); ITGN++)
01028         {
01029           string nomGN = ITGN->first;
01030           NOMS_GROUPES_NOEUDS.push_back(nomGN);
01031         }
01032       NOMS_GROUPES_NOEUDS.resize(GN.size());
01033 
01034       // Tri des vecteurs de noeuds de GN
01035       for (unsigned int ig = 0; ig < NOMS_GROUPES_NOEUDS.size(); ig++)
01036         sort(GN[NOMS_GROUPES_NOEUDS[ig]].begin(), GN[NOMS_GROUPES_NOEUDS[ig]].end());
01037 
01038       // Construction des étiquettes (familles)
01039 
01040       // Initialisation des index de groupes
01041       for (unsigned int ig = 0; ig < NOMS_GROUPES_NOEUDS.size(); ig++)
01042         INDEX_N[ig] = 0;
01043 
01044       for (int k = 1; k <= nombreNoeudsMaillage; k++)
01045         { // k: num. global de noeud
01046           int tailleEtiquette = 0;
01047           string etiq = (string) "";
01048           // Boucle sur les groupes
01049           for (unsigned int ig = 0; ig < NOMS_GROUPES_NOEUDS.size(); ig++)
01050             {
01051               if (INDEX_N[ig] < GN[NOMS_GROUPES_NOEUDS[ig]].size())
01052                 {
01053                   string nomgroupe = NOMS_GROUPES_NOEUDS[ig];
01054                   if (k == GN[nomgroupe][INDEX_N[ig]])
01055                     {
01056                       // Attention: l'indice 0 dans le vecteur ETIQUETTES correspond
01057                       // à l'élément (noeud ou maille) de num. global 1
01058                       // Par ailleurs, le numéro de groupe dans l'étiquette commence à 0
01059                       ETIQUETTES_N[k - 1].push_back(ig);
01060                       tailleEtiquette++;
01061                       etiq += int2string(ig);
01062                       INDEX_N[ig]++;
01063                     }
01064                 }
01065             }
01066           ETIQUETTES_N[k - 1].resize(tailleEtiquette);
01067           // Stockage de l'étiquette dans NOMSFAM ETIQFAM, si pas déjà stockée
01068           //          bool trouve = false;
01069           //          for (int i = 0; i < NOMSFAM.size(); i++)
01070           //            if (NOMSFAM[i] == ((string) "ETIQUETTE_" + etiq))
01071           //              {
01072           //                trouve = true;
01073           //                break;
01074           //              }
01075           if (!NUMFAMETIQ[etiq] && etiq != (string) "")
01076             {
01077               NOMSFAM.push_back((string) "ETIQN_" + etiq);
01078               ETIQFAM.push_back(ETIQUETTES_N[k - 1]);
01079               NUMFAMETIQ[etiq] = cptNOMFAM + 1; // Famille de noeuds, num>0
01080               cptNOMFAM++;
01081             }
01082         }
01083 
01084       NOMSFAM.resize(cptNOMFAM);
01085       ETIQFAM.resize(cptNOMFAM);
01086 
01087       // Création des familles de noeuds
01088       for (unsigned int ifam = 0; ifam < NOMSFAM.size(); ifam++)
01089         {
01090           strcpy(nomfam, string2char(NOMSFAM[ifam]));
01091           // Numéro de famille: ifam+1 (positif pour les noeuds + non nul)
01092           numfam = ifam + 1;
01093           ngro = ETIQFAM[ifam].size();
01094 
01095           // Noms des groupes de la famille: variable nomsGN
01096           char *gro = new char[ngro * MED_LNAME_SIZE + 1];
01097           int cptGN = 0;
01098           for (unsigned int ign = 0; ign < ETIQFAM[ifam].size(); ign++)
01099             {
01100               string nomGNcourant = NOMS_GROUPES_NOEUDS[ETIQFAM[ifam][ign]];
01101               // ATTENTION! Il faut mettre à la fin de chaque segment un \0 qui est ensuite écrasé
01102               // par le premier caractère du champ suivant dans le strcat !!!!
01103               if (ign == 0)
01104                 {
01105                   // Premier groupe
01106                   strcpy(gro, string2char(nomGNcourant));
01107                   for (int jg = nomGNcourant.size(); jg < MED_LNAME_SIZE; jg++)
01108                     gro[jg] = ' ';
01109                   gro[MED_LNAME_SIZE] = '\0';
01110                 }
01111               else
01112                 {
01113                   strcat(gro, string2char(nomGNcourant));
01114                   for (int jg = nomGNcourant.size(); jg < MED_LNAME_SIZE; jg++)
01115                     gro[cptGN * MED_LNAME_SIZE + jg] = ' ';
01116                   gro[(cptGN + 1) * MED_LNAME_SIZE] = '\0';
01117                 }
01118               cptGN++;
01119             }
01120 
01121           // Création de la famille
01122           if (MEDfamilyCr(fid, maa, nomfam, numfam, 0, MED_NO_GROUP) < 0)
01123             ERREUR("Error MEDfamilyCr");
01124          delete gro;
01125        }
01126 
01127     }
01128 
01129   // ########################################################################
01130   //          NOEUDS
01131   // ########################################################################
01132 
01133   //  float x, y, z;
01134 
01135   med_int nnoe = nombreNoeudsMaillage; // Nombre de noeuds
01136   med_float *coo; // Table des coordonnées
01137 
01138   // Noms des coordonnées (variable nomcoo)
01139   char* nomcoo = new char[mdim * MED_SNAME_SIZE + 1];
01140   string strX = (string) "X";
01141   while (strX.size() < MED_SNAME_SIZE)
01142     strX += (string) " ";
01143   string strY = (string) "Y";
01144   while (strY.size() < MED_SNAME_SIZE)
01145     strY += (string) " ";
01146   string strZ = (string) "Z";
01147   while (strZ.size() < MED_SNAME_SIZE)
01148     strZ += (string) " ";
01149   if (mdim == 3)
01150     strcpy(nomcoo, string2char(strX + strY + strZ));
01151   else if (mdim == 2)
01152     strcpy(nomcoo, string2char(strX + strY));
01153   else
01154     strcpy(nomcoo, string2char(strX));
01155   nomcoo[mdim * MED_SNAME_SIZE] = '\0';
01156 
01157   // Unités des coordonnées (variable unicoo)
01158   char* unicoo = new char[mdim * MED_SNAME_SIZE + 1];
01159   string strmesure = (string) "SI";
01160   while (strmesure.size() < MED_SNAME_SIZE)
01161     strmesure += (string) " ";
01162   if (mdim == 3)
01163     strcpy(unicoo, string2char(strmesure + strmesure + strmesure));
01164   else if (mdim == 2)
01165     strcpy(unicoo, string2char(strmesure + strmesure));
01166   else
01167     strcpy(unicoo, string2char(strmesure));
01168   unicoo[mdim * MED_SNAME_SIZE] = '\0';
01169 
01170   // Tables des noms, numeros, numeros de familles des noeuds
01171   //    autant d'elements que de noeuds - les noms ont pout longueur MED_SNAME_SIZE
01172   char *nomnoe;
01173   med_int *numnoe = NULL;
01174   med_int *nufano;
01175   med_bool inonoe = MED_FALSE;
01176   med_bool inunoe = MED_FALSE;
01177 
01178   // Allocations memoire
01179   if (nnoe > 0)
01180     {
01181       // table des coordonnees - profil : (dimension * nombre de noeuds )
01182       coo = (med_float*) calloc(nnoe * mdim, sizeof(med_float));
01183 
01184       // table des des numeros, des numeros de familles des noeuds - profil : (nombre de noeuds)
01185       //      numnoe = (med_int*) malloc(sizeof(med_int) * nnoe);
01186       nufano = (med_int*) malloc(sizeof(med_int) * nnoe);
01187 
01188       // table des noms des noeuds - profil : (nnoe*MED_SNAME_SIZE+1)
01189       nomnoe = (char*) ""; // ATTENTION!
01190 
01191       //      nomnoe = (char*) malloc(MED_SNAME_SIZE * nnoe + 1);
01192       //      for (int inoeud = 0; inoeud < IDS_NOEUDS.size(); inoeud++)
01193       //        {
01194       //          string nomNoeud = IDS_NOEUDS[inoeud];
01195       //          if (inoeud == 0)
01196       //            {
01197       //              // Premier groupe
01198       //              strcpy(nomnoe, string2char(nomNoeud));
01199       //              for (int jg = nomNoeud.size(); jg < MED_SNAME_SIZE; jg++)
01200       //                nomnoe[jg] = ' ';
01201       //              nomnoe[MED_SNAME_SIZE] = '\0';
01202       //            }
01203       //          else
01204       //            {
01205       //              strcat(nomnoe, string2char(nomNoeud));
01206       //              for (int jg = nomNoeud.size(); jg < MED_SNAME_SIZE; jg++)
01207       //                nomnoe[inoeud * MED_SNAME_SIZE + jg] = ' ';
01208       //              nomnoe[(inoeud + 1) * MED_SNAME_SIZE] = '\0';
01209       //            }
01210       //        }
01211     }
01212 
01213   // Chargement des coordonnées, numéros de familles et numéros de noeuds
01214   if (dimensionMaillage == 3)
01215     {
01216       int i3 = 0;
01217       for (int i = 0; i < nnoe; i++)
01218         {
01219           //          coo[i3] = X[i];
01220           //          coo[i3 + 1] = Y[i];
01221           //          coo[i3 + 2] = Z[i];
01222           //          i3 = i3 + 3;
01223           coo[i3] = *(XX + i);
01224           coo[i3 + 1] = *(YY + i);
01225           coo[i3 + 2] = *(ZZ + i);
01226           i3 = i3 + 3;
01227 
01228           // Numéros de familles  -  Le num. global de noeud est i+1
01229           if (nGroupesNoeuds)
01230             {
01231               vector<int> v = ETIQUETTES_N[i];
01232               string sv = (string) "";
01233               for (unsigned int j = 0; j < v.size(); j++)
01234                 sv += int2string(v[j]); // Etiquette du noeud au format string
01235               // cout << "Noeud " << i + 1 << " : sv=" << sv << endl;
01236               *(nufano + i) = (med_int) NUMFAMETIQ[sv];
01237             }
01238           else
01239             *(nufano + i) = (med_int) 0;
01240 
01241           // Numéros de noeuds
01242           // *(numnoe + i) = (med_int) NUM_NOEUDS[i];
01243         }
01244     }
01245   else /* dimension 2 */
01246     {
01247       int i2 = 0;
01248       for (int i = 0; i < nnoe; i++)
01249         {
01250           coo[i2] = *(XX + i);
01251           coo[i2 + 1] = *(YY + i);
01252           i2 = i2 + 2;
01253           // Numéros de familles  -  Le num. global de noeud est i+1
01254           if (nGroupesNoeuds)
01255             {
01256               vector<int> v = ETIQUETTES_N[i];
01257               string sv = (string) "";
01258               for (unsigned int j = 0; j < v.size(); j++)
01259                 sv += int2string(v[j]); // Etiquette du noeud au format string
01260               // cout << "Noeud " << i + 1 << " : sv=" << sv << endl;
01261               *(nufano + i) = (med_int) NUMFAMETIQ[sv];
01262             }
01263           else
01264             *(nufano + i) = (med_int) 0;
01265           // Numéros de noeuds
01266           // *(numnoe + i) = (med_int) NUM_NOEUDS[i];
01267         }
01268     }
01269 
01270   //   // Restitution coo
01271   //  int i3 = 0;
01272   //  for (int i = 0; i < nnoe; i++)
01273   //    {
01274   //      cout << "Noeud " << i << " : " << coo[i3] << " " << coo[i3 + 1] << " " << coo[i3 + 2] << endl;
01275   //      i3 = i3 + 3;
01276   //    }
01277 
01278   if (MEDmeshNodeWr(fid, maa, MED_NO_DT, MED_NO_IT, MED_UNDEF_DT, MED_FULL_INTERLACE, nnoe, coo, inonoe, nomnoe,
01279                     inunoe, numnoe, MED_TRUE, nufano) < 0)
01280     {
01281       ERREUR("Error MEDmeshNodeWr");
01282       cout << "Error MEDmeshNodeWr" << endl;
01283     }
01284 
01285   // ########################################################################
01286   //          GROUPES DE MAILLES
01287   // ########################################################################
01288 
01289   int nGroupesMailles = GM.size();
01290 
01291   map<TYPE_MAILLE, vector<vector<int> > > ETIQUETTES_M; // [ tm => [ nl => [ig1, ig2, ... ] ] ]
01292   // INDEX_M :
01293   //  Clé :       tm
01294   //  Valeur :    vect. des compteurs par indice de GM dans NOMS_GROUPES_MAILLES
01295   map<TYPE_MAILLE, vector<unsigned int> > INDEX_M;
01296   NOMSFAM.clear();
01297   ETIQFAM.clear();
01298   NUMFAMETIQ.clear(); //  clé = étiquette  -  valeur = numéros de familles
01299   cptNOMFAM = 0;
01300 
01301   if (nGroupesMailles)
01302     {
01303 
01304       // Pérennisation d'un ordre sur les GM dans le vecteur NOMS_GROUPES_MAILLES
01305       vector<string> NOMS_GROUPES_MAILLES;
01306       for (map<string, map<TYPE_MAILLE, vector<int> > >::iterator ITGM = GM.begin(); ITGM != GM.end(); ITGM++)
01307         {
01308           string nomGM = ITGM->first;
01309           NOMS_GROUPES_MAILLES.push_back(nomGM);
01310         }
01311       NOMS_GROUPES_MAILLES.resize(GM.size());
01312       // Tri des vecteurs d'entiers de GM
01313       for (unsigned int ig = 0; ig < NOMS_GROUPES_MAILLES.size(); ig++)
01314         {
01315           string nomGM = NOMS_GROUPES_MAILLES[ig];
01316           for (map<TYPE_MAILLE, vector<int> >::iterator I = GM[nomGM].begin(); I != GM[nomGM].end(); I++)
01317             {
01318               TYPE_MAILLE tm = I->first;
01319               sort(GM[nomGM][tm].begin(), GM[nomGM][tm].end());
01320             }
01321         }
01322 
01323       // Construction des étiquettes (familles)
01324 
01325       // Initialisation 0 des index de groupes, et resize ETIQUETTES_M[tm]
01326       for (int itm = (int) POI1; itm <= (int) HEXA20; itm++)
01327         {
01328           TYPE_MAILLE tm = (TYPE_MAILLE) itm;
01329           if (EFFECTIFS_TYPES[tm])
01330             {
01331               for (unsigned int ig = 0; ig < NOMS_GROUPES_MAILLES.size(); ig++)
01332                 INDEX_M[tm].push_back(0);
01333               ETIQUETTES_M[tm].resize(EFFECTIFS_TYPES[tm]);
01334             }
01335         }
01336 
01337       for (int itm = (int) POI1; itm <= (int) HEXA20; itm++)
01338         {
01339           TYPE_MAILLE tm = (TYPE_MAILLE) itm;
01340           int efftm = EFFECTIFS_TYPES[tm];
01341           // cout << endl << "*************** coucou ***************" << endl;
01342           // cout << "*************** Type " << TM2string(tm) << " effectif = " << efftm << endl;
01343           if (efftm)
01344             {
01345               // cout << "Traitement du type " << TM2string(tm) << endl;
01346               for (int nl = 0; nl < efftm; nl++)
01347                 {
01348                   // nl = num. local de la maille dans son type
01349                   // cout << "\tMaille " << TM2string(tm) << " n° " << nl << endl;
01350 
01351                   int tailleEtiquette = 0;
01352                   string etiq = (string) "";
01353                   // Boucle sur les groupes
01354                   for (unsigned int ig = 0; ig < NOMS_GROUPES_MAILLES.size(); ig++)
01355                     {
01356                       string nomGM = NOMS_GROUPES_MAILLES[ig];
01357                       // cout << "\t\t" << "Groupe " << nomGM << endl;
01358 
01359                       if (INDEX_M[tm][ig] < GM[nomGM][tm].size())
01360                         {
01361                           if (nl == GM[nomGM][tm][INDEX_M[tm][ig]])
01362                             {
01363                               // Attention: l'indice 0 dans le vecteur ETIQUETTES correspond
01364                               // à l'élément (noeud ou maille) de num. global 1
01365                               // Par ailleurs, le numéro de groupe dans l'étiquette commence à 0
01366                               // cout << "\t\t\t" << "La maille est dans le groupe " << nomGM << endl;
01367                               ETIQUETTES_M[tm][nl].push_back(ig);
01368                               tailleEtiquette++;
01369                               etiq += int2string(ig);
01370                               INDEX_M[tm][ig]++;
01371                               // cout << "\t\t\t  OK" << endl;
01372                             }
01373                         }
01374                     }
01375 
01376                   ETIQUETTES_M[tm][nl].resize(tailleEtiquette);
01377                   // Stockage de l'étiquette dans NOMSFAM ETIQFAM, si pas déjà stockée
01378                   //                  bool trouve = false;
01379                   //                  for (int i = 0; i < NOMSFAM.size(); i++)
01380                   //                    if (NOMSFAM[i] == ((string) "ETIQUETTE_" + etiq))
01381                   //                      {
01382                   //                        trouve = true;
01383                   //                        break;
01384                   //                      }
01385 
01386                   if (!NUMFAMETIQ[etiq] && etiq != (string) "")
01387                     {
01388                       NOMSFAM.push_back((string) "ETIQM_" + etiq);
01389                       ETIQFAM.push_back(ETIQUETTES_M[tm][nl]);
01390                       NUMFAMETIQ[etiq] = -cptNOMFAM - 1; // Famille de mailles, num<0
01391                       cptNOMFAM++;
01392                     }
01393 
01394                 }
01395 
01396             } // if (efftm)
01397         }
01398 
01399       NOMSFAM.resize(cptNOMFAM);
01400       ETIQFAM.resize(cptNOMFAM);
01401 
01402       // Création des familles de mailles
01403       for (unsigned int ifam = 0; ifam < NOMSFAM.size(); ifam++)
01404         {
01405           strcpy(nomfam, string2char(NOMSFAM[ifam]));
01406           // Numéro de famille: -ifam-1 (négatif pour les mailles, et non nul)
01407           numfam = -ifam - 1;
01408           ngro = ETIQFAM[ifam].size();
01409 
01410           // Noms des groupes de la famille
01411           char* gro = new char[ngro * MED_LNAME_SIZE + 1];
01412           int cptGM = 0;
01413           for (unsigned int ign = 0; ign < ETIQFAM[ifam].size(); ign++)
01414             {
01415               string nomGMcourant = NOMS_GROUPES_MAILLES[ETIQFAM[ifam][ign]];
01416               // ATTENTION! Il faut mettre à la fin de chaque segment un \0 qui est ensuite écrasé
01417               // par le premier caractère du champ suivant dans le strcat !!!!
01418               if (ign == 0)
01419                 {
01420                   // Premier groupe
01421                   strcpy(gro, string2char(nomGMcourant));
01422                   for (int jg = nomGMcourant.size(); jg < MED_LNAME_SIZE; jg++)
01423                     gro[jg] = ' ';
01424                   gro[MED_LNAME_SIZE] = '\0';
01425                 }
01426               else
01427                 {
01428                   strcat(gro, string2char(nomGMcourant));
01429                   for (int jg = nomGMcourant.size(); jg < MED_LNAME_SIZE; jg++)
01430                     gro[cptGM * MED_LNAME_SIZE + jg] = ' ';
01431                   gro[(cptGM + 1) * MED_LNAME_SIZE] = '\0';
01432                 }
01433               cptGM++;
01434             }
01435 
01436           // Création de la famille
01437           if (MEDfamilyCr(fid, maa, nomfam, numfam, 1, gro) < 0)
01438             ERREUR("Error MEDfamilyCr");
01439 
01440          delete gro;
01441         }
01442     }
01443 
01444   // ########################################################################
01445   //                                MAILLES
01446   // ########################################################################
01447   //               Appel de la routine ecritureTypeNew
01448 
01449   med_bool inomTYPE = MED_FALSE;
01450   med_bool inumTYPE = MED_FALSE;
01451 
01452   med_geometry_type MGE;
01453 
01454   for (int itm = (int) POI1; itm <= (int) HEXA20; itm++)
01455     {
01456       TYPE_MAILLE tm = (TYPE_MAILLE) itm;
01457       if (EFFECTIFS_TYPES[tm])
01458         {
01459           nTYPE = EFFECTIFS_TYPES[tm];
01460           tTYPE = Nnoeuds(tm);
01461           MGE = InstanceMGE(tm);
01462           stype = TM2string(tm);
01463 
01464           // Noms des mailles
01465           //          char *nomTYPE = (char*) malloc(MED_SNAME_SIZE * nTYPE + 1);
01466           //          strcpy(nomTYPE, ""); // ATTENTION!
01467 
01468           char *nomTYPE = (char*)""; // Attention! Ne pas faire strcpy !
01469 
01470           //           for (int imaille = 0; imaille < IDS_MAILLES[tm].size(); imaille++)
01471           //            {
01472           //              string nomMaille = IDS_MAILLES[tm][imaille];
01473           //              if (imaille == 0)
01474           //                {
01475           //                  // Premier groupe
01476           //                  strcpy(nomTYPE, string2char(nomMaille));
01477           //                  for (int jg = nomMaille.size(); jg < MED_SNAME_SIZE; jg++)
01478           //                    nomTYPE[jg] = ' ';
01479           //                  nomTYPE[MED_SNAME_SIZE] = '\0';
01480           //                }
01481           //              else
01482           //                {
01483           //                  strcat(nomTYPE, string2char(nomMaille));
01484           //                  for (int jg = nomMaille.size(); jg < MED_SNAME_SIZE; jg++)
01485           //                    nomTYPE[imaille * MED_SNAME_SIZE + jg] = ' ';
01486           //                  nomTYPE[(imaille + 1) * MED_SNAME_SIZE] = '\0';
01487           //                }
01488           //            }
01489 
01490           med_int *numTYPE = NULL; //  (med_int*) malloc(sizeof(med_int)*nTYPE);
01491 
01492           med_int *famTYPE = (med_int*) malloc(sizeof(med_int) * nTYPE);
01493 
01494           //          med_int *conTYPE = (med_int*) malloc(sizeof(med_int) * tTYPE * nTYPE);
01495           //          for (int i = 0; i < nTYPE * tTYPE; i++)
01496           //            *(conTYPE + i) = (med_int) CON[tm][i];
01497 
01498           // Chargement famTYPE
01499           if (nGroupesMailles)
01500             {
01501               // Boucle sur les mailles du type (indice = num. local)
01502               for (int nl = 0; nl < nTYPE; nl++)
01503                 {
01504                   // Construction de l'étiquette de la maille au format string
01505                   vector<int> v = ETIQUETTES_M[tm][nl];
01506                   string sv = (string) "";
01507                   for (unsigned int j = 0; j < v.size(); j++)
01508                     sv += int2string(v[j]);
01509                   // Accès au num. de la famille
01510                   *(famTYPE + nl) = (med_int) NUMFAMETIQ[sv];
01511                 } // Boucle sur les mailles du type
01512             } // if (nGroupesMailles)
01513           else
01514             for (int nl = 0; nl < nTYPE; nl++)
01515               *(famTYPE + nl) = (med_int) 0;
01516 
01517           // Formatage MED des CNX
01518           conversionCNX(CNX[tm], tm, nTYPE);
01519 
01520           // Chargement numTYPE
01521           //for (int nl=0; nl<nTYPE; nl++)    *(numTYPE+nl) = (med_int) ( NUM_MAILLES[tm][nl] );
01522 //          cerr << "maa=" << maa << endl;
01523 //          cerr << "MGE=" << MGE << endl;
01524 //          cerr << "nTYPE=" << nTYPE << endl;
01525 //          cerr << "inomTYPE=" << inomTYPE << endl;
01526 //          //cerr << "nomTYPE=" << nomTYPE << endl;
01527 //          cerr << "inumTYPE=" << inumTYPE << endl;
01528 //          this->afficheMailles(tm);
01529           if (MEDmeshElementWr(fid, maa, MED_NO_DT, MED_NO_IT, MED_UNDEF_DT, MED_CELL, MGE, MED_NODAL,
01530                                MED_FULL_INTERLACE, nTYPE, CNX[tm], inomTYPE, nomTYPE, inumTYPE, numTYPE, MED_FALSE,
01531                                famTYPE) < 0)
01532             {
01533               ERREUR("Error MEDmeshElementWr");
01534               cout << "Error MEDmeshElementWr, type " << stype << endl;
01535             }
01536           if (MEDmeshEntityFamilyNumberWr(fid, maa, MED_NO_DT, MED_NO_IT,
01537                                           MED_CELL, MGE, nTYPE, famTYPE) < 0)
01538             {
01539               ERREUR("Error MEDmeshEntityFamilyNumberWr");
01540               cout << "Error MEDmeshEntityFamilyNumberWr, type " << stype << endl;
01541             }
01542 
01543           // free(nomTYPE);
01544           // free(numTYPE);
01545           free(famTYPE);
01546           // free(conTYPE);
01547 
01548         } // Effectif non vide
01549     }
01550 
01551   // ########################################################################
01552   //                            Fermeture du fichier MED
01553   // ########################################################################
01554 
01555   if (MEDfileClose(fid) < 0)
01556     {
01557       ERREUR("Error on close MED file\n");
01558       cout << "Error on close MED file" << endl;
01559     }
01560 
01561   delete unicoo;
01562   delete nomcoo;
01563 
01564   // cout << endl << endl << "Fin procédure outputMED" << endl;
01565 } // outputMED
01566 
01567 
01568 int Maillage::NGLOBAL(TYPE_MAILLE typeMaille, int nlocal)
01569 {
01570   // Attention, les num. globaux commencent à 1, les num. locaux à 0
01571   int cpt = 1 + nlocal;
01572   for (int itm = (int) POI1; itm < (int) typeMaille; itm++)
01573     { // Attention! inférieur strict!
01574       TYPE_MAILLE tm = (TYPE_MAILLE) itm;
01575       cpt += EFFECTIFS_TYPES[tm];
01576     }
01577   return cpt;
01578 }
01579 
01580 TYPE_MAILLE Maillage::TYPE(int nglobal)
01581 {
01582   // Attention, les num. globaux commencent à 1, les num. locaux à 0
01583   TYPE_MAILLE resultat;
01584   int cpt = 0;
01585   for (int itm = (int) POI1; itm <= (int) HEXA20; itm++)
01586     {
01587       TYPE_MAILLE tm = (TYPE_MAILLE) itm;
01588       cpt += EFFECTIFS_TYPES[tm];
01589       if (nglobal <= cpt)
01590         {
01591           resultat = tm;
01592           break;
01593         }
01594     }
01595   return resultat;
01596 }
01597 
01598 int Maillage::NLOCAL(int nglobal, TYPE_MAILLE tm)
01599 {
01600   // Attention, les num. globaux commencent à 1, les num. locaux à 0
01601   int nPOI1 = EFFECTIFS_TYPES[POI1];
01602   int nSEG2 = EFFECTIFS_TYPES[SEG2];
01603   int nSEG3 = EFFECTIFS_TYPES[SEG3];
01604   int nTRIA3 = EFFECTIFS_TYPES[TRIA3];
01605   int nTRIA6 = EFFECTIFS_TYPES[TRIA6];
01606   int nQUAD4 = EFFECTIFS_TYPES[QUAD4];
01607   int nQUAD8 = EFFECTIFS_TYPES[QUAD8];
01608   int nTETRA4 = EFFECTIFS_TYPES[TETRA4];
01609   int nTETRA10 = EFFECTIFS_TYPES[TETRA10];
01610   int nPYRAM5 = EFFECTIFS_TYPES[PYRAM5];
01611   int nPYRAM13 = EFFECTIFS_TYPES[PYRAM13];
01612   int nPENTA6 = EFFECTIFS_TYPES[PENTA6];
01613   int nPENTA15 = EFFECTIFS_TYPES[PENTA15];
01614   int nHEXA8 = EFFECTIFS_TYPES[HEXA8];
01615   int nHEXA20 = EFFECTIFS_TYPES[HEXA20];
01616 
01617   if (nglobal <= nPOI1)
01618     {
01619       return nglobal - 1;
01620     }
01621   else if (nglobal <= nPOI1 + nSEG2)
01622     {
01623       return nglobal - nPOI1 - 1;
01624     }
01625   else if (nglobal <= nPOI1 + nSEG2 + nSEG3)
01626     {
01627       return nglobal - nPOI1 - nSEG2 - 1;
01628     }
01629   else if (nglobal <= nPOI1 + nSEG2 + nSEG3 + nTRIA3)
01630     {
01631       return nglobal - nPOI1 - nSEG2 - nSEG3 - 1;
01632     }
01633   else if (nglobal <= nPOI1 + nSEG2 + nSEG3 + nTRIA3 + nTRIA6)
01634     {
01635       return nglobal - nPOI1 - nSEG2 - nSEG3 - nTRIA3 - 1;
01636     }
01637   else if (nglobal <= nPOI1 + nSEG2 + nSEG3 + nTRIA3 + nTRIA6 + nQUAD4)
01638     {
01639       return nglobal - nPOI1 - nSEG2 - nSEG3 - nTRIA3 - nTRIA6 - 1;
01640     }
01641   else if (nglobal <= nPOI1 + nSEG2 + nSEG3 + nTRIA3 + nTRIA6 + nQUAD4 + nQUAD8)
01642     {
01643       return nglobal - nPOI1 - nSEG2 - nSEG3 - nTRIA3 - nTRIA6 - nQUAD4 - 1;
01644     }
01645   else if (nglobal <= nPOI1 + nSEG2 + nSEG3 + nTRIA3 + nTRIA6 + nQUAD4 + nQUAD8 + nTETRA4)
01646     {
01647       return nglobal - nPOI1 - nSEG2 - nSEG3 - nTRIA3 - nTRIA6 - nQUAD4 - nQUAD8 - 1;
01648     }
01649   else if (nglobal <= nPOI1 + nSEG2 + nSEG3 + nTRIA3 + nTRIA6 + nQUAD4 + nQUAD8 + nTETRA4 + nTETRA10)
01650     {
01651       return nglobal - nPOI1 - nSEG2 - nSEG3 - nTRIA3 - nTRIA6 - nQUAD4 - nQUAD8 - nTETRA4 - 1;
01652     }
01653   else if (nglobal <= nPOI1 + nSEG2 + nSEG3 + nTRIA3 + nTRIA6 + nQUAD4 + nQUAD8 + nTETRA4 + nTETRA10 + nPYRAM5)
01654     {
01655       return nglobal - nPOI1 - nSEG2 - nSEG3 - nTRIA3 - nTRIA6 - nQUAD4 - nQUAD8 - nTETRA4 - nTETRA10 - 1;
01656     }
01657   else if (nglobal <= nPOI1 + nSEG2 + nSEG3 + nTRIA3 + nTRIA6 + nQUAD4 + nQUAD8 + nTETRA4 + nTETRA10 + nPYRAM5
01658       + nPYRAM13)
01659     {
01660       return nglobal - nPOI1 - nSEG2 - nSEG3 - nTRIA3 - nTRIA6 - nQUAD4 - nQUAD8 - nTETRA4 - nTETRA10 - nPYRAM5 - 1;
01661     }
01662   else if (nglobal <= nPOI1 + nSEG2 + nSEG3 + nTRIA3 + nTRIA6 + nQUAD4 + nQUAD8 + nTETRA4 + nTETRA10 + nPYRAM5
01663       + nPYRAM13 + nPENTA6)
01664     {
01665       return nglobal - nPOI1 - nSEG2 - nSEG3 - nTRIA3 - nTRIA6 - nQUAD4 - nQUAD8 - nTETRA4 - nTETRA10 - nPYRAM5
01666           - nPYRAM13 - 1;
01667     }
01668   else if (nglobal <= nPOI1 + nSEG2 + nSEG3 + nTRIA3 + nTRIA6 + nQUAD4 + nQUAD8 + nTETRA4 + nTETRA10 + nPYRAM5
01669       + nPYRAM13 + nPENTA6 + nPENTA15)
01670     {
01671       return nglobal - nPOI1 - nSEG2 - nSEG3 - nTRIA3 - nTRIA6 - nQUAD4 - nQUAD8 - nTETRA4 - nTETRA10 - nPYRAM5
01672           - nPYRAM13 - nPENTA6 - 1;
01673     }
01674   else if (nglobal <= nPOI1 + nSEG2 + nSEG3 + nTRIA3 + nTRIA6 + nQUAD4 + nQUAD8 + nTETRA4 + nTETRA10 + nPYRAM5
01675       + nPYRAM13 + nPENTA6 + nPENTA15 + nHEXA8)
01676     {
01677       return nglobal - nPOI1 - nSEG2 - nSEG3 - nTRIA3 - nTRIA6 - nQUAD4 - nQUAD8 - nTETRA4 - nTETRA10 - nPYRAM5
01678           - nPYRAM13 - nPENTA6 - nPENTA15 - 1;
01679     }
01680   else if (nglobal <= nPOI1 + nSEG2 + nSEG3 + nTRIA3 + nTRIA6 + nQUAD4 + nQUAD8 + nTETRA4 + nTETRA10 + nPYRAM5
01681       + nPYRAM13 + nPENTA6 + nPENTA15 + nHEXA8 + nHEXA20)
01682     {
01683       return nglobal - nPOI1 - nSEG2 - nSEG3 - nTRIA3 - nTRIA6 - nQUAD4 - nQUAD8 - nTETRA4 - nTETRA10 - nPYRAM5
01684           - nPYRAM13 - nPENTA6 - nPENTA15 - nHEXA8 - 1;
01685     }
01686   else
01687     ERREUR("method NLOCAL: unknown type");
01688   return 0;
01689 }
01690 
01700 void Maillage::eliminationMailles(TYPE_MAILLE tm, vector<int> listeMaillesSuppr)
01701 {
01702   map<int, int> TABLE_NL; // Table des num. locaux dans le type tm
01703 
01704   cout << "Method eliminationMailles, listeMaillesSuppr.size()=" << listeMaillesSuppr.size() << endl;
01705 
01706   // ************* Modification de la connectivité du type concerné
01707 
01708   int* CNX2;
01709   int nNoeudsType = Nnoeuds(tm);
01710   int tailleCNX2 = nNoeudsType * (EFFECTIFS_TYPES[tm] - listeMaillesSuppr.size());
01711   CNX2 = (int*) malloc(sizeof(int) * tailleCNX2);
01712   // Recopie sélective des connectivités
01713   int isuppr = 0; // indice dans listeMaillesSuppr
01714   int ih2 = 0; // nouveau numéro local ( remarque: ih2 = ih1 - isuppr )
01715   for (int ih1 = 0; ih1 < EFFECTIFS_TYPES[tm]; ih1++)
01716     {
01717       if (listeMaillesSuppr[isuppr] != ih1)
01718         {
01719           for (int jh1 = 0; jh1 < nNoeudsType; jh1++)
01720             *(CNX2 + nNoeudsType * ih2 + jh1) = *(CNX[tm] + nNoeudsType * ih1 + jh1);
01721           ih2++;
01722         }
01723       else
01724         isuppr++;
01725     }
01726   free(CNX[tm]);
01727   CNX[tm] = CNX2;
01728 
01729   // ************* Construction de la table de correspondance des NL dans le type concerné
01730   unsigned int offset = 0;
01731   for (int i = 0; i < EFFECTIFS_TYPES[tm]; i++)
01732     {
01733       if (offset < listeMaillesSuppr.size())
01734         {
01735           if (i < listeMaillesSuppr[offset])
01736             TABLE_NL[i] = i - offset;
01737           else if (i == listeMaillesSuppr[offset])
01738             {
01739               TABLE_NL[i] = -1; // Element à supprimer
01740               offset++;
01741             }
01742         }
01743       else
01744         TABLE_NL[i] = i - offset;
01745     }
01746 
01747   // Contrôle
01748   if (offset != listeMaillesSuppr.size())
01749     {
01750       ERREUR("Incoherent offset, method eliminationMailles");
01751       exit(0);
01752     }
01753 
01754   // ************* Mise à jour du type concerné dans les GM
01755   for (map<string, map<TYPE_MAILLE, vector<int> > >::iterator I = GM.begin(); I != GM.end(); I++)
01756     {
01757       string nomGM = I->first;
01758 
01759       if (GM[nomGM][tm].size())
01760         {
01761           //cout << "GM[" << nomGM <<"][" << tm << "].size()=" << GM[nomGM][tm].size() << endl;
01762           vector<int> mailles = GM[nomGM][tm];
01763           vector<int> mailles2; //mailles2.resize(mailles.size()-listeMaillesSuppr.size());
01764           unsigned int cptMailles = 0;
01765           for (unsigned int i = 0; i < mailles.size(); i++)
01766             {
01767               int nl2 = TABLE_NL[mailles[i]];
01768               if (nl2 != -1)
01769                 {
01770                   mailles2.push_back(nl2);
01771                   cptMailles++;
01772                 }
01773             }
01774 
01775           GM[nomGM][tm].clear();
01776           mailles2.resize(cptMailles);
01777           GM[nomGM][tm] = mailles2;
01778 
01779         }
01780     }
01781 
01782   // ************* Mise à jour des effectifs
01783 
01784   EFFECTIFS_TYPES[tm] = EFFECTIFS_TYPES[tm] - listeMaillesSuppr.size();
01785   nombreMaillesMaillage = nombreMaillesMaillage - listeMaillesSuppr.size();
01786 
01787   TABLE_NL.clear();
01788 }
01789