Back to index

salome-smesh  6.5.0
Public Member Functions | Public Attributes
MESHCUT::Maillage Class Reference

#include <MeshCut_Maillage.hxx>

Collaboration diagram for MESHCUT::Maillage:
Collaboration graph
[legend]

List of all members.

Public Member Functions

 Maillage (std::string _ID)
virtual ~Maillage ()
void creationGMtype (TYPE_MAILLE tm, std::string nomGMtype)
void afficheMailles (TYPE_MAILLE tm)
void listeMaillesType (TYPE_MAILLE tm)
void listeMaillesTousTypes ()
void listeMaillesParGM ()
void listeMaillesGM (std::string nomGM)
void listeNoeuds ()
void listeNoeudsGN (std::string nomGN)
void listeNoeudsGNordonne (std::string nomGN)
std::vector< float > G (int i, TYPE_MAILLE tm)
float distanceNoeudMaille (int ngnoeud, int imaille, TYPE_MAILLE tm)
int noeudVoisin (int ngnoeud, int imaille, TYPE_MAILLE tm)
 Retourne le ng du noeud le plus proche de ngnoeud dans la maille imaille du type tm.
float distanceNoeudNoeud (int ng1, int ng2)
void inputMED (std::string fichierMED)
void outputMED (std::string fichierMED)
void outputMEDold (std::string fichierMED)
void inputHL (std::string fichierHL)
void outputHL (std::string fichierHL)
void outputVRML (std::string ficVRML, float rNoeuds, char *renduAretes, char *renduFaces, float transparence)
int NGLOBAL (TYPE_MAILLE typeMaille, int nlocal)
int NLOCAL (int nglobal, TYPE_MAILLE tm)
TYPE_MAILLE TYPE (int nglobal)
void eliminationMailles (TYPE_MAILLE typeMaille, std::vector< int > listeMaillesSuppr)
 Suppression de mailles dans un type :
void acquisitionTYPE_inputMED (TYPE_MAILLE TYPE, int nTYPE, med_idt fid, char maa[MED_NAME_SIZE+1], med_int mdim)
bool NoeudDansHEXA8 (int n, int n0, int n1, int n2, int n3, int n4, int n5, int n6, int n7, float epsilon)
bool NoeudDansPENTA6 (int n, int n0, int n1, int n2, int n3, int n4, int n5, float epsilon)
bool NoeudDansPYRAM5 (int n, int n0, int n1, int n2, int n3, int n4, float epsilon)
bool NoeudDansTETRA4 (int n, int n1, int n2, int n3, int n4, float epsilon)
bool NoeudDansQUAD4 (int n, int n1, int n2, int n3, int n4, float epsilon)
bool NoeudDansTRIA3 (int n, int n1, int n2, int n3, float epsilon)
double volumeTETRA (int n1, int n2, int n3, int n4)
double aireTRIA (int n1, int n2, int n3)
double DET3 (int n1, int n2, int n3)
double DET2 (int n1, int n2)
void * chargeEnveloppesCubiques (TYPE_MAILLE tm)
void * chargeEnveloppesCarrees (TYPE_MAILLE tm)
bool noeudDeMaille (int ngnoeud, int i, TYPE_MAILLE tm)
bool NoeudDansMaille3D (int n, int i, TYPE_MAILLE tm, float epsilon)
bool NoeudDansMaille2D (int n, int i, TYPE_MAILLE tm, float epsilon)
bool NoeudDansEnveloppeMaille2D (int n, int i, TYPE_MAILLE tm, float epsilon)
bool NoeudDansEnveloppeMaille3D (int n, int i, TYPE_MAILLE tm, float epsilon)
void * afficheEnveloppesCubiques (TYPE_MAILLE tm)
void * afficheEnveloppesCarrees (TYPE_MAILLE tm)
std::vector< int > noeudsGeomCommuns (int i1, TYPE_MAILLE tm1, int i2, TYPE_MAILLE tm2)
void creationGMresidu ()
float longueurMoyenne ()

Public Attributes

std::map< int, std::vector< int > > FAMILLES
std::map< int, std::vector
< TYPE_MAILLE > > 
FAM_TYPES
std::map< int, std::vector< int > > FAMILLES_NOEUDS
std::map< std::string,
std::vector< int > > 
GROUPES_MAILLES
std::map< std::string,
std::vector< int > > 
GROUPES_NOEUDS
std::map< int, int > tailleFAMILLES
std::map< std::string, int > tailleGROUPES
std::map< TYPE_MAILLE,
std::vector< int > > 
RESIDU
std::string ID
int nombreNoeudsMaillage
int nombreMaillesMaillage
class CubeenveloppeMaillage
int dimensionMaillage
int dimensionEspace
char axisname [3 *MED_SNAME_SIZE+1]
char unitname [3 *MED_SNAME_SIZE+1]
float * XX
float * YY
float * ZZ
std::map< TYPE_MAILLE, int > EFFECTIFS_TYPES
std::map< TYPE_MAILLE, int * > CNX
std::map< TYPE_MAILLE, float * > EC
std::map< std::string,
std::map< TYPE_MAILLE,
std::vector< int > > > 
GM
std::map< std::string,
std::vector< int > > 
GN

Detailed Description

Definition at line 31 of file MeshCut_Maillage.hxx.


Constructor & Destructor Documentation

Maillage::Maillage ( std::string  _ID)

Definition at line 33 of file MeshCut_Maillage.cxx.

{
  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 ( ) [virtual]

Definition at line 45 of file MeshCut_Maillage.cxx.

{
}

Member Function Documentation

void Maillage::acquisitionTYPE_inputMED ( TYPE_MAILLE  TYPE,
int  nTYPE,
med_idt  fid,
char  maa[MED_NAME_SIZE+1],
med_int  mdim 
)

Definition at line 856 of file MeshCut_Maillage.cxx.

{

  //  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);
}

Here is the call graph for this function:

Definition at line 58 of file MeshCut_Maillage.cxx.

{
  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;
    }
}

Here is the call graph for this function:

double MESHCUT::Maillage::aireTRIA ( int  n1,
int  n2,
int  n3 
)
void Maillage::creationGMtype ( TYPE_MAILLE  tm,
std::string  nomGMtype 
)

Definition at line 49 of file MeshCut_Maillage.cxx.

{
  //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());
}
double MESHCUT::Maillage::DET2 ( int  n1,
int  n2 
)
double MESHCUT::Maillage::DET3 ( int  n1,
int  n2,
int  n3 
)
float Maillage::distanceNoeudMaille ( int  ngnoeud,
int  imaille,
TYPE_MAILLE  tm 
)

Definition at line 179 of file MeshCut_Maillage.cxx.

{
  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;
}

Here is the call graph for this function:

float Maillage::distanceNoeudNoeud ( int  ng1,
int  ng2 
)

Definition at line 230 of file MeshCut_Maillage.cxx.

{
  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::eliminationMailles ( TYPE_MAILLE  tm,
std::vector< int >  listeMaillesSuppr 
)

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.

Definition at line 1700 of file MeshCut_Maillage.cxx.

{
  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();
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::vector< float > Maillage::G ( int  i,
TYPE_MAILLE  tm 
)

Definition at line 158 of file MeshCut_Maillage.cxx.

{
  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;
}

Here is the call graph for this function:

void MESHCUT::Maillage::inputHL ( std::string  fichierHL)
void Maillage::inputMED ( std::string  fichierMED)

Definition at line 267 of file MeshCut_Maillage.cxx.

{
  //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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Maillage::listeMaillesGM ( std::string  nomGM)

Definition at line 108 of file MeshCut_Maillage.cxx.

{
  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;
        }
    }
}

Here is the call graph for this function:

Definition at line 101 of file MeshCut_Maillage.cxx.

{
  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);
}

Definition at line 92 of file MeshCut_Maillage.cxx.

{
  for (int itm = (int) POI1; itm <= (int) HEXA20; itm++)
    {
      TYPE_MAILLE tm = (TYPE_MAILLE) itm;
      listeMaillesType(tm);
    }
}

Definition at line 81 of file MeshCut_Maillage.cxx.

{
  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;
}

Definition at line 133 of file MeshCut_Maillage.cxx.

{
  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)

Definition at line 141 of file MeshCut_Maillage.cxx.

{
  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)

Definition at line 149 of file MeshCut_Maillage.cxx.

{
  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;
}
int Maillage::NGLOBAL ( TYPE_MAILLE  typeMaille,
int  nlocal 
)

Definition at line 1568 of file MeshCut_Maillage.cxx.

{
  // 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;
}
int Maillage::NLOCAL ( int  nglobal,
TYPE_MAILLE  tm 
)

Definition at line 1598 of file MeshCut_Maillage.cxx.

{
  // 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;
}

Here is the call graph for this function:

bool MESHCUT::Maillage::NoeudDansEnveloppeMaille2D ( int  n,
int  i,
TYPE_MAILLE  tm,
float  epsilon 
)
bool MESHCUT::Maillage::NoeudDansEnveloppeMaille3D ( int  n,
int  i,
TYPE_MAILLE  tm,
float  epsilon 
)
bool MESHCUT::Maillage::NoeudDansHEXA8 ( int  n,
int  n0,
int  n1,
int  n2,
int  n3,
int  n4,
int  n5,
int  n6,
int  n7,
float  epsilon 
)
bool MESHCUT::Maillage::NoeudDansMaille2D ( int  n,
int  i,
TYPE_MAILLE  tm,
float  epsilon 
)
bool MESHCUT::Maillage::NoeudDansMaille3D ( int  n,
int  i,
TYPE_MAILLE  tm,
float  epsilon 
)
bool MESHCUT::Maillage::NoeudDansPENTA6 ( int  n,
int  n0,
int  n1,
int  n2,
int  n3,
int  n4,
int  n5,
float  epsilon 
)
bool MESHCUT::Maillage::NoeudDansPYRAM5 ( int  n,
int  n0,
int  n1,
int  n2,
int  n3,
int  n4,
float  epsilon 
)
bool MESHCUT::Maillage::NoeudDansQUAD4 ( int  n,
int  n1,
int  n2,
int  n3,
int  n4,
float  epsilon 
)
bool MESHCUT::Maillage::NoeudDansTETRA4 ( int  n,
int  n1,
int  n2,
int  n3,
int  n4,
float  epsilon 
)
bool MESHCUT::Maillage::NoeudDansTRIA3 ( int  n,
int  n1,
int  n2,
int  n3,
float  epsilon 
)
bool MESHCUT::Maillage::noeudDeMaille ( int  ngnoeud,
int  i,
TYPE_MAILLE  tm 
)
std::vector<int> MESHCUT::Maillage::noeudsGeomCommuns ( int  i1,
TYPE_MAILLE  tm1,
int  i2,
TYPE_MAILLE  tm2 
)
int Maillage::noeudVoisin ( int  ngnoeud,
int  imaille,
TYPE_MAILLE  tm 
)

Retourne le ng du noeud le plus proche de ngnoeud dans la maille imaille du type tm.

Definition at line 204 of file MeshCut_Maillage.cxx.

{
  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;
}

Here is the call graph for this function:

void MESHCUT::Maillage::outputHL ( std::string  fichierHL)
void Maillage::outputMED ( std::string  fichierMED)

Definition at line 934 of file MeshCut_Maillage.cxx.

{
  // 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

Here is the call graph for this function:

Here is the caller graph for this function:

void MESHCUT::Maillage::outputMEDold ( std::string  fichierMED)
void MESHCUT::Maillage::outputVRML ( std::string  ficVRML,
float  rNoeuds,
char *  renduAretes,
char *  renduFaces,
float  transparence 
)
TYPE_MAILLE Maillage::TYPE ( int  nglobal)

Definition at line 1580 of file MeshCut_Maillage.cxx.

{
  // 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;
}
double MESHCUT::Maillage::volumeTETRA ( int  n1,
int  n2,
int  n3,
int  n4 
)

Member Data Documentation

char MESHCUT::Maillage::axisname[3 *MED_SNAME_SIZE+1]

Definition at line 64 of file MeshCut_Maillage.hxx.

Definition at line 78 of file MeshCut_Maillage.hxx.

Definition at line 62 of file MeshCut_Maillage.hxx.

Definition at line 61 of file MeshCut_Maillage.hxx.

Definition at line 81 of file MeshCut_Maillage.hxx.

Definition at line 72 of file MeshCut_Maillage.hxx.

Definition at line 59 of file MeshCut_Maillage.hxx.

std::map<int, std::vector<TYPE_MAILLE> > MESHCUT::Maillage::FAM_TYPES

Definition at line 38 of file MeshCut_Maillage.hxx.

std::map<int, std::vector<int> > MESHCUT::Maillage::FAMILLES

Definition at line 37 of file MeshCut_Maillage.hxx.

std::map<int, std::vector<int> > MESHCUT::Maillage::FAMILLES_NOEUDS

Definition at line 41 of file MeshCut_Maillage.hxx.

std::map<std::string, std::map<TYPE_MAILLE, std::vector<int> > > MESHCUT::Maillage::GM

Definition at line 84 of file MeshCut_Maillage.hxx.

std::map<std::string, std::vector<int> > MESHCUT::Maillage::GN

Definition at line 85 of file MeshCut_Maillage.hxx.

std::map<std::string, std::vector<int> > MESHCUT::Maillage::GROUPES_MAILLES

Definition at line 44 of file MeshCut_Maillage.hxx.

std::map<std::string, std::vector<int> > MESHCUT::Maillage::GROUPES_NOEUDS

Definition at line 45 of file MeshCut_Maillage.hxx.

std::string MESHCUT::Maillage::ID

Definition at line 55 of file MeshCut_Maillage.hxx.

Definition at line 57 of file MeshCut_Maillage.hxx.

Definition at line 56 of file MeshCut_Maillage.hxx.

std::map<TYPE_MAILLE, std::vector<int> > MESHCUT::Maillage::RESIDU

Definition at line 52 of file MeshCut_Maillage.hxx.

Definition at line 48 of file MeshCut_Maillage.hxx.

std::map<std::string, int> MESHCUT::Maillage::tailleGROUPES

Definition at line 49 of file MeshCut_Maillage.hxx.

char MESHCUT::Maillage::unitname[3 *MED_SNAME_SIZE+1]

Definition at line 65 of file MeshCut_Maillage.hxx.

Definition at line 67 of file MeshCut_Maillage.hxx.

Definition at line 68 of file MeshCut_Maillage.hxx.

Definition at line 69 of file MeshCut_Maillage.hxx.


The documentation for this class was generated from the following files: