src/MULTIPR/MULTIPR_Elements.cxx

   1 // Project MULTIPR, IOLS WP1.2.1 - EDF/CS
   2 // Partitioning/decimation module for the SALOME v3.2 platform
   3
   4 /**
   5  * \file    MULTIPR_Elements.cxx
   6  *
   7  * \brief   see MULTIPR_Elements.hxx
   8  *
   9  * \author  Olivier LE ROUX - CS, Virtual Reality Dpt
  10  *
  11  * \date    01/2007
  12  */
  13
  14 //*****************************************************************************
  15 // Includes section
  16 //*****************************************************************************
  17
  18 #include "MULTIPR_Elements.hxx"
  19 #include "MULTIPR_Nodes.hxx"
  20 #include "MULTIPR_Exceptions.hxx"
  21
  22 #include <iostream>
  23 #include <set>
  24 #include <map>
  25
  26 using namespace std;
  27
  28
  29 namespace multipr
  30 {
  31
  32
  33 //*****************************************************************************
  34 // Class Elements implementation
  35 //*****************************************************************************
  36
  37 Elements::Elements()
  38 {
  39     mId       = NULL;
  40     mFamIdent = NULL;
  41     mNames    = NULL;
  42     mCon      = NULL;
  43
  44     reset();
  45 }
  46
  47
  48 Elements::~Elements()
  49 {
  50     reset();
  51 }
  52
  53
  54 void Elements::reset()
  55 {
  56     mNum           = 0;
  57     mEntity        = MED_MAILLE;
  58     mGeom          = MED_NONE;
  59     mNumNodesByElt = 0;
  60     mDim           = 0;
  61
  62     if (mId != NULL)       { delete[] mId;       mId       = NULL; }
  63     if (mFamIdent != NULL) { delete[] mFamIdent; mFamIdent = NULL; }
  64     if (mNames != NULL)    { delete[] mNames;    mNames    = NULL; }
  65     if (mCon != NULL)      { delete[] mCon;      mCon      = NULL; }
  66
  67     mSetOfNodes.clear();
  68
  69     mFlagPrintAll = false;
  70 }
  71
  72
  73 med_int Elements::getFamilyIdentifier(med_int pIndex) const
  74 {
  75     if ((pIndex < 0) || (pIndex >= mNum)) throw IndexOutOfBoundsException("", __FILE__, __LINE__);
  76
  77     return mFamIdent[pIndex];
  78 }
  79
  80
  81 const med_int* Elements::getConnectivity(int pIndex) const
  82 {
  83     if ((pIndex < 0) || (pIndex >= mNum)) throw IndexOutOfBoundsException("", __FILE__, __LINE__);
  84
  85     return mCon + mNumNodesByElt * pIndex;
  86 }
  87
  88
  89 void Elements::getCoordinates(med_int pIndexElt, const Nodes* pNodes, med_float* pCoo, int pFirst) const
  90 {
  91     if ((pIndexElt < 0) || (pIndexElt >= mNum)) throw IndexOutOfBoundsException("", __FILE__, __LINE__);
  92     if (pNodes == NULL) throw NullArgumentException("", __FILE__, __LINE__);
  93     if (pCoo == NULL) throw NullArgumentException("", __FILE__, __LINE__);
  94
  95     // get the list of nodes of the element
  96     const med_int* con = getConnectivity(pIndexElt);
  97
  98     med_float* destCoo = pCoo;
  99     int size = sizeof(med_float) * mDim;
 100
 101     // for each node of the element
 102     int n = (mNumNodesByElt < pFirst) ? mNumNodesByElt : pFirst;
 103     for (int i = 0 ; i < n ; i++)
 104     {
 105         // get index of node (MED index start at 1)
 106         med_int indexNode = con[i] - 1;
 107
 108         // get coordinates of this node
 109         const med_float* srcCoo = pNodes->getCoordinates(indexNode);
 110
 111         // copy coordinates to destCoo
 112         memcpy(destCoo, srcCoo, size);
 113
 114         // prepare next point
 115         destCoo += mDim;
 116     }
 117 }
 118
 119
 120 Elements* Elements::extractSubSet(const set<med_int>& pSetIndices) const
 121 {
 122     Elements* subset = new Elements();
 123
 124     //---------------------------------------------------------------------
 125     // Copy parameters
 126     //---------------------------------------------------------------------
 127     subset->mNum           = pSetIndices.size();
 128     subset->mEntity        = mEntity;
 129     subset->mGeom          = mGeom;          // e.g. 310 for a TETRA10
 130     subset->mNumNodesByElt = mNumNodesByElt; // e.g. 10 for a TETRA10
 131     subset->mDim           = mDim;           // e.g. 3 for a TETRA10
 132
 133     //---------------------------------------------------------------------
 134     // Allocate arrays
 135     //---------------------------------------------------------------------
 136     subset->mFamIdent     = new med_int[subset->mNum];
 137     subset->mCon          = new med_int[mNumNodesByElt * subset->mNum];
 138
 139     //---------------------------------------------------------------------
 140     // Copy subset of familys id and connectivity.
 141     //---------------------------------------------------------------------
 142     med_int* destCon = subset->mCon;
 143     set<med_int>::iterator itSet = pSetIndices.begin();
 144     for (int itElt = 0 ; itElt < subset->mNum; itElt++)
 145     {
 146         med_int srcIndex = (*itSet) - 1; // MED index start at 1
 147         subset->mFamIdent[itElt] = mFamIdent[srcIndex];
 148
 149         med_int* srcCon = mCon + srcIndex * mNumNodesByElt;
 150         memcpy(destCon, srcCon, sizeof(med_int) * mNumNodesByElt);
 151
 152         destCon += mNumNodesByElt;
 153         itSet++;
 154     }
 155
 156     //---------------------------------------------------------------------
 157     // Copy subset of identifiers if necessary
 158     //---------------------------------------------------------------------
 159     if (isIdentifiers())
 160     {
 161         itSet = pSetIndices.begin();
 162         subset->mId = new med_int[subset->mNum];
 163         for (int itElt = 0 ; itElt < subset->mNum; itElt++)
 164         {
 165             med_int srcIndex = (*itSet) - 1; // MED index start at 1
 166             subset->mId[itElt] = mId[srcIndex];
 167
 168             itSet++;
 169         }
 170     }
 171
 172     //---------------------------------------------------------------------
 173     // Copy subset of names if necessary
 174     //---------------------------------------------------------------------
 175     if (isNames())
 176     {
 177         itSet = pSetIndices.begin();
 178         subset->mNames = new char[MED_TAILLE_PNOM * subset->mNum + 1];
 179         char* destPtr = subset->mNames;
 180         for (int itElt = 0 ; itElt < subset->mNum; itElt++)
 181         {
 182             med_int srcIndex = (*itSet) - 1; // MED index start at 1
 183             char* srcPtr = mNames + srcIndex * MED_TAILLE_PNOM;
 184             memcpy(destPtr, srcPtr, MED_TAILLE_PNOM);
 185
 186             destPtr += MED_TAILLE_PNOM;
 187             itSet++;
 188         }
 189         subset->mNames[MED_TAILLE_PNOM * subset->mNum] = '\0';
 190     }
 191
 192     return subset;
 193 }
 194
 195
 196 const set<med_int>& Elements::getSetOfNodes()
 197 {
 198     // lazy get: test if mSetOfNodes has already been built
 199     if (mSetOfNodes.size() == 0)
 200     {
 201         buildSetOfNodes();
 202     }
 203
 204     return mSetOfNodes;
 205 }
 206
 207
 208 set<med_int> Elements::getSetOfFamilies() const
 209 {
 210     // set of families is empty at the beginning
 211     set<med_int> setOfFamilies;
 212
 213     // for each element, add its family to the set
 214     for (int itElt = 0 ; itElt < mNum ; itElt++)
 215     {
 216         setOfFamilies.insert(mFamIdent[itElt]);
 217     }
 218
 219     return setOfFamilies;
 220 }
 221
 222
 223 void Elements::remap()
 224 {
 225     // build set of nodes if necessary
 226     if (mSetOfNodes.size() == 0)
 227     {
 228         buildSetOfNodes();
 229     }
 230
 231     // build the map for indices convertion
 232     map<med_int, med_int> mapOldIndexToNewIndex;
 233     med_int newIndex = 1; // MED index start at 1
 234     for (set<med_int>::iterator itSet = mSetOfNodes.begin(); itSet != mSetOfNodes.end() ; itSet++)
 235     {
 236         med_int oldIndex = (*itSet);
 237         mapOldIndexToNewIndex.insert(make_pair(oldIndex, newIndex));
 238         newIndex++;
 239     }
 240
 241     // for each node referenced by this set of elements
 242     for (int itNode = 0, size = mNum * mNumNodesByElt ; itNode < size ; itNode++)
 243     {
 244         // convert old index to new index (remap)
 245         mCon[itNode] = mapOldIndexToNewIndex[mCon[itNode]];
 246     }
 247
 248     buildSetOfNodes();
 249 }
 250
 251
 252 void Elements::buildSetOfNodes()
 253 {
 254     if (mSetOfNodes.size() != 0)
 255     {
 256         mSetOfNodes.clear();
 257     }
 258
 259     // for each node referenced by this set of elements
 260     for (int itNode = 0, size = mNum * mNumNodesByElt ; itNode < size ; itNode++)
 261     {
 262         // add the node to the set
 263         mSetOfNodes.insert(mCon[itNode]);
 264     }
 265 }
 266
 267
 268 void Elements::readMED(
 269     med_idt               pMEDfile,
 270     char*                 pMeshName,
 271     med_int               pMeshDim,
 272     med_entite_maillage   pEntity,
 273     med_geometrie_element pGeom)
 274 {
 275     if (pMEDfile == 0) throw IOException("", __FILE__, __LINE__);
 276     if (pMeshName == NULL) throw NullArgumentException("", __FILE__, __LINE__);
 277     if ((pMeshDim < 1) || (pMeshDim > 3)) throw IllegalArgumentException("", __FILE__, __LINE__);
 278
 279     reset();
 280
 281     mEntity        = pEntity;
 282     mGeom          = pGeom;
 283     mNumNodesByElt = mGeom % 100;
 284     mDim           = mGeom / 100;
 285
 286     mNum = MEDnEntMaa(
 287         pMEDfile,
 288         pMeshName,
 289         MED_CONN,  // type of information requested = CONNECTIVITY
 290         pEntity,
 291         pGeom,
 292         MED_NOD);  // nodal connectivity
 293
 294     if (mNum < 0) throw IOException("i/o error while reading information about elements in MED file", __FILE__, __LINE__);
 295
 296     mCon      = new med_int[mNumNodesByElt * mNum];
 297     mNames    = new char[MED_TAILLE_PNOM * mNum + 1];
 298     mId       = new med_int[mNum];
 299     mFamIdent = new med_int[mNum];
 300     med_booleen isNames;
 301     med_booleen isIdentifiers;
 302
 303     med_err ret = MEDelementsLire(
 304         pMEDfile,
 305         pMeshName,
 306         pMeshDim,
 307         mCon,
 308         MED_FULL_INTERLACE,
 309         mNames,
 310         &isNames,
 311         mId,
 312         &isIdentifiers,
 313         mFamIdent,
 314         mNum,
 315         mEntity,
 316         mGeom,
 317         MED_NOD); // NODAL CONNECTIVITY
 318
 319     if (ret != 0) throw IOException("i/o error while reading elements in MED file", __FILE__, __LINE__);
 320
 321     if (!isNames)
 322     {
 323         delete[] mNames;
 324         mNames = NULL;
 325     }
 326
 327     if (!isIdentifiers)
 328     {
 329         delete[] mId;
 330         mId = NULL;
 331     }
 332 }
 333
 334
 335 void Elements::writeMED(med_idt pMEDfile, char* pMeshName, med_int pMeshDim)
 336 {
 337     if (pMEDfile == 0) throw IOException("", __FILE__, __LINE__);
 338     if (pMeshName == NULL) throw NullArgumentException("", __FILE__, __LINE__);
 339     if (strlen(pMeshName) > MED_TAILLE_NOM) throw IllegalArgumentException("", __FILE__, __LINE__);
 340     if ((pMeshDim < 1) || (pMeshDim > 3)) throw IllegalArgumentException("", __FILE__, __LINE__);
 341
 342     // special case: if no elements => do nothing
 343     if (mNum == 0) return;
 344
 345     med_err ret = MEDelementsEcr(
 346         pMEDfile,
 347         pMeshName,
 348         pMeshDim,
 349         mCon,
 350         MED_FULL_INTERLACE,
 351         mNames,
 352         isNames()?MED_VRAI:MED_FAUX,
 353         mId,
 354         isIdentifiers()?MED_VRAI:MED_FAUX,
 355         mFamIdent,
 356         mNum,
 357         mEntity,
 358         mGeom,
 359         MED_NOD); // NODAL CONNECTIVITY
 360
 361     if (ret != 0) throw IOException("i/o error while writing elements in MED file", __FILE__, __LINE__);
 362 }
 363
 364
 365 ostream& operator<<(ostream& pOs, Elements& pE)
 366 {
 367     char strEntity[16];
 368     switch (pE.mEntity)
 369     {
 370         case MED_MAILLE: strcpy(strEntity, "MED_MAILLE"); break;
 371         case MED_FACE:   strcpy(strEntity, "MED_FACE"); break;
 372         case MED_ARETE:  strcpy(strEntity, "MED_ARETE"); break;
 373         case MED_NOEUD:  strcpy(strEntity, "MED_NOEUD"); break;
 374         default:         strcpy(strEntity, "UNKNOWN"); break;
 375     }
 376
 377     pOs << "Elements: " << endl;
 378     pOs << "    #number  =" << pE.mNum << endl;
 379     pOs << "    Entity   =" << strEntity << endl;
 380     pOs << "    Geom     =" << pE.mGeom << endl;
 381     pOs << "    Has names?" << (pE.isNames()?"yes":"no") << endl;
 382     pOs << "    Has id   ?" << (pE.isIdentifiers()?"yes":"no") << endl;
 383
 384     {
 385         set<med_int> setOfFam = pE.getSetOfFamilies();
 386         if (setOfFam.size() == 0)
 387         {
 388             pOs << "    Families: #fam=0" << endl;
 389         }
 390         else
 391         {
 392             set<med_int>::iterator itFam = setOfFam.end();
 393             itFam--;
 394             pOs << "    Families: #fam=" << setOfFam.size() << " id_min=" << (*(setOfFam.begin())) << " id_max=" << (*itFam) << endl;
 395
 396             if (pE.mFlagPrintAll)
 397             {
 398                 for (int i = 0 ; i < pE.mNum; i++)
 399                 {
 400                     pOs << "        Elt " << (i + 1) << ": " << pE.mFamIdent[i] << endl;
 401                 }
 402             }
 403         }
 404     }
 405
 406     {
 407         set<med_int> setOfNodes = pE.getSetOfNodes();
 408         if (setOfNodes.size() == 0)
 409         {
 410             pOs << "    Connectivity: #nodes=0" << endl;
 411         }
 412         else
 413         {
 414             set<med_int>::iterator itNode = setOfNodes.end();
 415             itNode--;
 416             pOs << "    Connectivity: #nodes=" << setOfNodes.size() << " id_min=" << (*(setOfNodes.begin())) << " id_max=" << (*itNode) << endl;
 417
 418             if (pE.mFlagPrintAll)
 419             {
 420                 for (int i = 0 ; i < pE.mNum ; i++)
 421                 {
 422                     pOs << "        Elt " << (i + 1) << ": ";
 423                     for (int j = 0 ; j < pE.mNumNodesByElt ; j++)
 424                     {
 425                         pOs << pE.mCon[i * pE.mNumNodesByElt + j] << " ";
 426                     }
 427                     pOs << endl;
 428                 }
 429             }
 430         }
 431     }
 432
 433     if (pE.mFlagPrintAll)
 434     {
 435
 436         if (pE.isIdentifiers())
 437         {
 438             pOs << "    Num (identifier): " << endl;
 439             for (int i = 0 ; i < pE.mNum; i++)
 440             {
 441                 pOs << "        Elt " << (i + 1) << ": " << pE.mId[i] << " " << endl;
 442             }
 443         }
 444
 445         if (pE.isNames())
 446         {
 447             pE.mNames[MED_TAILLE_PNOM * pE.mNum] = '\0';
 448             pOs << "    Names: |" << pE.mNames << "|" << endl;
 449         }
 450
 451     }
 452
 453     return pOs;
 454 }
 455
 456
 457 } // namespace  multipr
 458
 459 // EOF