src/MULTIPR/MULTIPR_Family.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_Family.cxx
   6  *
   7  * \brief   see MULTIPR_Family.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_Family.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 Attributs implementation
  32 //*****************************************************************************
  33
  34 Attributs::Attributs()
  35 {
  36     mId   = NULL;
  37     mVal  = NULL;
  38     mDesc = NULL;
  39
  40     reset();
  41 }
  42
  43
  44 Attributs::~Attributs()
  45 {
  46     reset();
  47 }
  48
  49
  50 Attributs& Attributs::operator=(const Attributs& pAttr)
  51 {
  52     if (this != &pAttr) // check for self-assignement
  53     {
  54         reset();
  55
  56         mNum = pAttr.mNum;
  57
  58         if (mNum < 0) throw IllegalStateException("", __FILE__, __LINE__);
  59
  60         if (pAttr.mId != NULL)
  61         {
  62             mId = new med_int[mNum];
  63             memcpy(mId, pAttr.mId, sizeof(med_int) * mNum);
  64         }
  65
  66         if (pAttr.mVal != NULL)
  67         {
  68             mVal = new med_int[mNum];
  69             memcpy(mVal, pAttr.mVal, sizeof(med_int) * mNum);
  70         }
  71
  72         if (pAttr.mDesc != NULL)
  73         {
  74             mDesc = new char[MED_TAILLE_DESC * mNum + 1];
  75             memcpy(mDesc, pAttr.mDesc, MED_TAILLE_DESC * mNum + 1);
  76         }
  77     }
  78
  79     return *this;
  80 }
  81
  82
  83 void Attributs::reset()
  84 {
  85     mNum = 0;
  86
  87     if (mId   != NULL) { delete[] mId;   mId   = NULL; }
  88     if (mVal  != NULL) { delete[] mVal;  mVal  = NULL; }
  89     if (mDesc != NULL) { delete[] mDesc; mDesc = NULL; }
  90 }
  91
  92
  93 ostream& operator<<(ostream& pOs, Attributs& pA)
  94 {
  95     if (pA.mNum == 0)
  96     {
  97         pOs << "NONE" << endl;
  98     }
  99     else
 100     {
 101         pOs << endl << "        #attr=" << pA.mNum << endl;
 102
 103         if (pA.mId != NULL)
 104         {
 105             pOs << "        Id  =[";
 106             for (int i = 0 ; i < pA.mNum ; i++)
 107             {
 108                 pOs << pA.mId[i] << " ";
 109             }
 110             pOs << "]" << endl;
 111         }
 112         else
 113         {
 114             pOs << "        Id  =NULL" << endl;
 115         }
 116
 117         if (pA.mVal != NULL)
 118         {
 119             pOs << "        Val =[";
 120             for (int i = 0 ; i < pA.mNum ; i++)
 121             {
 122                 pOs << pA.mVal[i] << " ";
 123             }
 124             pOs << "]" << endl;
 125         }
 126         else
 127         {
 128             pOs << "        Val =NULL";
 129         }
 130
 131         if (pA.mDesc != NULL)
 132         {
 133             pOs << "        Desc=|" << pA.mDesc << "|" << endl;
 134         }
 135         else
 136         {
 137             pOs << "        Desc=NULL" << endl;
 138         }
 139     }
 140
 141     return pOs;
 142 }
 143
 144
 145 //*****************************************************************************
 146 // Class Family implementation
 147 //*****************************************************************************
 148
 149 Family::Family()
 150 {
 151     reset();
 152 }
 153
 154
 155 Family::~Family()
 156 {
 157     reset();
 158 }
 159
 160
 161 void Family::reset()
 162 {
 163     mName[0]       = '\0';
 164     mId            = 0;
 165     mStrNameGroups = "";
 166
 167     mElt.clear();
 168     mNameGroups.clear();
 169     mAttributs.reset();
 170
 171     mIsFamilyOfNodes = true;
 172
 173     mFlagPrintAll = false;
 174 }
 175
 176
 177 void Family::insertElt(med_int pIndexElt)
 178 {
 179     if (pIndexElt < 1) throw new IllegalArgumentException("", __FILE__, __LINE__);
 180
 181     mElt.insert(pIndexElt);
 182 }
 183
 184
 185 void Family::buildGroups(vector<Group*>& pGroups, map<string, Group*>& pGroupNameToGroup) const
 186 {
 187     // pGroups / pGroupNameToGroup can be empty or not
 188
 189     // for each group in this family
 190     for (unsigned itGroup = 0 ; itGroup < mNameGroups.size() ; itGroup++)
 191     {
 192         const string& keyName = mNameGroups[itGroup];
 193
 194         // check if the group already exist
 195         map<string, Group*>::iterator it = pGroupNameToGroup.find(keyName);
 196
 197         Group* group = NULL;
 198         if (it != pGroupNameToGroup.end())
 199         {
 200             // the group already exists
 201             group = (*it).second;
 202         }
 203         else
 204         {
 205             // a new group have been identified: create a new entry
 206             group = new Group();
 207             group->setName(keyName);
 208             group->setIsGroupOfNodes(isFamilyOfNodes());
 209
 210             pGroups.push_back(group);
 211             pGroupNameToGroup.insert(make_pair(keyName, group));
 212         }
 213
 214         // add all elements of the this family to the group
 215         for (set<med_int>::iterator itElt = mElt.begin() ; itElt != mElt.end() ; itElt++)
 216         {
 217             group->insertElt(*itElt);
 218         }
 219
 220     }
 221 }
 222
 223
 224 Family* Family::extractGroup(const char* pGroupName)
 225 {
 226     Family* family = new Family();
 227
 228     strcpy(family->mName, mName);
 229     family->mId = mId;
 230     family->mAttributs = mAttributs;
 231
 232     if (pGroupName == NULL)
 233     {
 234         family->mStrNameGroups = mStrNameGroups;
 235         family->mNameGroups = mNameGroups;
 236     }
 237     else
 238     {
 239         if (strlen(pGroupName) > MED_TAILLE_LNOM) throw IllegalArgumentException("", __FILE__, __LINE__);
 240         if (strlen(pGroupName) == 0) throw IllegalArgumentException("", __FILE__, __LINE__);
 241
 242         if (strstr(mStrNameGroups.c_str(), pGroupName) == 0)
 243         {
 244             // pGroupName found in the list of groups => just keep pGroupName
 245             family->mStrNameGroups = mStrNameGroups;
 246             family->mNameGroups = mNameGroups;
 247         }
 248         else
 249         {
 250             // pGroupName not found in the current list of groups
 251             // probably not a group of the same nature => keep all the groups
 252             family->mStrNameGroups = pGroupName;
 253             family->mNameGroups.push_back(pGroupName);
 254         }
 255     }
 256
 257     return family;
 258 }
 259
 260
 261 void Family::readMED(med_idt pMEDfile, char* pMeshName, med_int pIndex)
 262 {
 263     if (pMEDfile == 0) throw IOException("", __FILE__, __LINE__);
 264     if (pMeshName == NULL) throw NullArgumentException("", __FILE__, __LINE__);
 265     if (strlen(pMeshName) > MED_TAILLE_NOM) throw IllegalArgumentException("", __FILE__, __LINE__);
 266     if (pIndex < 1) throw IllegalArgumentException("", __FILE__, __LINE__);
 267
 268     reset();
 269
 270     med_int numGroups = MEDnGroupe(pMEDfile, pMeshName, pIndex);
 271
 272     if (numGroups < 0) throw IOException("i/o error while reading number of groups in MED file", __FILE__, __LINE__);
 273
 274     med_int numAttr = MEDnAttribut(pMEDfile, pMeshName, pIndex);
 275
 276     med_int* attrId   = new med_int[numAttr];
 277     med_int* attrVal  = new med_int[numAttr];
 278     char*    attrDesc = new char[MED_TAILLE_DESC * numAttr + 1];
 279     attrDesc[0] = '\0';
 280
 281     char* nameGroups = new char[MED_TAILLE_LNOM * numGroups + 1];
 282     nameGroups[0] = '\0';
 283
 284     med_err ret = MEDfamInfo(
 285         pMEDfile,
 286         pMeshName,
 287         pIndex,
 288         mName,
 289         &mId,
 290         attrId,
 291         attrVal,
 292         attrDesc,
 293         &numAttr,
 294         nameGroups,
 295         &numGroups);
 296
 297     if (ret != 0) throw IOException("i/o error while reading family information in MED file", __FILE__, __LINE__);
 298
 299     attrDesc[MED_TAILLE_DESC * numAttr] = '\0';
 300
 301     mAttributs.mNum  = numAttr;
 302     mAttributs.mId   = attrId;
 303     mAttributs.mVal  = attrVal;
 304     mAttributs.mDesc = attrDesc;
 305
 306     mStrNameGroups = nameGroups;
 307
 308     // split nameGroups
 309     for (int itGroup = 0 ; itGroup < numGroups ; itGroup++)
 310     {
 311         char str[MED_TAILLE_LNOM + 1];
 312         strncpy(str, nameGroups + itGroup * MED_TAILLE_LNOM, MED_TAILLE_LNOM);
 313         str[MED_TAILLE_LNOM] = '\0';
 314         mNameGroups.push_back(str);
 315     }
 316
 317     delete[] nameGroups;
 318
 319     // MEDfamLire is not necessary as we used MEDnoeudsLire/MEDelementsLire instead
 320 }
 321
 322
 323 void Family::writeMED(med_idt pMEDfile, char* pMeshName)
 324 {
 325     if (pMEDfile == 0) throw IOException("", __FILE__, __LINE__);
 326     if (pMeshName == NULL) throw NullArgumentException("", __FILE__, __LINE__);
 327     if (strlen(pMeshName) > MED_TAILLE_NOM) throw IllegalArgumentException("", __FILE__, __LINE__);
 328     if (strlen(mName) > MED_TAILLE_NOM) throw IllegalArgumentException("", __FILE__, __LINE__);
 329     if (mAttributs.mVal == NULL) throw IllegalStateException("", __FILE__, __LINE__);
 330     if (mAttributs.mDesc == NULL) throw IllegalStateException("", __FILE__, __LINE__);
 331     if (mAttributs.mId == NULL) throw IllegalStateException("", __FILE__, __LINE__);
 332
 333     med_err ret = MEDfamCr(
 334         pMEDfile,
 335         pMeshName,
 336         mName,
 337         mId,
 338         mAttributs.mId,
 339         mAttributs.mVal,
 340         mAttributs.mDesc,
 341         mAttributs.mNum,
 342         const_cast<char*>(mStrNameGroups.c_str()),
 343         mNameGroups.size());
 344
 345     if (ret != 0) throw IOException("i/o error while creating family in MED file", __FILE__, __LINE__);
 346
 347     // MEDfamEcr is not necessary as we used MEDnoeudsEcr/MEDelementsEcr instead
 348
 349 }
 350
 351
 352 ostream& operator<<(ostream& pOs, Family& pF)
 353 {
 354     pOs << "Family: " << endl;
 355     pOs << "    Name      =|" << pF.mName << "| size=" << strlen(pF.mName) << endl;
 356     pOs << "    Id        =" << pF.mId << endl;
 357     pOs << "    Family of =" << (pF.isFamilyOfNodes()?"NODES":"ELEMENTS") << endl;
 358
 359     pOs << "    Groups: #groups=" << pF.mNameGroups.size() << endl;
 360     for (unsigned itGroup = 0 ; itGroup < pF.mNameGroups.size() ; itGroup++)
 361     {
 362         pOs << "        Group " << (itGroup + 1) << ": |" << pF.mNameGroups[itGroup] << "| size=" << pF.mNameGroups[itGroup].length() << endl;
 363     }
 364     pOs << "    Attributs: " << pF.mAttributs;
 365
 366     if (pF.mElt.size() != 0)
 367     {
 368         set<med_int>::iterator itSet = pF.mElt.end();
 369         itSet--;
 370         pOs << "    Elements: #elt=" << pF.mElt.size() << " min_id=" << (*(pF.mElt.begin())) << " max_id=" << (*itSet) << endl;
 371         if (pF.mFlagPrintAll)
 372         {
 373             pOs << "        ";
 374             for (set<med_int>::iterator itSet = pF.mElt.begin() ; itSet != pF.mElt.end() ; itSet++)
 375             {
 376                 pOs << (*itSet) << " ";
 377             }
 378             pOs << endl;
 379         }
 380     }
 381     else
 382     {
 383         pOs << "    Elements: #elt=0" << endl;
 384     }
 385
 386     return pOs;
 387 }
 388
 389
 390 //*****************************************************************************
 391 // Class Group implementation
 392 //*****************************************************************************
 393
 394 Group::Group()
 395 {
 396     reset();
 397 }
 398
 399
 400 Group::~Group()
 401 {
 402     reset();
 403 }
 404
 405
 406 void Group::reset()
 407 {
 408     mName = "";
 409     mElt.clear();
 410     mIsGroupOfNodes = true;
 411
 412     mFlagPrintAll = false;
 413 }
 414
 415
 416 void Group::setName(const string& pName)
 417 {
 418     if (pName.length() > MED_TAILLE_LNOM) throw IllegalArgumentException("", __FILE__, __LINE__);
 419
 420     mName = pName;
 421 }
 422
 423
 424 void Group::insertElt(med_int pIndexElt)
 425 {
 426     if (pIndexElt < 1) throw IllegalArgumentException("", __FILE__, __LINE__);
 427
 428     mElt.insert(pIndexElt);
 429 }
 430
 431 ostream& operator<<(ostream& pOs, Group& pG)
 432 {
 433     pOs << "Group: " << endl;
 434     pOs << "    Name     =|" << pG.mName << "| size=" << pG.mName.length() << endl;
 435     pOs << "    Group of =" << (pG.isGroupOfNodes()?"NODES":"ELEMENTS") << endl;
 436
 437     if (pG.mElt.size() != 0)
 438     {
 439         set<med_int>::iterator itSet = pG.mElt.end();
 440         itSet--;
 441         pOs << "    Elements: #elt=" << pG.mElt.size() << " min_id=" << (*(pG.mElt.begin())) << " max_id=" << (*itSet) << endl;
 442         if (pG.mFlagPrintAll)
 443         {
 444             pOs << "        ";
 445             for (set<med_int>::iterator itSet = pG.mElt.begin() ; itSet != pG.mElt.end() ; itSet++)
 446             {
 447                 pOs << (*itSet) << " ";
 448             }
 449             pOs << endl;
 450         }
 451     }
 452     else
 453     {
 454         pOs << "    Elements: #elt=0" << endl;
 455     }
 456
 457     return pOs;
 458 }
 459
 460
 461 } // namespace  multipr
 462
 463 // EOF