--- /dev/null
+// Copyright (C) 2006-2012 EDF R&D
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+#include "MeshCut_Maillage.hxx"
+#include "MeshCut_Cube.hxx"
+
+#include <iostream>
+#include <sstream>
+#include <list>
+#include <algorithm>
+#include <cmath>
+#include <cstring>
+
+using namespace MESHCUT;
+using namespace std;
+
+Maillage::Maillage(std::string _ID)
+{
+ ID = _ID;
+ nombreNoeudsMaillage = 0;
+ nombreMaillesMaillage = 0;
+ //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;
+ GM.clear();
+ GN.clear();
+ for (int itm = (int) POI1; itm <= (int) HEXA20; itm++)
+ EFFECTIFS_TYPES[(TYPE_MAILLE) itm] = 0;
+}
+
+Maillage::~Maillage()
+{
+}
+
+void Maillage::creationGMtype(TYPE_MAILLE tm, std::string nomGMtype)
+{
+ //cout << "Creation GM type, groupe " << nomGMtype << endl;
+ for (int nl = 0; nl < EFFECTIFS_TYPES[tm]; nl++)
+ GM[nomGMtype][tm].push_back(nl);
+ GM[nomGMtype][tm].resize(EFFECTIFS_TYPES[tm]);
+ sort(GM[nomGMtype][tm].begin(), GM[nomGMtype][tm].end());
+}
+
+void Maillage::afficheMailles(TYPE_MAILLE tm)
+{
+ cout << "Affichage des mailles du type " << TM2string(tm) << " (effectif " << EFFECTIFS_TYPES[tm] << "): " << endl;
+ if (EFFECTIFS_TYPES[tm])
+ {
+ // Boucle sur les connectivités d'un type tm
+ int nnoeuds = Nnoeuds(tm);
+ for (int i = 0; i < EFFECTIFS_TYPES[tm]; i++)
+ {
+ cout << "\tMaille " << i << " :" << endl;
+ //Boucle sur les noeuds de la maille de numéro local i dans le type tm
+ int * offset = CNX[tm] + nnoeuds * i;
+ for (int j = 0; j < nnoeuds; j++)
+ {
+ int ngnoeud = *(offset + j);
+ //cout << "\t\t" << X[ngnoeud-1] << " " << Y[ngnoeud-1] << " " << Z[ngnoeud-1] << endl;
+ cout << "\t" << ngnoeud << "\t" << *(XX + ngnoeud - 1) << " " << *(YY + ngnoeud - 1) << " " << *(ZZ + ngnoeud - 1) << endl;
+ }
+ }
+ cout << endl;
+ }
+}
+
+void Maillage::listeMaillesType(TYPE_MAILLE tm)
+{
+ cout << "La fonction \"Restitution des mailles par type\" est obsolète " << endl;
+
+ // cout << "Restitution des mailles du type " << TM2string(tm) << " (effectif " << EFFECTIFS_TYPES[tm] << "): " << endl;
+ // if (EFFECTIFS_TYPES[tm])
+ // for (int i = 0; i < IDS_MAILLES[tm].size(); i++)
+ // cout << IDS_MAILLES[tm][i] << " ";
+ // cout << endl;
+}
+
+void Maillage::listeMaillesTousTypes()
+{
+ for (int itm = (int) POI1; itm <= (int) HEXA20; itm++)
+ {
+ TYPE_MAILLE tm = (TYPE_MAILLE) itm;
+ listeMaillesType(tm);
+ }
+}
+
+void Maillage::listeMaillesParGM()
+{
+ cout << "Liste des mailles par GM : " << endl;
+ for (map<string, map<TYPE_MAILLE, vector<int> > >::iterator I = GM.begin(); I != GM.end(); I++)
+ listeMaillesGM(I->first);
+}
+
+void Maillage::listeMaillesGM(std::string nomGM)
+{
+ cout << "Liste des mailles du groupe " << nomGM << " : " << endl;
+ for (int itm = (int) POI1; itm <= (int) HEXA20; itm++)
+ {
+ TYPE_MAILLE tm = (TYPE_MAILLE) itm;
+ if (GM[nomGM][tm].size())
+ {
+ cout << "\t" << TM2string(tm) << " : ";
+ for (unsigned int j = 0; j < GM[nomGM][tm].size(); j++)
+ cout << GM[nomGM][tm][j] << " ";
+ cout << endl;
+ }
+ }
+}
+
+//void Maillage::listeMaillesGMordonne(std::string nomGM)
+//{
+// cout << "Liste ordonnée des mailles du groupe " << nomGM << " (" << GM[nomGM].size() << " mailles) : ";
+// sort(GM[nomGM].begin(), GM[nomGM].end());
+// for (int j = 0; j < GM[nomGM].size(); j++)
+// cout << GM[nomGM][j] << " ";
+// cout << endl;
+//}
+
+void Maillage::listeNoeuds()
+{
+ cout << "Liste des noeuds du maillage : " << endl;
+ for (int i = 0; i < nombreNoeudsMaillage; i++)
+ cout << "\t" << *(XX + i) << " " << *(YY + i) << " " << *(ZZ + i) << endl;
+ cout << endl;
+}
+
+void Maillage::listeNoeudsGN(std::string nomGN)
+{
+ cout << "Liste brute des noeuds du groupe " << nomGN << " (" << GN[nomGN].size() << " noeuds) : ";
+ for (unsigned int j = 0; j < GN[nomGN].size(); j++)
+ cout << GN[nomGN][j] << " ";
+ cout << endl;
+}
+
+void Maillage::listeNoeudsGNordonne(std::string nomGN)
+{
+ cout << "Liste ordonnée des noeuds du groupe " << nomGN << " (" << GN[nomGN].size() << " noeuds) : ";
+ sort(GN[nomGN].begin(), GN[nomGN].end());
+ for (unsigned int j = 0; j < GN[nomGN].size(); j++)
+ cout << GN[nomGN][j] << " ";
+ cout << endl;
+}
+
+std::vector<float> Maillage::G(int i, TYPE_MAILLE tm)
+{
+ vector<float> G;
+ float x = 0.0;
+ float y = 0.0;
+ float z = 0.0;
+ int nn = NnoeudsGeom(tm);
+ for (int j = 0; j < nn; j++)
+ {
+ int ng = CNX[tm][nn * i + j];
+ x += XX[ng - 1];
+ y += YY[ng - 1];
+ z += ZZ[ng - 1];
+ }
+ G.push_back(x / nn);
+ G.push_back(y / nn);
+ G.push_back(z / nn);
+ G.resize(3);
+ return G;
+}
+
+float Maillage::distanceNoeudMaille(int ngnoeud, int imaille, TYPE_MAILLE tm)
+{
+ float x, y, z;
+ float x0 = XX[ngnoeud - 1];
+ float y0 = YY[ngnoeud - 1];
+ float z0 = ZZ[ngnoeud - 1];
+ int nn = NnoeudsGeom(tm);
+ float d1 = 1000000000000.0;
+ float d;
+ for (int j = 0; j < nn; j++)
+ {
+ int ng = CNX[tm][nn * imaille + j]; // Noeud courant dans la maille
+ x = XX[ng - 1];
+ y = YY[ng - 1];
+ z = ZZ[ng - 1];
+ d = sqrt((x - x0) * (x - x0) + (y - y0) * (y - y0) + (z - z0) * (z - z0));
+ if (d < d1)
+ d1 = d;
+ }
+ return d1;
+}
+
+/*!
+ * Retourne le ng du noeud le plus proche de ngnoeud dans la maille imaille du type tm
+ */
+int Maillage::noeudVoisin(int ngnoeud, int imaille, TYPE_MAILLE tm)
+{
+ float x, y, z;
+ int ngv;
+ float x0 = XX[ngnoeud - 1];
+ float y0 = YY[ngnoeud - 1];
+ float z0 = ZZ[ngnoeud - 1];
+ int nn = NnoeudsGeom(tm);
+ float d1 = 1000000000000.0;
+ float d;
+ for (int j = 0; j < nn; j++)
+ {
+ int ng = CNX[tm][nn * imaille + j]; // Noeud courant dans la maille
+ x = XX[ng - 1];
+ y = YY[ng - 1];
+ z = ZZ[ng - 1];
+ d = sqrt((x - x0) * (x - x0) + (y - y0) * (y - y0) + (z - z0) * (z - z0));
+ if (d < d1)
+ {
+ d1 = d;
+ ngv = ng;
+ }
+ }
+ return ngv;
+}
+
+float Maillage::distanceNoeudNoeud(int ng1, int ng2)
+{
+ float x1, x2, y1, y2, z1, z2;
+ x1 = XX[ng1 - 1];
+ y1 = YY[ng1 - 1];
+ z1 = ZZ[ng1 - 1];
+ x2 = XX[ng2 - 1];
+ y2 = YY[ng2 - 1];
+ z2 = ZZ[ng2 - 1];
+ return sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2) + (z1 - z2) * (z1 - z2));
+}
+
+//void Maillage::encombrements()
+//{
+// float ex = 0.0;
+// float ey = 0.0;
+// float ez = 0.0;
+//
+// for (int itm = (int) SEG2; itm <= (int) HEXA20; itm++)
+// {
+// TYPE_MAILLE tm = (TYPE_MAILLE) itm;
+// if (MAILLAGE->EFFECTIFS_TYPES[tm])
+// {
+// int nnoeuds = Nnoeuds(tm);
+// for (int i = 0; i < CON[tm].size() / nnoeuds; i++)
+// {
+// //Boucle sur les noeuds de la maille de numéro local i dans le type tm
+// for (int j = 0; j < nnoeuds; j++)
+// {
+// //..... CON[tm][nnoeuds*i+j];
+// }
+// }
+// }
+// }
+// // Boucle sur les connectivités d'un type tm
+//}
+
+void Maillage::inputMED(std::string fichierMED)
+{
+ //cout << endl << "Début procédure inputMED, fichier "<< fichierMED << endl;
+
+ // int i, j, k, ichamp, igauss, ipt, ival;
+ int j;
+ // med_err ret = 0; // Code retour
+ med_idt fid; // Descripteur de fichier MED
+ char maa[MED_NAME_SIZE + 1]; // nom du maillage de longueur maxi MED_NAME_SIZE
+ med_int spacedim;
+ med_int mdim; // Dimension du maillage
+ med_mesh_type type;
+ char desc[MED_COMMENT_SIZE + 1]; // Description du maillage
+
+ // Profils
+ // med_int nprofils;
+ // int iprofil;
+ // char nomprofil[MED_NAME_SIZE + 1] = "";
+ // med_int nvalprofil, nvalprofil2;
+ // med_int *pflval;
+
+ // Champs
+ // med_int nChamps, nCompChamp, nval;
+ // char *compChamp, *unitChamp, *nomChamp;
+ //char nomChamp [ MED_NAME_SIZE+1 ] = "";
+ // med_field_type typeChamp;
+ // med_int nGauss, ngpdt, numdt, numo;
+ med_int nPasTemps;
+ // char locname[MED_NAME_SIZE + 1] = "";
+ // med_geometry_type type_geo;
+ // med_int ngauss;
+ char dtunit[MED_SNAME_SIZE + 1] = "";
+ // med_float dt = 0.0;
+ // med_bool local;
+ // med_int nbrefmaa;
+
+ med_sorting_type sortingtype;
+ med_axis_type axistype;
+
+ // Initialisations
+ FAMILLES.clear();
+ FAM_TYPES.clear();
+ FAMILLES_NOEUDS.clear();
+ GROUPES_MAILLES.clear();
+ GROUPES_NOEUDS.clear();
+ RESIDU.clear(); // Sera initialisé à 1 par la routine acquisitionTYPE_inputMED
+ tailleFAMILLES.clear();
+ tailleGROUPES.clear();
+
+ // Ouverture du fichier MED en lecture seule
+ fid = MEDfileOpen(string2char(fichierMED), MED_ACC_RDONLY);
+ if (fid < 0)
+ {
+ ERREUR("Error file open\n");
+ }
+ //cout << chrono() << " --- inputMED: MEDfileOpen: ouverture du maillage en lecture seule, OK" << endl;
+
+ // Lecture des infos concernant le premier maillage
+ if (MEDmeshInfo(fid, 1, maa, &spacedim, &mdim, &type, desc, dtunit, &sortingtype, &nPasTemps, &axistype, axisname,
+ unitname) < 0)
+ ERREUR("Error while reading mesh informations ");
+ //cout << chrono() << " --- inputMED: MEDmeshInfo: OK" << endl;
+
+// cerr << "maa=" << maa << endl;
+// cerr << "spacedim=" << spacedim << endl;
+// cerr << "mdim=" << mdim << endl;
+// cerr << "type=" << type << endl;
+// cerr << "desc=" << desc << endl;
+// cerr << "dtunit=" << dtunit << endl;
+// cerr << "sortingtype=" << sortingtype << endl;
+// cerr << "nPasTemps=" << nPasTemps << endl;
+// cerr << "axistype=" << axistype << endl;
+// cerr << "axisname=" << axisname << endl;
+// cerr << "unitname=" << unitname << endl;
+
+ dimensionMaillage = mdim;
+ dimensionEspace = spacedim;
+
+ ID = (string) maa;
+
+ // nGauss = MEDnGauss(fid);
+ // if (debug > 0)
+ // cout << "Nombre d'éléments portant des points de Gauss: " << (int) nGauss << endl;
+ // map<string, int> REFGAUSS;
+ // map<string, int>::iterator iterGAUSS;
+ // for (igauss = 1; igauss <= nGauss; igauss++)
+ // {
+ // if (MEDgaussInfo(fid, igauss, locname, &type_geo, &ngauss) < 0)
+ // ERREUR("Erreur MEDgaussInfo");
+ // if (debug == 2)
+ // {
+ // cout << endl << " Retour MEDgaussInfo, localisation gauss n°" << igauss << " : " << endl;
+ // cout << " locname = " << locname << endl;
+ // cout << " type_geo = " << type_geo << endl;
+ // cout << " ngauss = " << ngauss << endl;
+ // cout << endl;
+ // }
+ // REFGAUSS[(string) locname] = (int) ngauss;
+ // }
+ //
+ // if (debug == 2)
+ // {
+ // cout << endl << "Restitution de la table REFGAUSS:" << endl;
+ // for (iterGAUSS = REFGAUSS.begin(); iterGAUSS != REFGAUSS.end(); iterGAUSS++)
+ // {
+ // cout << iterGAUSS->first << " : " << iterGAUSS->second << endl;
+ // }
+ // }
+ //
+ // nprofils = MEDnProfil(fid);
+ // if (debug)
+ // cout << endl << endl << "Nombre de profils: " << nprofils << endl;
+ // for (iprofil = 1; iprofil <= nprofils; iprofil++)
+ // {
+ // if (MEDprofilInfo(fid, iprofil, nomprofil, &nvalprofil) < 0)
+ // ERREUR("ERREUR MEDprofilInfo");
+ // nvalprofil2 = MEDnValProfil(fid, nomprofil);
+ // if (debug == 2)
+ // {
+ // cout << "Profil " << iprofil << " : " << endl;
+ // cout << " Nom profil : " << nomprofil << endl;
+ // cout << " Nombre de valeurs profil (par MEDprofilInfo) : " << nvalprofil << endl;
+ // cout << " Nombre de valeurs profil (par MEDnValProfil) : " << nvalprofil2 << endl;
+ // }
+ // if (nvalprofil != nvalprofil2)
+ // ERREUR("Discordance nvalprofil (entre MEDprofilInfo et MEDnValProfil)");
+ // pflval = (med_int*) malloc(sizeof(med_int) * nvalprofil);
+ // if (MEDprofilLire(fid, pflval, nomprofil) < 0)
+ // ERREUR("ERREUR MEDprofilLire");
+ // //cout << " Affichage des 100 premières valeurs:" << endl;
+ // //for (ival=0;ival<min(100,nvalprofil);ival++) cout << " " << *(pflval+ival) ;
+ // free(pflval);
+ // }
+ //
+ // nChamps = MEDnChamp(fid, 0);
+ // cout << "Nombre de champs : " << (int) nChamps << endl;
+ //
+ // if (nChamps > 0)
+ // {
+ //
+ // for (ichamp = 1; ichamp <= nChamps; ichamp++)
+ // {
+ // //for (ichamp=4; ichamp<=4; ichamp++ ) {
+ // cout << endl << endl;
+ // cout << endl << endl << " ====================================================================" << endl;
+ // cout << endl << endl << " CHAMP " << ichamp << endl;
+ // cout << endl << endl << " ====================================================================" << endl;
+ // cout << endl << endl;
+ //
+ // nCompChamp = MEDnChamp(fid, ichamp);
+ // if (nCompChamp < 0)
+ // ERREUR("Erreur Ncomposantes champ");
+ // cout << "Nombre de composantes du champ " << ichamp << " : " << (int) nCompChamp << endl;
+ //
+ // nomChamp = (char*) malloc(MED_NAME_SIZE + 1);
+ // compChamp = (char*) malloc(nCompChamp * MED_SNAME_SIZE + 1);
+ // unitChamp = (char*) malloc(nCompChamp * MED_SNAME_SIZE + 1);
+ //
+ // if (MEDchampInfo(fid, ichamp, nomChamp, &typeChamp, compChamp, unitChamp, nCompChamp) < 0)
+ // ERREUR("Erreur MEDchampInfo");
+ //
+ // cout << "Infos sur le champ " << ichamp << " : " << endl;
+ // cout << " Nom: " << (string) nomChamp << endl;
+ // cout << " Type: " << typeChamp << endl;
+ // cout << " Noms des composantes: " << (string) compChamp << endl;
+ // cout << " Unités des composantes: " << (string) unitChamp << endl;
+ //
+ // infoChamps((string) "NOEUDS", MED_NODE, MED_NONE, fid, maa, nomChamp, typeChamp, nCompChamp, REFGAUSS);
+ // infoChamps((string) "POI1", MED_CELL, MED_POINT1, fid, maa, nomChamp, typeChamp, nCompChamp, REFGAUSS);
+ // infoChamps((string) "SEG2", MED_CELL, MED_SEG2, fid, maa, nomChamp, typeChamp, nCompChamp, REFGAUSS);
+ // infoChamps((string) "SEG3", MED_CELL, MED_SEG3, fid, maa, nomChamp, typeChamp, nCompChamp, REFGAUSS);
+ // infoChamps((string) "TRIA3", MED_CELL, MED_TRIA3, fid, maa, nomChamp, typeChamp, nCompChamp, REFGAUSS);
+ // infoChamps((string) "TRIA6", MED_CELL, MED_TRIA6, fid, maa, nomChamp, typeChamp, nCompChamp, REFGAUSS);
+ // infoChamps((string) "QUAD4", MED_CELL, MED_QUAD4, fid, maa, nomChamp, typeChamp, nCompChamp, REFGAUSS);
+ // infoChamps((string) "QUAD8", MED_CELL, MED_QUAD8, fid, maa, nomChamp, typeChamp, nCompChamp, REFGAUSS);
+ // infoChamps((string) "TETRA4", MED_CELL, MED_TETRA4, fid, maa, nomChamp, typeChamp, nCompChamp, REFGAUSS);
+ // infoChamps((string) "TETRA10", MED_CELL, MED_TETRA10, fid, maa, nomChamp, typeChamp, nCompChamp, REFGAUSS);
+ // infoChamps((string) "PYRAM5", MED_CELL, MED_PYRA5, fid, maa, nomChamp, typeChamp, nCompChamp, REFGAUSS);
+ // infoChamps((string) "PYRAM13", MED_CELL, MED_PYRA13, fid, maa, nomChamp, typeChamp, nCompChamp, REFGAUSS);
+ // infoChamps((string) "PENTA6", MED_CELL, MED_PENTA6, fid, maa, nomChamp, typeChamp, nCompChamp, REFGAUSS);
+ // infoChamps((string) "PENTA15", MED_CELL, MED_PENTA15, fid, maa, nomChamp, typeChamp, nCompChamp, REFGAUSS);
+ // infoChamps((string) "HEXA8", MED_CELL, MED_HEXA8, fid, maa, nomChamp, typeChamp, nCompChamp, REFGAUSS);
+ // infoChamps((string) "HEXA20", MED_CELL, MED_HEXA20, fid, maa, nomChamp, typeChamp, nCompChamp, REFGAUSS);
+ //
+ // }
+ //
+ // cout << endl << "Rappel des codes de géométries: " << endl;
+ // cout << " TETRA4 = " << MED_TETRA4 << endl;
+ // cout << " PENTA6 = " << MED_PENTA6 << endl;
+ // cout << " HEXA8 = " << MED_HEXA8 << endl;
+ //
+ // }
+ // else
+ // cout << "Pas de champs dans ce maillage" << endl;
+
+ // ##################################################################################################
+ // ##################################################################################################
+ //
+ // A C Q U I S I T I O N D E S F A M I L L E S
+ //
+ // ##################################################################################################
+ // ##################################################################################################
+
+
+ med_int nFamilles;
+ char nomGroupeChar[MED_LNAME_SIZE + 1];
+ if ((nFamilles = MEDnFamily(fid, maa)) < 0)
+ ERREUR("ERROR MEDnFamily");
+
+ // Initialisation des tailles: tailleFAMILLES et tailleGROUPES
+
+ // for (int i = 0; i < nFamilles; i++)
+ // {
+ // char nomfam[MED_NAME_SIZE + 1];
+ // char *attdes, *gro;
+ // med_int numfam, *attide, *attval, natt, ngro;
+ //
+ // if ((ngro = MEDnFamilyGroup(fid, maa, i + 1)) < 0)
+ // ERREUR("ERREUR MEDnFamilyGroup");
+ // if ((natt = MEDnFamily23Attribute(fid, maa, i + 1)) < 0)
+ // ERREUR("ERREUR MEDnFamily23Attribute");
+ //
+ // attide = (med_int *) malloc(sizeof(med_int) * natt);
+ // attval = (med_int *) malloc(sizeof(med_int) * natt);
+ // attdes = (char *) malloc(MED_COMMENT_SIZE * natt + 1);
+ // gro = (char *) malloc(MED_LNAME_SIZE * ngro + 1);
+ //
+ // if (MEDfamilyInfo(fid, maa, (med_int)(i + 1), nomfam, &numfam, attide, attval, attdes, &natt, gro, &ngro) < 0)
+ // ERREUR("ERREUR MEDfamilyInfo");
+ //
+ // free(attide);
+ // free(attval);
+ // free(attdes);
+ // free(gro);
+ // }
+
+ for (int i = 0; i < nFamilles; i++)
+ {
+ char nomfam[MED_NAME_SIZE + 1];
+ char *attdes, *gro;
+ med_int numfam, *attide, *attval, natt, ngro;
+
+ if ((ngro = MEDnFamilyGroup(fid, maa, i + 1)) < 0)
+ ERREUR("ERROR MEDnFamilyGroup");
+ if ((natt = MEDnFamily23Attribute(fid, maa, i + 1)) < 0)
+ ERREUR("ERROR MEDnFamily23Attribute");
+
+ attide = (med_int *) malloc(sizeof(med_int) * natt);
+ attval = (med_int *) malloc(sizeof(med_int) * natt);
+ attdes = (char *) malloc(MED_COMMENT_SIZE * natt + 1);
+ gro = (char *) malloc(MED_LNAME_SIZE * ngro + 1);
+
+ if (MEDfamilyInfo(fid, maa, (med_int) (i + 1), nomfam, &numfam, gro) < 0)
+ ERREUR("ERROR MEDfamilyInfo");
+
+ for (int ig = 1; ig <= ngro; ig++)
+ {
+ for (j = 0; j < MED_LNAME_SIZE; j++)
+ nomGroupeChar[j] = gro[(ig - 1) * MED_LNAME_SIZE + j];
+ nomGroupeChar[MED_LNAME_SIZE] = '\0';
+ //cout << "Groupe lu : " << (string)nomGroupeChar << endl;
+ tailleGROUPES[strip((string) nomGroupeChar)]++;
+ if (numfam > 0)
+ GROUPES_NOEUDS[strip((string) nomGroupeChar)].push_back((int) numfam);
+ else if (numfam < 0)
+ GROUPES_MAILLES[strip((string) nomGroupeChar)].push_back((int) numfam);
+ }
+
+ free(attide);
+ free(attval);
+ free(attdes);
+ free(gro);
+ }
+
+ // ##################################################################################################
+ // ##################################################################################################
+ //
+ // A C Q U I S I T I O N D E S N O E U D S
+ //
+ // ##################################################################################################
+ // ##################################################################################################
+
+ // class Noeud *n;
+ // list<Noeud*> listeNoeuds;
+ // float x, y, z, rx, ry, rz, tx, ty, tz;
+ string line, IDnoeud;
+ float x0, x1, y0, y1, z0, z1;
+
+ vector<int> RESIDU_NOEUDS; // Table de vérité du résidu des noeuds
+
+ ostringstream OSCOORD;
+
+ med_int nnoe = 0; // Nbre de noeuds
+ med_float *coo1; // Table des coordonnées
+ // char nomcoo[mdim * MED_SNAME_SIZE + 1]; // Table des noms des coordonnées
+ // char unicoo[mdim * MED_SNAME_SIZE + 1]; // Table des unités des coordonnées
+ char *nomnoe;
+
+ med_int *numnoe;
+ med_int *nufano;
+ // med_grid_type rep;
+ // med_bool inonoe, inunoe;
+ // med_int profil[2] = { 2, 3 };
+ med_bool coordinatechangement;
+ med_bool geotransformation;
+
+ // Combien de noeuds a lire ?
+ nnoe = MEDmeshnEntity(fid, maa, MED_NO_DT, MED_NO_IT, MED_NODE, MED_NO_GEOTYPE, MED_COORDINATE, MED_NO_CMODE,
+ &coordinatechangement, &geotransformation);
+
+ if (nnoe < 0)
+ ERREUR("Error while reading number of nodes");
+
+ nombreNoeudsMaillage = nnoe;
+
+ // Lecture des familles des noeuds
+ med_int *famNoeuds = (med_int*) malloc(sizeof(med_int) * nnoe);
+ if (nnoe > 0)
+ {
+ if (MEDmeshEntityFamilyNumberRd(fid, maa, MED_NO_DT, MED_NO_IT, MED_NODE, MED_NONE, famNoeuds) < 0)
+ ERREUR("Error while reading family node number (MEDmeshEntityFamilyNumberRd)");
+ }
+
+ /* Allocations memoires */
+ if (nnoe > 0)
+ {
+ // table des coordonnees - profil : (dimension * nombre de noeuds )
+ coo1 = (med_float*) calloc(nnoe * mdim, sizeof(med_float));
+ // table des des numeros, des numeros de familles des noeuds - profil : (nombre de noeuds)
+ numnoe = (med_int*) malloc(sizeof(med_int) * nnoe);
+ nufano = (med_int*) malloc(sizeof(med_int) * nnoe);
+ // table des noms des noeuds - profil : (nnoe*MED_SNAME_SIZE+1)
+ nomnoe = (char*) malloc(MED_SNAME_SIZE * nnoe + 1);
+ }
+
+ // Lecture des composantes des coordonnees des noeuds
+ if (nnoe > 0)
+ if (MEDmeshNodeCoordinateRd(fid, maa, MED_NO_DT, MED_NO_IT, MED_FULL_INTERLACE, coo1) < 0)
+ ERREUR("Error while reading nodes coordinates");
+
+ // // Les noeuds ont-ils un nom? un numéro?
+ // if (nnoe > 0)
+ // {
+ // if (MEDnomLire(fid, maa, nomnoe, nnoe, MED_NODE, (med_geometry_type) 0) < 0)
+ // inonoe = MED_FALSE;
+ // else
+ // inonoe = MED_TRUE;
+ // if (MEDnumLire(fid, maa, numnoe, nnoe, MED_NODE, (med_geometry_type) 0) < 0)
+ // inunoe = MED_FALSE;
+ // else
+ // inunoe = MED_TRUE;
+ // }
+ //
+ // if (inonoe)
+ // cout << "WARNING input MED : les noms des noeuds sont ignorés" << endl;
+ // if (inunoe)
+ // cout << "WARNING input MED : les numéros des noeuds sont ignorés" << endl;
+ //
+ // if (inonoe)
+ // {
+ // char str[MED_SNAME_SIZE + 1];
+ // for (int inoeud = 0; inoeud < nnoe; inoeud++)
+ // {
+ // strncpy(str, nomnoe + inoeud * MED_SNAME_SIZE, MED_SNAME_SIZE);
+ // str[MED_SNAME_SIZE] = '\0';
+ // IDS_NOEUDS.push_back((string) str);
+ // }
+ // }
+ // else if (inunoe)
+ // {
+ // for (int inoeud = 0; inoeud < nnoe; inoeud++)
+ // {
+ // int numnoeud = *(numnoe + inoeud);
+ // IDS_NOEUDS.push_back((string) "N" + int2string(numnoeud));
+ // }
+ // }
+ // else
+ // for (int inoeud = 0; inoeud < nnoe; inoeud++)
+ // IDS_NOEUDS.push_back((string) "N" + int2string(inoeud + 1));
+ // IDS_NOEUDS.resize(nnoe);
+
+ /* ====================================================================== */
+ /* BOUCLE SUR LES NOEUDS LUS DANS LE FICHIER MED */
+ /* ====================================================================== */
+
+ // X.resize(nnoe);
+ // Y.resize(nnoe);
+ // Z.resize(nnoe);
+
+ // Initialisation de l'enveloppe
+ x0 = coo1[0];
+ x1 = coo1[0];
+ y0 = coo1[1];
+ y1 = coo1[1];
+ if (mdim == 3)
+ {
+ z0 = coo1[2];
+ z1 = coo1[2];
+ }
+ else
+ {
+ z0 = 0.0;
+ z1 = 0.0;
+ }
+
+ // Allocation mémoire pour les coordonnées XX YY ZZ
+ XX = (float*) malloc(sizeof(float) * nombreNoeudsMaillage);
+ if (mdim > 1)
+ YY = (float*) malloc(sizeof(float) * nombreNoeudsMaillage);
+ if (mdim > 2)
+ ZZ = (float*) malloc(sizeof(float) * nombreNoeudsMaillage);
+
+ for (int i = 0; i < nnoe; i++)
+ {
+
+ // Chargement des coordonnées X, Y et Z
+ // Calcul de l'enveloppe du maillage
+
+ FAMILLES_NOEUDS[*(famNoeuds + i)].push_back(i + 1); // ATTENTION! Les num. de noeuds commencent à 1
+ tailleFAMILLES[*(famNoeuds + i)]++;
+
+ // IDnoeud = "N"+int2string(i+1);
+
+ float * XXi = XX + i;
+ float * YYi = YY + i;
+ float * ZZi = ZZ + i;
+
+ if (mdim == 3)
+ {
+ *XXi = (float) coo1[3 * i];
+ *YYi = (float) coo1[3 * i + 1];
+ *ZZi = (float) coo1[3 * i + 2];
+ if (*XXi < x0)
+ x0 = *XXi;
+ else if (*XXi > x1)
+ x1 = *XXi;
+ if (*YYi < y0)
+ y0 = *YYi;
+ else if (*YYi > y1)
+ y1 = *YYi;
+ if (*ZZi < z0)
+ z0 = *ZZi;
+ else if (*ZZi > z1)
+ z1 = *ZZi;
+ }
+ else if (mdim == 2)
+ {
+ *XXi = (float) coo1[2 * i];
+ *YYi = (float) coo1[2 * i + 1];
+ if (*XXi < x0)
+ x0 = *XXi;
+ else if (*XXi > x1)
+ x1 = *XXi;
+ if (*YYi < y0)
+ y0 = *YYi;
+ else if (*YYi > y1)
+ y1 = *YYi;
+ }
+ else if (mdim == 1)
+ {
+ *XXi = (float) coo1[1 * i];
+ if (*XXi < x0)
+ x0 = *XXi;
+ else if (*XXi > x1)
+ x1 = *XXi;
+ }
+
+ // Chargement des numéros de noeuds
+ // if (inunoe)
+ // NUM_NOEUDS.push_back(*(numnoe + i));
+ // else
+ // NUM_NOEUDS.push_back(i + 1);
+
+ } // boucle sur les noeuds
+
+ // NUM_NOEUDS.resize(nnoe);
+
+ // Enveloppe du maillage
+ enveloppeMaillage = new Cube(x0, x1, y0, y1, z0, z1);
+
+ // Libération mémoire
+ if (nnoe > 0)
+ {
+ free(coo1);
+ free(nomnoe);
+ free(numnoe);
+ free(nufano);
+ }
+
+ // ##################################################################################################
+ // ##################################################################################################
+ //
+ // A C Q U I S I T I O N D E S M A I L L E S
+ //
+ // ##################################################################################################
+ // ##################################################################################################
+
+ for (int itm = (int) POI1; itm <= (int) HEXA20; itm++)
+ {
+ TYPE_MAILLE tm = (TYPE_MAILLE) itm;
+ EFFECTIFS_TYPES[tm] = MEDmeshnEntity(fid, maa, MED_NO_DT, MED_NO_IT, MED_CELL, InstanceMGE(tm), MED_CONNECTIVITY,
+ MED_NODAL, &coordinatechangement, &geotransformation);
+ if (EFFECTIFS_TYPES[tm])
+ acquisitionTYPE_inputMED(tm, EFFECTIFS_TYPES[tm], fid, maa, mdim);
+ }
+
+ // Resize des vecteurs des maps FAMILLES et FAM_TYPES
+ map<int, vector<int> >::iterator IF;
+ for (IF = FAMILLES.begin(); IF != FAMILLES.end(); IF++)
+ {
+ IF->second.resize(tailleFAMILLES[IF->first]);
+ FAM_TYPES[IF->first].resize(tailleFAMILLES[IF->first]);
+ }
+
+ for (int itm = (int) POI1; itm <= (int) HEXA20; itm++)
+ nombreMaillesMaillage += EFFECTIFS_TYPES[(TYPE_MAILLE) itm];
+
+ // ##################################################################################################
+ // ##################################################################################################
+ //
+ // A C Q U I S I T I O N D E S G R O U P E S
+ // D E M A I L L E S E T D E N O E U D S
+ //
+ // ##################################################################################################
+ // ##################################################################################################
+
+ // =============================================================================================
+ // Chargement des groupes dans GM et GN
+ // =============================================================================================
+
+ string nomGM;
+ vector<int> vfam;
+ map<string, vector<int> >::iterator iterGRO;
+
+ int cptGM = 0;
+ for (iterGRO = GROUPES_MAILLES.begin(); iterGRO != GROUPES_MAILLES.end(); iterGRO++)
+ {
+ nomGM = iterGRO->first;
+ vfam = iterGRO->second;
+ cptGM++;
+ map<TYPE_MAILLE, int> effectifGroupeType;
+ for (unsigned int i = 0; i < vfam.size(); i++)
+ {
+ int numf = vfam[i];
+ // Parcours simultané des vecteurs FAMILLES[numf] et FAM_TYPES[numfam] pour obtention du num local
+ // et du type des mailles de la famille numf
+ for (unsigned int imaille = 0; imaille < FAMILLES[numf].size(); imaille++)
+ {
+ TYPE_MAILLE tm = FAM_TYPES[numf][imaille];
+ int nl = FAMILLES[numf][imaille];
+ GM[nomGM][tm].push_back(nl);
+ effectifGroupeType[tm]++;
+ }
+ }
+
+ // Resize d'un GM
+ for (map<TYPE_MAILLE, vector<int> >::iterator I = GM[nomGM].begin(); I != GM[nomGM].end(); I++)
+ {
+ TYPE_MAILLE tm = I->first;
+ GM[nomGM][tm].resize(effectifGroupeType[tm]);
+ sort(GM[nomGM][tm].begin(), GM[nomGM][tm].end());
+ }
+ }
+
+ int cptGN = 0;
+ for (iterGRO = GROUPES_NOEUDS.begin(); iterGRO != GROUPES_NOEUDS.end(); iterGRO++)
+ {
+ nomGM = iterGRO->first;
+ vfam = iterGRO->second;
+ cptGN++;
+ int cptNoeudsGN = 0;
+ for (unsigned int i = 0; i < vfam.size(); i++)
+ {
+ int numf = vfam[i];
+ // Parcours vecteurs FAMILLES_NOEUDS[numf]
+ for (unsigned int inoeud = 0; inoeud < FAMILLES_NOEUDS[numf].size(); inoeud++)
+ {
+ GN[nomGM].push_back(FAMILLES_NOEUDS[numf][inoeud]);
+ cptNoeudsGN++;
+ }
+ }
+ GN[nomGM].resize(cptNoeudsGN);
+ sort(GN[nomGM].begin(), GN[nomGM].end());
+ }
+
+ MEDfileClose(fid);
+ // cout << "Fin procédure inputMED" << endl << endl;
+}
+
+void Maillage::acquisitionTYPE_inputMED(TYPE_MAILLE TYPE, int nTYPE, med_idt fid, char maa[MED_NAME_SIZE + 1],
+ med_int mdim)
+{
+
+ // int taille, numeromaille, numeroFamille;
+ int numeroFamille;
+ string line, IDmaille, IDnoeud, typeMaille;
+ // char str[MED_SNAME_SIZE + 1]; // Conteneur pour un nom de maille
+ // bool rejetMaille;
+ med_int tTYPE = (med_int) Nnoeuds(TYPE);
+ char *nomTYPE = (char*) malloc(MED_SNAME_SIZE * nTYPE + 1);
+ med_int *numTYPE = (med_int*) malloc(sizeof(med_int) * nTYPE);
+ med_int *famTYPE = (med_int*) malloc(sizeof(med_int) * nTYPE);
+
+ //med_int *conTYPE = (med_int*) malloc(sizeof(med_int)*tTYPE*nTYPE);
+ CNX[TYPE] = (int*) malloc(sizeof(int) * tTYPE * nTYPE);
+
+ med_bool inomTYPE, inumTYPE, ifamTYPE;
+ med_geometry_type typeBanaliseMED = InstanceMGE(TYPE);
+
+ if (MEDmeshElementRd(fid, maa, MED_NO_DT, MED_NO_IT, MED_CELL, typeBanaliseMED, MED_NODAL, MED_FULL_INTERLACE,
+ CNX[TYPE], &inomTYPE, nomTYPE, &inumTYPE, numTYPE, &ifamTYPE, famTYPE) < 0)
+ ERREUR("Error while reading elements");
+
+ // Conversion HL
+ conversionCNX(CNX[TYPE], TYPE, nTYPE);
+
+ // CON[TYPE].resize(tTYPE * nTYPE);
+ // for (int i = 0; i < tTYPE * nTYPE; i++)
+ // CON[TYPE][i] = (int) *(conTYPE + i);
+ // CNX[TYPE] = (int*) malloc(sizeof(int) * tTYPE * nTYPE);
+ // for (int i = 0; i < tTYPE * nTYPE; i++)
+ // *(CNX[TYPE] + i) = (int) *(conTYPE + i);
+
+ for (int i = 0; i < nTYPE; i++)
+ {
+ numeroFamille = (int) *(famTYPE + i);
+ FAMILLES[numeroFamille].push_back(i);
+ tailleFAMILLES[numeroFamille]++;
+ FAM_TYPES[numeroFamille].push_back(TYPE);
+
+ // Chargement des numéros de mailles
+ // if (inumTYPE)
+ // NUM_MAILLES[TYPE].push_back(*(numTYPE + i));
+ // else
+ // NUM_MAILLES[TYPE].push_back(NGLOBAL(TYPE, i));
+
+ }
+ // NUM_MAILLES[TYPE].resize(nTYPE);
+
+ // if (inomTYPE)
+ // {
+ // char str[MED_SNAME_SIZE + 1];
+ // for (int imaille = 0; imaille < nTYPE; imaille++)
+ // {
+ // strncpy(str, nomTYPE + imaille * MED_SNAME_SIZE, MED_SNAME_SIZE);
+ // str[MED_SNAME_SIZE] = '\0';
+ // IDS_MAILLES[TYPE].push_back((string) str);
+ // }
+ // }
+ // else if (inumTYPE)
+ // {
+ // for (int imaille = 0; imaille < nTYPE; imaille++)
+ // {
+ // int nummaille = *(numTYPE + imaille);
+ // IDS_MAILLES[TYPE].push_back((string) "M" + int2string(nummaille));
+ // }
+ // }
+ // else
+ // {
+ // for (int imaille = 0; imaille < nTYPE; imaille++)
+ // {
+ // IDS_MAILLES[TYPE].push_back((string) "M" + int2string(imaille + 1));
+ // }
+ // }
+ // IDS_MAILLES[TYPE].resize(nTYPE);
+}
+
+void Maillage::outputMED(std::string fichierMED)
+{
+ // int i, j, k;
+ int nTYPE, tTYPE;
+ string line, s, stype, nomnoeud;
+ // med_err ret = 0; // Code retour
+ // int ig, jg;
+ // cout << endl << endl << "Début procédure outputMED, fichier " << fichierMED << endl;
+
+ // Sortie sur erreur en cas de maillage sans noeuds
+ if (nombreNoeudsMaillage <= 0)
+ {
+ ERREUR("This mesh does not contain any node\n"); /* cout << "Maillage sans noeuds" << endl; */
+ }
+
+ // ########################################################################
+ // Ouverture du fichier MED et création du maillage
+ // ########################################################################
+
+ // Ouverture du fichier MED en création
+ med_idt fid = MEDfileOpen(string2char(fichierMED), MED_ACC_CREAT);
+ if (fid < 0)
+ {
+ ERREUR("Error MEDfileOpen\n");
+ cout << "Error MEDfileOpen" << endl;
+ }
+
+ // Création du maillage
+ char maa[MED_NAME_SIZE + 1]; // Nom du maillage de longueur maxi MED_NAME_SIZE
+ strcpy(maa, string2char(ID));
+
+ med_int mdim; // Dimension du maillage
+ if (dimensionMaillage == 0)
+ {
+ mdim = 3;
+ cout << "ATTENTION, dimension 3 attribuée par défaut!" << endl;
+ }
+ else
+ mdim = dimensionMaillage;
+ med_int spacedim = 3;
+ if (dimensionEspace)
+ spacedim = dimensionEspace;
+
+ //med_int profil[2] = { 2, 3 };
+ char desc[MED_COMMENT_SIZE + 1]; // Description du maillage
+ strcpy(desc, string2char(ID));
+ med_mesh_type type = MED_UNSTRUCTURED_MESH;
+// cerr << "maa=" << maa << endl;
+// cerr << "spacedim=" << spacedim << endl;
+// cerr << "mdim=" << mdim << endl;
+// cerr << "type=" << type << endl;
+// cerr << "axisname=" << axisname << endl;
+// cerr << "unitname=" << unitname << endl;
+ if (MEDmeshCr(fid, maa, spacedim, mdim, type, desc, "s", MED_SORT_DTIT, MED_CARTESIAN, axisname, unitname) < 0)
+ {
+ ERREUR("Error MEDmeshCr");
+ cout << "Error MEDmeshCr" << endl;
+ }
+
+ // ============================= CREATION FAMILLE ZERO
+ char nomfam[MED_NAME_SIZE + 1];
+ med_int numfam;
+ // char attdes[MED_COMMENT_SIZE + 1];
+ // med_int natt, attide, attval;
+ int ngro;
+ // char gro[MED_LNAME_SIZE + 1];
+
+ strcpy(nomfam, "FAMILLE_0");
+ numfam = 0;
+ if (MEDfamilyCr(fid, maa, nomfam, numfam, 0, MED_NO_GROUP) < 0)
+ ERREUR("Error MEDfamilyCr (create family 0)");
+
+ // ########################################################################
+ // GROUPES DE NOEUDS
+ // ########################################################################
+
+ int nGroupesNoeuds = GN.size();
+
+ vector<vector<int> > ETIQUETTES_N;
+ ETIQUETTES_N.resize(nombreNoeudsMaillage);
+ vector<unsigned int> INDEX_N;
+ INDEX_N.resize(GN.size());
+ vector<string> NOMSFAM;
+ vector<vector<int> > ETIQFAM;
+ int cptNOMFAM = 0;
+ map<string, int> NUMFAMETIQ; // clé = étiquette - valeur = numéros de familles
+
+
+ if (nGroupesNoeuds)
+ {
+
+ // Pérennisation d'un ordre sur les GM dans le vecteur NOMS_GROUPES_MAILLES
+ vector<string> NOMS_GROUPES_NOEUDS;
+ for (map<string, vector<int> >::iterator ITGN = GN.begin(); ITGN != GN.end(); ITGN++)
+ {
+ string nomGN = ITGN->first;
+ NOMS_GROUPES_NOEUDS.push_back(nomGN);
+ }
+ NOMS_GROUPES_NOEUDS.resize(GN.size());
+
+ // Tri des vecteurs de noeuds de GN
+ for (unsigned int ig = 0; ig < NOMS_GROUPES_NOEUDS.size(); ig++)
+ sort(GN[NOMS_GROUPES_NOEUDS[ig]].begin(), GN[NOMS_GROUPES_NOEUDS[ig]].end());
+
+ // Construction des étiquettes (familles)
+
+ // Initialisation des index de groupes
+ for (unsigned int ig = 0; ig < NOMS_GROUPES_NOEUDS.size(); ig++)
+ INDEX_N[ig] = 0;
+
+ for (int k = 1; k <= nombreNoeudsMaillage; k++)
+ { // k: num. global de noeud
+ int tailleEtiquette = 0;
+ string etiq = (string) "";
+ // Boucle sur les groupes
+ for (unsigned int ig = 0; ig < NOMS_GROUPES_NOEUDS.size(); ig++)
+ {
+ if (INDEX_N[ig] < GN[NOMS_GROUPES_NOEUDS[ig]].size())
+ {
+ string nomgroupe = NOMS_GROUPES_NOEUDS[ig];
+ if (k == GN[nomgroupe][INDEX_N[ig]])
+ {
+ // Attention: l'indice 0 dans le vecteur ETIQUETTES correspond
+ // à l'élément (noeud ou maille) de num. global 1
+ // Par ailleurs, le numéro de groupe dans l'étiquette commence à 0
+ ETIQUETTES_N[k - 1].push_back(ig);
+ tailleEtiquette++;
+ etiq += int2string(ig);
+ INDEX_N[ig]++;
+ }
+ }
+ }
+ ETIQUETTES_N[k - 1].resize(tailleEtiquette);
+ // Stockage de l'étiquette dans NOMSFAM ETIQFAM, si pas déjà stockée
+ // bool trouve = false;
+ // for (int i = 0; i < NOMSFAM.size(); i++)
+ // if (NOMSFAM[i] == ((string) "ETIQUETTE_" + etiq))
+ // {
+ // trouve = true;
+ // break;
+ // }
+ if (!NUMFAMETIQ[etiq] && etiq != (string) "")
+ {
+ NOMSFAM.push_back((string) "ETIQN_" + etiq);
+ ETIQFAM.push_back(ETIQUETTES_N[k - 1]);
+ NUMFAMETIQ[etiq] = cptNOMFAM + 1; // Famille de noeuds, num>0
+ cptNOMFAM++;
+ }
+ }
+
+ NOMSFAM.resize(cptNOMFAM);
+ ETIQFAM.resize(cptNOMFAM);
+
+ // Création des familles de noeuds
+ for (unsigned int ifam = 0; ifam < NOMSFAM.size(); ifam++)
+ {
+ strcpy(nomfam, string2char(NOMSFAM[ifam]));
+ // Numéro de famille: ifam+1 (positif pour les noeuds + non nul)
+ numfam = ifam + 1;
+ ngro = ETIQFAM[ifam].size();
+
+ // Noms des groupes de la famille: variable nomsGN
+ char *gro = new char[ngro * MED_LNAME_SIZE + 1];
+ int cptGN = 0;
+ for (unsigned int ign = 0; ign < ETIQFAM[ifam].size(); ign++)
+ {
+ string nomGNcourant = NOMS_GROUPES_NOEUDS[ETIQFAM[ifam][ign]];
+ // ATTENTION! Il faut mettre à la fin de chaque segment un \0 qui est ensuite écrasé
+ // par le premier caractère du champ suivant dans le strcat !!!!
+ if (ign == 0)
+ {
+ // Premier groupe
+ strcpy(gro, string2char(nomGNcourant));
+ for (int jg = nomGNcourant.size(); jg < MED_LNAME_SIZE; jg++)
+ gro[jg] = ' ';
+ gro[MED_LNAME_SIZE] = '\0';
+ }
+ else
+ {
+ strcat(gro, string2char(nomGNcourant));
+ for (int jg = nomGNcourant.size(); jg < MED_LNAME_SIZE; jg++)
+ gro[cptGN * MED_LNAME_SIZE + jg] = ' ';
+ gro[(cptGN + 1) * MED_LNAME_SIZE] = '\0';
+ }
+ cptGN++;
+ }
+
+ // Création de la famille
+ if (MEDfamilyCr(fid, maa, nomfam, numfam, 0, MED_NO_GROUP) < 0)
+ ERREUR("Error MEDfamilyCr");
+ delete gro;
+ }
+
+ }
+
+ // ########################################################################
+ // NOEUDS
+ // ########################################################################
+
+ // float x, y, z;
+
+ med_int nnoe = nombreNoeudsMaillage; // Nombre de noeuds
+ med_float *coo; // Table des coordonnées
+
+ // Noms des coordonnées (variable nomcoo)
+ char* nomcoo = new char[mdim * MED_SNAME_SIZE + 1];
+ string strX = (string) "X";
+ while (strX.size() < MED_SNAME_SIZE)
+ strX += (string) " ";
+ string strY = (string) "Y";
+ while (strY.size() < MED_SNAME_SIZE)
+ strY += (string) " ";
+ string strZ = (string) "Z";
+ while (strZ.size() < MED_SNAME_SIZE)
+ strZ += (string) " ";
+ if (mdim == 3)
+ strcpy(nomcoo, string2char(strX + strY + strZ));
+ else if (mdim == 2)
+ strcpy(nomcoo, string2char(strX + strY));
+ else
+ strcpy(nomcoo, string2char(strX));
+ nomcoo[mdim * MED_SNAME_SIZE] = '\0';
+
+ // Unités des coordonnées (variable unicoo)
+ char* unicoo = new char[mdim * MED_SNAME_SIZE + 1];
+ string strmesure = (string) "SI";
+ while (strmesure.size() < MED_SNAME_SIZE)
+ strmesure += (string) " ";
+ if (mdim == 3)
+ strcpy(unicoo, string2char(strmesure + strmesure + strmesure));
+ else if (mdim == 2)
+ strcpy(unicoo, string2char(strmesure + strmesure));
+ else
+ strcpy(unicoo, string2char(strmesure));
+ unicoo[mdim * MED_SNAME_SIZE] = '\0';
+
+ // Tables des noms, numeros, numeros de familles des noeuds
+ // autant d'elements que de noeuds - les noms ont pout longueur MED_SNAME_SIZE
+ char *nomnoe;
+ med_int *numnoe = NULL;
+ med_int *nufano;
+ med_bool inonoe = MED_FALSE;
+ med_bool inunoe = MED_FALSE;
+
+ // Allocations memoire
+ if (nnoe > 0)
+ {
+ // table des coordonnees - profil : (dimension * nombre de noeuds )
+ coo = (med_float*) calloc(nnoe * mdim, sizeof(med_float));
+
+ // table des des numeros, des numeros de familles des noeuds - profil : (nombre de noeuds)
+ // numnoe = (med_int*) malloc(sizeof(med_int) * nnoe);
+ nufano = (med_int*) malloc(sizeof(med_int) * nnoe);
+
+ // table des noms des noeuds - profil : (nnoe*MED_SNAME_SIZE+1)
+ nomnoe = (char*) ""; // ATTENTION!
+
+ // nomnoe = (char*) malloc(MED_SNAME_SIZE * nnoe + 1);
+ // for (int inoeud = 0; inoeud < IDS_NOEUDS.size(); inoeud++)
+ // {
+ // string nomNoeud = IDS_NOEUDS[inoeud];
+ // if (inoeud == 0)
+ // {
+ // // Premier groupe
+ // strcpy(nomnoe, string2char(nomNoeud));
+ // for (int jg = nomNoeud.size(); jg < MED_SNAME_SIZE; jg++)
+ // nomnoe[jg] = ' ';
+ // nomnoe[MED_SNAME_SIZE] = '\0';
+ // }
+ // else
+ // {
+ // strcat(nomnoe, string2char(nomNoeud));
+ // for (int jg = nomNoeud.size(); jg < MED_SNAME_SIZE; jg++)
+ // nomnoe[inoeud * MED_SNAME_SIZE + jg] = ' ';
+ // nomnoe[(inoeud + 1) * MED_SNAME_SIZE] = '\0';
+ // }
+ // }
+ }
+
+ // Chargement des coordonnées, numéros de familles et numéros de noeuds
+ if (dimensionMaillage == 3)
+ {
+ int i3 = 0;
+ for (int i = 0; i < nnoe; i++)
+ {
+ // coo[i3] = X[i];
+ // coo[i3 + 1] = Y[i];
+ // coo[i3 + 2] = Z[i];
+ // i3 = i3 + 3;
+ coo[i3] = *(XX + i);
+ coo[i3 + 1] = *(YY + i);
+ coo[i3 + 2] = *(ZZ + i);
+ i3 = i3 + 3;
+
+ // Numéros de familles - Le num. global de noeud est i+1
+ if (nGroupesNoeuds)
+ {
+ vector<int> v = ETIQUETTES_N[i];
+ string sv = (string) "";
+ for (unsigned int j = 0; j < v.size(); j++)
+ sv += int2string(v[j]); // Etiquette du noeud au format string
+ // cout << "Noeud " << i + 1 << " : sv=" << sv << endl;
+ *(nufano + i) = (med_int) NUMFAMETIQ[sv];
+ }
+ else
+ *(nufano + i) = (med_int) 0;
+
+ // Numéros de noeuds
+ // *(numnoe + i) = (med_int) NUM_NOEUDS[i];
+ }
+ }
+ else /* dimension 2 */
+ {
+ int i2 = 0;
+ for (int i = 0; i < nnoe; i++)
+ {
+ coo[i2] = *(XX + i);
+ coo[i2 + 1] = *(YY + i);
+ i2 = i2 + 2;
+ // Numéros de familles - Le num. global de noeud est i+1
+ if (nGroupesNoeuds)
+ {
+ vector<int> v = ETIQUETTES_N[i];
+ string sv = (string) "";
+ for (unsigned int j = 0; j < v.size(); j++)
+ sv += int2string(v[j]); // Etiquette du noeud au format string
+ // cout << "Noeud " << i + 1 << " : sv=" << sv << endl;
+ *(nufano + i) = (med_int) NUMFAMETIQ[sv];
+ }
+ else
+ *(nufano + i) = (med_int) 0;
+ // Numéros de noeuds
+ // *(numnoe + i) = (med_int) NUM_NOEUDS[i];
+ }
+ }
+
+ // // Restitution coo
+ // int i3 = 0;
+ // for (int i = 0; i < nnoe; i++)
+ // {
+ // cout << "Noeud " << i << " : " << coo[i3] << " " << coo[i3 + 1] << " " << coo[i3 + 2] << endl;
+ // i3 = i3 + 3;
+ // }
+
+ if (MEDmeshNodeWr(fid, maa, MED_NO_DT, MED_NO_IT, MED_UNDEF_DT, MED_FULL_INTERLACE, nnoe, coo, inonoe, nomnoe,
+ inunoe, numnoe, MED_TRUE, nufano) < 0)
+ {
+ ERREUR("Error MEDmeshNodeWr");
+ cout << "Error MEDmeshNodeWr" << endl;
+ }
+
+ // ########################################################################
+ // GROUPES DE MAILLES
+ // ########################################################################
+
+ int nGroupesMailles = GM.size();
+
+ map<TYPE_MAILLE, vector<vector<int> > > ETIQUETTES_M; // [ tm => [ nl => [ig1, ig2, ... ] ] ]
+ // INDEX_M :
+ // Clé : tm
+ // Valeur : vect. des compteurs par indice de GM dans NOMS_GROUPES_MAILLES
+ map<TYPE_MAILLE, vector<unsigned int> > INDEX_M;
+ NOMSFAM.clear();
+ ETIQFAM.clear();
+ NUMFAMETIQ.clear(); // clé = étiquette - valeur = numéros de familles
+ cptNOMFAM = 0;
+
+ if (nGroupesMailles)
+ {
+
+ // Pérennisation d'un ordre sur les GM dans le vecteur NOMS_GROUPES_MAILLES
+ vector<string> NOMS_GROUPES_MAILLES;
+ for (map<string, map<TYPE_MAILLE, vector<int> > >::iterator ITGM = GM.begin(); ITGM != GM.end(); ITGM++)
+ {
+ string nomGM = ITGM->first;
+ NOMS_GROUPES_MAILLES.push_back(nomGM);
+ }
+ NOMS_GROUPES_MAILLES.resize(GM.size());
+ // Tri des vecteurs d'entiers de GM
+ for (unsigned int ig = 0; ig < NOMS_GROUPES_MAILLES.size(); ig++)
+ {
+ string nomGM = NOMS_GROUPES_MAILLES[ig];
+ for (map<TYPE_MAILLE, vector<int> >::iterator I = GM[nomGM].begin(); I != GM[nomGM].end(); I++)
+ {
+ TYPE_MAILLE tm = I->first;
+ sort(GM[nomGM][tm].begin(), GM[nomGM][tm].end());
+ }
+ }
+
+ // Construction des étiquettes (familles)
+
+ // Initialisation 0 des index de groupes, et resize ETIQUETTES_M[tm]
+ for (int itm = (int) POI1; itm <= (int) HEXA20; itm++)
+ {
+ TYPE_MAILLE tm = (TYPE_MAILLE) itm;
+ if (EFFECTIFS_TYPES[tm])
+ {
+ for (unsigned int ig = 0; ig < NOMS_GROUPES_MAILLES.size(); ig++)
+ INDEX_M[tm].push_back(0);
+ ETIQUETTES_M[tm].resize(EFFECTIFS_TYPES[tm]);
+ }
+ }
+
+ for (int itm = (int) POI1; itm <= (int) HEXA20; itm++)
+ {
+ TYPE_MAILLE tm = (TYPE_MAILLE) itm;
+ int efftm = EFFECTIFS_TYPES[tm];
+ // cout << endl << "*************** coucou ***************" << endl;
+ // cout << "*************** Type " << TM2string(tm) << " effectif = " << efftm << endl;
+ if (efftm)
+ {
+ // cout << "Traitement du type " << TM2string(tm) << endl;
+ for (int nl = 0; nl < efftm; nl++)
+ {
+ // nl = num. local de la maille dans son type
+ // cout << "\tMaille " << TM2string(tm) << " n° " << nl << endl;
+
+ int tailleEtiquette = 0;
+ string etiq = (string) "";
+ // Boucle sur les groupes
+ for (unsigned int ig = 0; ig < NOMS_GROUPES_MAILLES.size(); ig++)
+ {
+ string nomGM = NOMS_GROUPES_MAILLES[ig];
+ // cout << "\t\t" << "Groupe " << nomGM << endl;
+
+ if (INDEX_M[tm][ig] < GM[nomGM][tm].size())
+ {
+ if (nl == GM[nomGM][tm][INDEX_M[tm][ig]])
+ {
+ // Attention: l'indice 0 dans le vecteur ETIQUETTES correspond
+ // à l'élément (noeud ou maille) de num. global 1
+ // Par ailleurs, le numéro de groupe dans l'étiquette commence à 0
+ // cout << "\t\t\t" << "La maille est dans le groupe " << nomGM << endl;
+ ETIQUETTES_M[tm][nl].push_back(ig);
+ tailleEtiquette++;
+ etiq += int2string(ig);
+ INDEX_M[tm][ig]++;
+ // cout << "\t\t\t OK" << endl;
+ }
+ }
+ }
+
+ ETIQUETTES_M[tm][nl].resize(tailleEtiquette);
+ // Stockage de l'étiquette dans NOMSFAM ETIQFAM, si pas déjà stockée
+ // bool trouve = false;
+ // for (int i = 0; i < NOMSFAM.size(); i++)
+ // if (NOMSFAM[i] == ((string) "ETIQUETTE_" + etiq))
+ // {
+ // trouve = true;
+ // break;
+ // }
+
+ if (!NUMFAMETIQ[etiq] && etiq != (string) "")
+ {
+ NOMSFAM.push_back((string) "ETIQM_" + etiq);
+ ETIQFAM.push_back(ETIQUETTES_M[tm][nl]);
+ NUMFAMETIQ[etiq] = -cptNOMFAM - 1; // Famille de mailles, num<0
+ cptNOMFAM++;
+ }
+
+ }
+
+ } // if (efftm)
+ }
+
+ NOMSFAM.resize(cptNOMFAM);
+ ETIQFAM.resize(cptNOMFAM);
+
+ // Création des familles de mailles
+ for (unsigned int ifam = 0; ifam < NOMSFAM.size(); ifam++)
+ {
+ strcpy(nomfam, string2char(NOMSFAM[ifam]));
+ // Numéro de famille: -ifam-1 (négatif pour les mailles, et non nul)
+ numfam = -ifam - 1;
+ ngro = ETIQFAM[ifam].size();
+
+ // Noms des groupes de la famille
+ char* gro = new char[ngro * MED_LNAME_SIZE + 1];
+ int cptGM = 0;
+ for (unsigned int ign = 0; ign < ETIQFAM[ifam].size(); ign++)
+ {
+ string nomGMcourant = NOMS_GROUPES_MAILLES[ETIQFAM[ifam][ign]];
+ // ATTENTION! Il faut mettre à la fin de chaque segment un \0 qui est ensuite écrasé
+ // par le premier caractère du champ suivant dans le strcat !!!!
+ if (ign == 0)
+ {
+ // Premier groupe
+ strcpy(gro, string2char(nomGMcourant));
+ for (int jg = nomGMcourant.size(); jg < MED_LNAME_SIZE; jg++)
+ gro[jg] = ' ';
+ gro[MED_LNAME_SIZE] = '\0';
+ }
+ else
+ {
+ strcat(gro, string2char(nomGMcourant));
+ for (int jg = nomGMcourant.size(); jg < MED_LNAME_SIZE; jg++)
+ gro[cptGM * MED_LNAME_SIZE + jg] = ' ';
+ gro[(cptGM + 1) * MED_LNAME_SIZE] = '\0';
+ }
+ cptGM++;
+ }
+
+ // Création de la famille
+ if (MEDfamilyCr(fid, maa, nomfam, numfam, 1, gro) < 0)
+ ERREUR("Error MEDfamilyCr");
+
+ delete gro;
+ }
+ }
+
+ // ########################################################################
+ // MAILLES
+ // ########################################################################
+ // Appel de la routine ecritureTypeNew
+
+ med_bool inomTYPE = MED_FALSE;
+ med_bool inumTYPE = MED_FALSE;
+
+ med_geometry_type MGE;
+
+ for (int itm = (int) POI1; itm <= (int) HEXA20; itm++)
+ {
+ TYPE_MAILLE tm = (TYPE_MAILLE) itm;
+ if (EFFECTIFS_TYPES[tm])
+ {
+ nTYPE = EFFECTIFS_TYPES[tm];
+ tTYPE = Nnoeuds(tm);
+ MGE = InstanceMGE(tm);
+ stype = TM2string(tm);
+
+ // Noms des mailles
+ // char *nomTYPE = (char*) malloc(MED_SNAME_SIZE * nTYPE + 1);
+ // strcpy(nomTYPE, ""); // ATTENTION!
+
+ char *nomTYPE = (char*)""; // Attention! Ne pas faire strcpy !
+
+ // for (int imaille = 0; imaille < IDS_MAILLES[tm].size(); imaille++)
+ // {
+ // string nomMaille = IDS_MAILLES[tm][imaille];
+ // if (imaille == 0)
+ // {
+ // // Premier groupe
+ // strcpy(nomTYPE, string2char(nomMaille));
+ // for (int jg = nomMaille.size(); jg < MED_SNAME_SIZE; jg++)
+ // nomTYPE[jg] = ' ';
+ // nomTYPE[MED_SNAME_SIZE] = '\0';
+ // }
+ // else
+ // {
+ // strcat(nomTYPE, string2char(nomMaille));
+ // for (int jg = nomMaille.size(); jg < MED_SNAME_SIZE; jg++)
+ // nomTYPE[imaille * MED_SNAME_SIZE + jg] = ' ';
+ // nomTYPE[(imaille + 1) * MED_SNAME_SIZE] = '\0';
+ // }
+ // }
+
+ med_int *numTYPE = NULL; // (med_int*) malloc(sizeof(med_int)*nTYPE);
+
+ med_int *famTYPE = (med_int*) malloc(sizeof(med_int) * nTYPE);
+
+ // med_int *conTYPE = (med_int*) malloc(sizeof(med_int) * tTYPE * nTYPE);
+ // for (int i = 0; i < nTYPE * tTYPE; i++)
+ // *(conTYPE + i) = (med_int) CON[tm][i];
+
+ // Chargement famTYPE
+ if (nGroupesMailles)
+ {
+ // Boucle sur les mailles du type (indice = num. local)
+ for (int nl = 0; nl < nTYPE; nl++)
+ {
+ // Construction de l'étiquette de la maille au format string
+ vector<int> v = ETIQUETTES_M[tm][nl];
+ string sv = (string) "";
+ for (unsigned int j = 0; j < v.size(); j++)
+ sv += int2string(v[j]);
+ // Accès au num. de la famille
+ *(famTYPE + nl) = (med_int) NUMFAMETIQ[sv];
+ } // Boucle sur les mailles du type
+ } // if (nGroupesMailles)
+ else
+ for (int nl = 0; nl < nTYPE; nl++)
+ *(famTYPE + nl) = (med_int) 0;
+
+ // Formatage MED des CNX
+ conversionCNX(CNX[tm], tm, nTYPE);
+
+ // Chargement numTYPE
+ //for (int nl=0; nl<nTYPE; nl++) *(numTYPE+nl) = (med_int) ( NUM_MAILLES[tm][nl] );
+// cerr << "maa=" << maa << endl;
+// cerr << "MGE=" << MGE << endl;
+// cerr << "nTYPE=" << nTYPE << endl;
+// cerr << "inomTYPE=" << inomTYPE << endl;
+// //cerr << "nomTYPE=" << nomTYPE << endl;
+// cerr << "inumTYPE=" << inumTYPE << endl;
+// this->afficheMailles(tm);
+ if (MEDmeshElementWr(fid, maa, MED_NO_DT, MED_NO_IT, MED_UNDEF_DT, MED_CELL, MGE, MED_NODAL,
+ MED_FULL_INTERLACE, nTYPE, CNX[tm], inomTYPE, nomTYPE, inumTYPE, numTYPE, MED_FALSE,
+ famTYPE) < 0)
+ {
+ ERREUR("Error MEDmeshElementWr");
+ cout << "Error MEDmeshElementWr, type " << stype << endl;
+ }
+ if (MEDmeshEntityFamilyNumberWr(fid, maa, MED_NO_DT, MED_NO_IT,
+ MED_CELL, MGE, nTYPE, famTYPE) < 0)
+ {
+ ERREUR("Error MEDmeshEntityFamilyNumberWr");
+ cout << "Error MEDmeshEntityFamilyNumberWr, type " << stype << endl;
+ }
+
+ // free(nomTYPE);
+ // free(numTYPE);
+ free(famTYPE);
+ // free(conTYPE);
+
+ } // Effectif non vide
+ }
+
+ // ########################################################################
+ // Fermeture du fichier MED
+ // ########################################################################
+
+ if (MEDfileClose(fid) < 0)
+ {
+ ERREUR("Error on close MED file\n");
+ cout << "Error on close MED file" << endl;
+ }
+
+ delete unicoo;
+ delete nomcoo;
+
+ // cout << endl << endl << "Fin procédure outputMED" << endl;
+} // outputMED
+
+
+int Maillage::NGLOBAL(TYPE_MAILLE typeMaille, int nlocal)
+{
+ // Attention, les num. globaux commencent à 1, les num. locaux à 0
+ int cpt = 1 + nlocal;
+ for (int itm = (int) POI1; itm < (int) typeMaille; itm++)
+ { // Attention! inférieur strict!
+ TYPE_MAILLE tm = (TYPE_MAILLE) itm;
+ cpt += EFFECTIFS_TYPES[tm];
+ }
+ return cpt;
+}
+
+TYPE_MAILLE Maillage::TYPE(int nglobal)
+{
+ // Attention, les num. globaux commencent à 1, les num. locaux à 0
+ TYPE_MAILLE resultat;
+ int cpt = 0;
+ for (int itm = (int) POI1; itm <= (int) HEXA20; itm++)
+ {
+ TYPE_MAILLE tm = (TYPE_MAILLE) itm;
+ cpt += EFFECTIFS_TYPES[tm];
+ if (nglobal <= cpt)
+ {
+ resultat = tm;
+ break;
+ }
+ }
+ return resultat;
+}
+
+int Maillage::NLOCAL(int nglobal, TYPE_MAILLE tm)
+{
+ // Attention, les num. globaux commencent à 1, les num. locaux à 0
+ int nPOI1 = EFFECTIFS_TYPES[POI1];
+ int nSEG2 = EFFECTIFS_TYPES[SEG2];
+ int nSEG3 = EFFECTIFS_TYPES[SEG3];
+ int nTRIA3 = EFFECTIFS_TYPES[TRIA3];
+ int nTRIA6 = EFFECTIFS_TYPES[TRIA6];
+ int nQUAD4 = EFFECTIFS_TYPES[QUAD4];
+ int nQUAD8 = EFFECTIFS_TYPES[QUAD8];
+ int nTETRA4 = EFFECTIFS_TYPES[TETRA4];
+ int nTETRA10 = EFFECTIFS_TYPES[TETRA10];
+ int nPYRAM5 = EFFECTIFS_TYPES[PYRAM5];
+ int nPYRAM13 = EFFECTIFS_TYPES[PYRAM13];
+ int nPENTA6 = EFFECTIFS_TYPES[PENTA6];
+ int nPENTA15 = EFFECTIFS_TYPES[PENTA15];
+ int nHEXA8 = EFFECTIFS_TYPES[HEXA8];
+ int nHEXA20 = EFFECTIFS_TYPES[HEXA20];
+
+ if (nglobal <= nPOI1)
+ {
+ return nglobal - 1;
+ }
+ else if (nglobal <= nPOI1 + nSEG2)
+ {
+ return nglobal - nPOI1 - 1;
+ }
+ else if (nglobal <= nPOI1 + nSEG2 + nSEG3)
+ {
+ return nglobal - nPOI1 - nSEG2 - 1;
+ }
+ else if (nglobal <= nPOI1 + nSEG2 + nSEG3 + nTRIA3)
+ {
+ return nglobal - nPOI1 - nSEG2 - nSEG3 - 1;
+ }
+ else if (nglobal <= nPOI1 + nSEG2 + nSEG3 + nTRIA3 + nTRIA6)
+ {
+ return nglobal - nPOI1 - nSEG2 - nSEG3 - nTRIA3 - 1;
+ }
+ else if (nglobal <= nPOI1 + nSEG2 + nSEG3 + nTRIA3 + nTRIA6 + nQUAD4)
+ {
+ return nglobal - nPOI1 - nSEG2 - nSEG3 - nTRIA3 - nTRIA6 - 1;
+ }
+ else if (nglobal <= nPOI1 + nSEG2 + nSEG3 + nTRIA3 + nTRIA6 + nQUAD4 + nQUAD8)
+ {
+ return nglobal - nPOI1 - nSEG2 - nSEG3 - nTRIA3 - nTRIA6 - nQUAD4 - 1;
+ }
+ else if (nglobal <= nPOI1 + nSEG2 + nSEG3 + nTRIA3 + nTRIA6 + nQUAD4 + nQUAD8 + nTETRA4)
+ {
+ return nglobal - nPOI1 - nSEG2 - nSEG3 - nTRIA3 - nTRIA6 - nQUAD4 - nQUAD8 - 1;
+ }
+ else if (nglobal <= nPOI1 + nSEG2 + nSEG3 + nTRIA3 + nTRIA6 + nQUAD4 + nQUAD8 + nTETRA4 + nTETRA10)
+ {
+ return nglobal - nPOI1 - nSEG2 - nSEG3 - nTRIA3 - nTRIA6 - nQUAD4 - nQUAD8 - nTETRA4 - 1;
+ }
+ else if (nglobal <= nPOI1 + nSEG2 + nSEG3 + nTRIA3 + nTRIA6 + nQUAD4 + nQUAD8 + nTETRA4 + nTETRA10 + nPYRAM5)
+ {
+ return nglobal - nPOI1 - nSEG2 - nSEG3 - nTRIA3 - nTRIA6 - nQUAD4 - nQUAD8 - nTETRA4 - nTETRA10 - 1;
+ }
+ else if (nglobal <= nPOI1 + nSEG2 + nSEG3 + nTRIA3 + nTRIA6 + nQUAD4 + nQUAD8 + nTETRA4 + nTETRA10 + nPYRAM5
+ + nPYRAM13)
+ {
+ return nglobal - nPOI1 - nSEG2 - nSEG3 - nTRIA3 - nTRIA6 - nQUAD4 - nQUAD8 - nTETRA4 - nTETRA10 - nPYRAM5 - 1;
+ }
+ else if (nglobal <= nPOI1 + nSEG2 + nSEG3 + nTRIA3 + nTRIA6 + nQUAD4 + nQUAD8 + nTETRA4 + nTETRA10 + nPYRAM5
+ + nPYRAM13 + nPENTA6)
+ {
+ return nglobal - nPOI1 - nSEG2 - nSEG3 - nTRIA3 - nTRIA6 - nQUAD4 - nQUAD8 - nTETRA4 - nTETRA10 - nPYRAM5
+ - nPYRAM13 - 1;
+ }
+ else if (nglobal <= nPOI1 + nSEG2 + nSEG3 + nTRIA3 + nTRIA6 + nQUAD4 + nQUAD8 + nTETRA4 + nTETRA10 + nPYRAM5
+ + nPYRAM13 + nPENTA6 + nPENTA15)
+ {
+ return nglobal - nPOI1 - nSEG2 - nSEG3 - nTRIA3 - nTRIA6 - nQUAD4 - nQUAD8 - nTETRA4 - nTETRA10 - nPYRAM5
+ - nPYRAM13 - nPENTA6 - 1;
+ }
+ else if (nglobal <= nPOI1 + nSEG2 + nSEG3 + nTRIA3 + nTRIA6 + nQUAD4 + nQUAD8 + nTETRA4 + nTETRA10 + nPYRAM5
+ + nPYRAM13 + nPENTA6 + nPENTA15 + nHEXA8)
+ {
+ return nglobal - nPOI1 - nSEG2 - nSEG3 - nTRIA3 - nTRIA6 - nQUAD4 - nQUAD8 - nTETRA4 - nTETRA10 - nPYRAM5
+ - nPYRAM13 - nPENTA6 - nPENTA15 - 1;
+ }
+ else if (nglobal <= nPOI1 + nSEG2 + nSEG3 + nTRIA3 + nTRIA6 + nQUAD4 + nQUAD8 + nTETRA4 + nTETRA10 + nPYRAM5
+ + nPYRAM13 + nPENTA6 + nPENTA15 + nHEXA8 + nHEXA20)
+ {
+ return nglobal - nPOI1 - nSEG2 - nSEG3 - nTRIA3 - nTRIA6 - nQUAD4 - nQUAD8 - nTETRA4 - nTETRA10 - nPYRAM5
+ - nPYRAM13 - nPENTA6 - nPENTA15 - nHEXA8 - 1;
+ }
+ else
+ ERREUR("method NLOCAL: unknown type");
+ return 0;
+}
+
+/*!
+ * Suppression de mailles dans un type :
+ *
+ * - Contraction de la connectivité concernée
+ * - Réécriture des GM avec les nouveaux numéros locaux des éléments du type concerné
+ * - Mise à jour nombreMaillesMaillage
+ *
+ * Les noeuds ne sont pas affectés.
+ */
+void Maillage::eliminationMailles(TYPE_MAILLE tm, vector<int> listeMaillesSuppr)
+{
+ map<int, int> TABLE_NL; // Table des num. locaux dans le type tm
+
+ cout << "Method eliminationMailles, listeMaillesSuppr.size()=" << listeMaillesSuppr.size() << endl;
+
+ // ************* Modification de la connectivité du type concerné
+
+ int* CNX2;
+ int nNoeudsType = Nnoeuds(tm);
+ int tailleCNX2 = nNoeudsType * (EFFECTIFS_TYPES[tm] - listeMaillesSuppr.size());
+ CNX2 = (int*) malloc(sizeof(int) * tailleCNX2);
+ // Recopie sélective des connectivités
+ int isuppr = 0; // indice dans listeMaillesSuppr
+ int ih2 = 0; // nouveau numéro local ( remarque: ih2 = ih1 - isuppr )
+ for (int ih1 = 0; ih1 < EFFECTIFS_TYPES[tm]; ih1++)
+ {
+ if (listeMaillesSuppr[isuppr] != ih1)
+ {
+ for (int jh1 = 0; jh1 < nNoeudsType; jh1++)
+ *(CNX2 + nNoeudsType * ih2 + jh1) = *(CNX[tm] + nNoeudsType * ih1 + jh1);
+ ih2++;
+ }
+ else
+ isuppr++;
+ }
+ free(CNX[tm]);
+ CNX[tm] = CNX2;
+
+ // ************* Construction de la table de correspondance des NL dans le type concerné
+ unsigned int offset = 0;
+ for (int i = 0; i < EFFECTIFS_TYPES[tm]; i++)
+ {
+ if (offset < listeMaillesSuppr.size())
+ {
+ if (i < listeMaillesSuppr[offset])
+ TABLE_NL[i] = i - offset;
+ else if (i == listeMaillesSuppr[offset])
+ {
+ TABLE_NL[i] = -1; // Element à supprimer
+ offset++;
+ }
+ }
+ else
+ TABLE_NL[i] = i - offset;
+ }
+
+ // Contrôle
+ if (offset != listeMaillesSuppr.size())
+ {
+ ERREUR("Incoherent offset, method eliminationMailles");
+ exit(0);
+ }
+
+ // ************* Mise à jour du type concerné dans les GM
+ for (map<string, map<TYPE_MAILLE, vector<int> > >::iterator I = GM.begin(); I != GM.end(); I++)
+ {
+ string nomGM = I->first;
+
+ if (GM[nomGM][tm].size())
+ {
+ //cout << "GM[" << nomGM <<"][" << tm << "].size()=" << GM[nomGM][tm].size() << endl;
+ vector<int> mailles = GM[nomGM][tm];
+ vector<int> mailles2; //mailles2.resize(mailles.size()-listeMaillesSuppr.size());
+ unsigned int cptMailles = 0;
+ for (unsigned int i = 0; i < mailles.size(); i++)
+ {
+ int nl2 = TABLE_NL[mailles[i]];
+ if (nl2 != -1)
+ {
+ mailles2.push_back(nl2);
+ cptMailles++;
+ }
+ }
+
+ GM[nomGM][tm].clear();
+ mailles2.resize(cptMailles);
+ GM[nomGM][tm] = mailles2;
+
+ }
+ }
+
+ // ************* Mise à jour des effectifs
+
+ EFFECTIFS_TYPES[tm] = EFFECTIFS_TYPES[tm] - listeMaillesSuppr.size();
+ nombreMaillesMaillage = nombreMaillesMaillage - listeMaillesSuppr.size();
+
+ TABLE_NL.clear();
+}
+
