src/MULTIPR/MULTIPR_Nodes.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_Nodes.cxx
   6  *
   7  * \brief   see MULTIPR_Nodes.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_Nodes.hxx"
  19 #include "MULTIPR_Exceptions.hxx"
  20
  21 #include <iostream>
  22
  23 using namespace std;
  24
  25
  26 namespace multipr
  27 {
  28
  29
  30 //*****************************************************************************
  31 // Class Nodes implementation
  32 //*****************************************************************************
  33
  34 Nodes::Nodes()
  35 {
  36     mId           = NULL;
  37     mFamIdent     = NULL;
  38     mNames        = NULL;
  39     mCoo          = NULL;
  40     mNamesCoo     = NULL;
  41     mNamesUnitCoo = NULL;
  42
  43     reset();
  44 }
  45
  46
  47 Nodes::~Nodes()
  48 {
  49     reset();
  50 }
  51
  52
  53 void Nodes::reset()
  54 {
  55     mNum         = 0;
  56     mDim         = 0;
  57     mCoordSystem = MED_CART;
  58
  59     if (mId           != NULL) { delete[] mId;           mId           = NULL; }
  60     if (mFamIdent     != NULL) { delete[] mFamIdent;     mFamIdent     = NULL; }
  61     if (mNames        != NULL) { delete[] mNames;        mNames        = NULL; }
  62     if (mCoo          != NULL) { delete[] mCoo;          mCoo          = NULL; }
  63     if (mNamesCoo     != NULL) { delete[] mNamesCoo;     mNamesCoo     = NULL; }
  64     if (mNamesUnitCoo != NULL) { delete[] mNamesUnitCoo; mNamesUnitCoo = NULL; }
  65
  66     mFlagPrintAll = false;
  67 }
  68
  69
  70 const med_float* Nodes::getCoordinates(med_int pIndexNode) const
  71 {
  72     if ((pIndexNode < 0) || (pIndexNode >= mNum)) throw IndexOutOfBoundsException("", __FILE__, __LINE__);
  73
  74     return mCoo + pIndexNode * mDim;
  75 }
  76
  77
  78 med_int Nodes::getFamIdent(med_int pIndexNode) const
  79 {
  80     if ((pIndexNode < 0) || (pIndexNode >= mNum)) throw IndexOutOfBoundsException("", __FILE__, __LINE__);
  81
  82     return mFamIdent[pIndexNode];
  83 }
  84
  85
  86 void Nodes::getBBox(med_float pMin[3], med_float pMax[3]) const
  87 {
  88     //---------------------------------------------------------------------
  89     // Special case: no nodes => bbox = [0 ; 0] x [0 ; 0] x [0 ; 0]
  90     //---------------------------------------------------------------------
  91     if (mNum == 0)
  92     {
  93         for (int itDim = 0 ; itDim < mDim ; itDim++)
  94         {
  95             pMin[itDim] = med_float(0.0);
  96             pMax[itDim] = med_float(0.0);
  97         }
  98
  99         return;
 100     }
 101
 102     //---------------------------------------------------------------------
 103     // Compute axis-aligned bounding box
 104     //---------------------------------------------------------------------
 105     for (int itDim = 0 ; itDim < mDim ; itDim++)
 106     {
 107         pMin[itDim] = numeric_limits<med_float>::max();
 108         pMax[itDim] = -pMin[itDim];
 109     }
 110     for (int itNode = 0 ; itNode < mNum ; itNode++)
 111     {
 112         for (int itDim = 0 ; itDim < mDim ; itDim++)
 113         {
 114             med_float coord = mCoo[itNode * mDim + itDim];
 115             if (coord < pMin[itDim]) pMin[itDim] = coord;
 116             if (coord > pMax[itDim]) pMax[itDim] = coord;
 117         }
 118     }
 119 }
 120
 121
 122 set<med_int> Nodes::getSetOfFamilies() const
 123 {
 124     set<med_int> setOfFamilies;
 125
 126     // for each node, ad its family to the set
 127     for (int itNode = 0 ; itNode < mNum ; itNode++)
 128     {
 129         setOfFamilies.insert(mFamIdent[itNode]);
 130     }
 131
 132     return setOfFamilies;
 133 }
 134
 135
 136 Nodes* Nodes::extractSubSet(const set<med_int>& pSetIndices) const
 137 {
 138     Nodes* subset = new Nodes();
 139
 140     subset->mNum         = pSetIndices.size();
 141     subset->mDim         = mDim;
 142     subset->mCoordSystem = mCoordSystem;
 143
 144     //---------------------------------------------------------------------
 145     // Allocate arrays
 146     //---------------------------------------------------------------------
 147     subset->mFamIdent     = new med_int[subset->mNum];
 148     subset->mCoo          = new med_float[subset->mDim * subset->mNum];
 149     subset->mNamesCoo     = new char[subset->mDim * MED_TAILLE_PNOM + 1];
 150     subset->mNamesUnitCoo = new char[subset->mDim * MED_TAILLE_PNOM + 1];
 151
 152     memcpy(subset->mNamesCoo, mNamesCoo, subset->mDim * MED_TAILLE_PNOM + 1);
 153     memcpy(subset->mNamesUnitCoo, mNamesUnitCoo, subset->mDim * MED_TAILLE_PNOM + 1);
 154
 155     //---------------------------------------------------------------------
 156     // Copy subset of familys id and coords.
 157     //---------------------------------------------------------------------
 158     set<med_int>::iterator itSet = pSetIndices.begin();
 159     for (int i = 0 ; i < subset->mNum; i++)
 160     {
 161
 162         med_int srcIndex = (*itSet) - 1; // MED index start at 1
 163         subset->mFamIdent[i] = mFamIdent[srcIndex];
 164
 165         med_float* srcCoo = mCoo + srcIndex * mDim;
 166         med_float* destCoo = subset->mCoo + i * subset->mDim;
 167         for (int itDim = 0 ; itDim < mDim ; itDim++)
 168         {
 169             destCoo[itDim] = srcCoo[itDim];
 170         }
 171
 172         itSet++;
 173     }
 174
 175     //---------------------------------------------------------------------
 176     // Copy subset of identifiers if necessary
 177     //---------------------------------------------------------------------
 178     if (isIdentifiers())
 179     {
 180         itSet = pSetIndices.begin();
 181         subset->mId = new med_int[subset->mNum];
 182         for (int i = 0 ; i < subset->mNum; i++)
 183         {
 184             med_int srcIndex = (*itSet) - 1; // MED index start at 1
 185             subset->mId[i] = mId[srcIndex];
 186
 187             itSet++;
 188         }
 189     }
 190
 191     //---------------------------------------------------------------------
 192     // Copy subset of names if necessary
 193     //---------------------------------------------------------------------
 194     if (isNames())
 195     {
 196         subset->mNames = new char[MED_TAILLE_PNOM * subset->mNum + 1];
 197         char* destPtr = subset->mNames;
 198         itSet = pSetIndices.begin();
 199         for (int i = 0 ; i < subset->mNum; i++)
 200         {
 201             med_int srcIndex = (*itSet) - 1; // MED index start at 1
 202             char* srcPtr = mNames + srcIndex * MED_TAILLE_PNOM;
 203             memcpy(destPtr, srcPtr, MED_TAILLE_PNOM);
 204             destPtr += MED_TAILLE_PNOM;
 205
 206             itSet++;
 207         }
 208         subset->mNames[MED_TAILLE_PNOM * subset->mNum] = '\0';
 209     }
 210
 211     return subset;
 212 }
 213
 214
 215 void Nodes::readMED(med_idt pMEDfile, char* pMeshName, med_int pDim)
 216 {
 217     if (pMEDfile == 0) throw IOException("", __FILE__, __LINE__);
 218     if (pMeshName == NULL) throw NullArgumentException("", __FILE__, __LINE__);
 219     if (pDim != 3) throw IllegalArgumentException("", __FILE__, __LINE__);
 220
 221     reset();
 222
 223     mDim = pDim;
 224     mNum = MEDnEntMaa(
 225         pMEDfile,
 226         pMeshName,
 227         MED_COOR,
 228         MED_NOEUD,
 229         med_geometrie_element(0),
 230         med_connectivite(0));
 231
 232     if (mNum <= 0) throw IOException("", __FILE__, __LINE__);
 233
 234     mId           = new med_int[mNum];
 235     mFamIdent     = new med_int[mNum];
 236     mNames        = new char[MED_TAILLE_PNOM * mNum + 1];
 237     mCoo          = new med_float[mDim * mNum];
 238     mNamesCoo     = new char[mDim * MED_TAILLE_PNOM + 1];
 239     mNamesUnitCoo = new char[mDim * MED_TAILLE_PNOM + 1];
 240
 241     mNames[0] = '\0';
 242     mNamesCoo[0] = '\0';
 243     mNamesUnitCoo[0] = '\0';
 244
 245     med_booleen isIdentifiers;
 246     med_booleen isNames;
 247
 248     med_err ret = MEDnoeudsLire(
 249         pMEDfile,
 250         pMeshName,
 251         mDim,
 252         mCoo,
 253         MED_FULL_INTERLACE,
 254         &mCoordSystem,
 255         mNamesCoo,
 256         mNamesUnitCoo,
 257         mNames,
 258         &isNames,
 259         mId,
 260         &isIdentifiers,
 261         mFamIdent,
 262         mNum);
 263
 264     if (ret != 0) throw IOException("", __FILE__, __LINE__);
 265
 266     // check if coordinates system is CARTESIAN
 267     if (mCoordSystem != MED_CART) throw IllegalStateException("", __FILE__, __LINE__);
 268
 269     if (!isNames)
 270     {
 271         delete[] mNames;
 272         mNames = NULL;
 273     }
 274
 275     if (!isIdentifiers)
 276     {
 277         delete[] mId;
 278         mId = NULL;
 279     }
 280 }
 281
 282
 283 void Nodes::writeMED(med_idt pMEDfile, char* pMeshName) const
 284 {
 285     if (pMEDfile == 0) throw IOException("", __FILE__, __LINE__);
 286     if (pMeshName == NULL) throw NullArgumentException("", __FILE__, __LINE__);
 287     if (strlen(pMeshName) > MED_TAILLE_NOM) throw IllegalArgumentException("", __FILE__, __LINE__);
 288     if ((mDim < 1) || (mDim > 3)) throw IllegalStateException("", __FILE__, __LINE__);
 289     if (mFamIdent == NULL) throw IllegalStateException("", __FILE__, __LINE__);
 290     if (mCoo == NULL) throw IllegalStateException("", __FILE__, __LINE__);
 291     if (mNamesCoo == NULL) throw IllegalStateException("", __FILE__, __LINE__);
 292     if (mNamesUnitCoo == NULL) throw IllegalStateException("", __FILE__, __LINE__);
 293
 294     // special case: if no nodes => do nothing
 295     if (mNum == 0) return;
 296
 297     med_err ret = MEDnoeudsEcr(
 298         pMEDfile,
 299         pMeshName,
 300         mDim,
 301         mCoo,
 302         MED_FULL_INTERLACE,
 303         mCoordSystem,
 304         mNamesCoo,
 305         mNamesUnitCoo,
 306         mNames,
 307         isNames()?MED_VRAI:MED_FAUX,
 308         mId,
 309         isIdentifiers()?MED_VRAI:MED_FAUX,
 310         mFamIdent,
 311         mNum);
 312
 313     if (ret != 0) throw IOException("i/o error while writing nodes", __FILE__, __LINE__);
 314
 315 }
 316
 317
 318 ostream& operator<<(ostream& pOs, Nodes& pN)
 319 {
 320     char strCoordSystem[16];
 321     switch (pN.mCoordSystem)
 322     {
 323         case MED_CART:  strcpy(strCoordSystem, "CARTESIAN"); break;
 324         case MED_CYL:   strcpy(strCoordSystem, "CYLINDRIC"); break;
 325         case MED_SPHER: strcpy(strCoordSystem, "SPHERIC"); break;
 326         default:        strcpy(strCoordSystem, "UNKNOWN"); break;
 327     }
 328
 329     pOs << "Nodes: " << endl;
 330     pOs << "    #number      =" << pN.mNum << endl;
 331     pOs << "    Dimension    =" << pN.mDim << endl;
 332     pOs << "    Coord. system=" << strCoordSystem << endl;
 333     pOs << "    Has names    ?" << (pN.isNames()?"yes":"no") << endl;
 334     pOs << "    Has id       ?" << (pN.isIdentifiers()?"yes":"no") << endl;
 335     pOs << "    Axis names   =" << "|" << pN.mNamesCoo << "|" << endl;
 336     pOs << "    Unit axis    =" << "|" << pN.mNamesUnitCoo << "|" << endl;
 337
 338     {
 339         set<med_int> setOfFam = pN.getSetOfFamilies();
 340         if (setOfFam.size() == 0)
 341         {
 342             pOs << "    Families: #fam=0" << endl;
 343         }
 344         else
 345         {
 346             set<med_int>::iterator itFam = setOfFam.end();
 347             itFam--;
 348             pOs << "    Families: #fam=" << setOfFam.size() << " id_min=" << (*(setOfFam.begin())) << " id_max=" << (*itFam) << endl;
 349         }
 350
 351         if (pN.mFlagPrintAll)
 352         {
 353             for (int itNode = 0 ; itNode < pN.mNum; itNode++)
 354             {
 355                 pOs << "        Node " << (itNode+1) << ": " << pN.mFamIdent[itNode] << endl;
 356             }
 357         }
 358     }
 359
 360     med_float bboxMin[3], bboxMax[3];
 361     pN.getBBox(bboxMin, bboxMax);
 362     pOs << "    BBox: [" << bboxMin[0] << " ; " << bboxMax[0] << "] x [" << bboxMin[1] << " ; " << bboxMax[1] << "] x [" << bboxMin[2] << " ; " << bboxMax[2] << "]" << endl;
 363
 364     if (pN.mFlagPrintAll)
 365     {
 366         pOs << "    Coordinates: " << endl;
 367         for (int itNode = 0 ; itNode < pN.mNum ; itNode++)
 368         {
 369             pOs << "        Node " << (itNode+1) << ": ";
 370             for (int itDim = 0 ; itDim < pN.mDim ; itDim++)
 371             {
 372                 pOs << pN.mCoo[itNode * pN.mDim + itDim] << " ";
 373             }
 374             pOs << endl;
 375         }
 376
 377         if (pN.isIdentifiers())
 378         {
 379             pOs << "    Num: " << endl;
 380             for (int itNode = 0 ; itNode < pN.mNum; itNode++)
 381             {
 382                 pOs << "        Node " << (itNode+1) << ": " << pN.mId[itNode] << endl;
 383             }
 384         }
 385
 386         if (pN.isNames())
 387         {
 388             pN.mNames[MED_TAILLE_PNOM * pN.mNum] = '\0';
 389             pOs << "    Names: |" << pN.mNames << "|" << endl;
 390         }
 391
 392     }
 393
 394     return pOs;
 395 }
 396
 397
 398 } // namespace  multipr
 399
 400 // EOF