src/DriverMED/DriverMED_R_SMESHDS_Mesh.cxx

   1 //  SMESH DriverMED : driver to read and write 'med' files
   2 //
   3 //  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   4 //  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   5 //
   6 //  This library is free software; you can redistribute it and/or
   7 //  modify it under the terms of the GNU Lesser General Public
   8 //  License as published by the Free Software Foundation; either
   9 //  version 2.1 of the License.
  10 //
  11 //  This library is distributed in the hope that it will be useful,
  12 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 //  Lesser General Public License for more details.
  15 //
  16 //  You should have received a copy of the GNU Lesser General Public
  17 //  License along with this library; if not, write to the Free Software
  18 //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19 //
  20 //  See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
  21 //
  22 //
  23 //
  24 //  File   : DriverMED_R_SMESHDS_Mesh.cxx
  25 //  Module : SMESH
  26
  27 #include "DriverMED_R_SMESHDS_Mesh.h"
  28 #include "DriverMED_R_SMDS_Mesh.h"
  29 #include "utilities.h"
  30
  31 #include "DriverMED_Family.h"
  32
  33 #include "SMESHDS_Group.hxx"
  34
  35 #include "MEDA_Wrapper.hxx"
  36 #include "MED_Utilities.hxx"
  37
  38 #include <stdlib.h>
  39
  40 DriverMED_R_SMESHDS_Mesh::DriverMED_R_SMESHDS_Mesh()
  41      :
  42        myMesh (NULL),
  43        myFile (""),
  44        myFileId (-1),
  45        myMeshId (-1)
  46 {
  47 }
  48
  49 DriverMED_R_SMESHDS_Mesh::~DriverMED_R_SMESHDS_Mesh()
  50 {
  51 //  map<int, DriverMED_FamilyPtr>::iterator aFamsIter = myFamilies.begin();
  52 //  for (; aFamsIter != myFamilies.end(); aFamsIter++)
  53 //  {
  54 //    delete (*aFamsIter).second;
  55 //  }
  56 }
  57
  58 void DriverMED_R_SMESHDS_Mesh::SetMesh(SMDS_Mesh * aMesh)
  59 {
  60   myMesh = aMesh;
  61 }
  62
  63 void DriverMED_R_SMESHDS_Mesh::SetFile(string aFile)
  64 {
  65   myFile = aFile;
  66 }
  67
  68 void DriverMED_R_SMESHDS_Mesh::SetFileId(med_idt aFileId)
  69 {
  70   myFileId = aFileId;
  71 }
  72
  73 void DriverMED_R_SMESHDS_Mesh::SetMeshId(int aMeshId)
  74 {
  75   myMeshId = aMeshId;
  76 }
  77
  78 void DriverMED_R_SMESHDS_Mesh::SetMeshName(string theMeshName)
  79 {
  80   myMeshName = theMeshName;
  81 }
  82
  83 void DriverMED_R_SMESHDS_Mesh::Read()
  84 {
  85
  86   string myClass = string("SMDS_Mesh");
  87   string myExtension = string("MED");
  88
  89   DriverMED_R_SMDS_Mesh *myReader = new DriverMED_R_SMDS_Mesh;
  90
  91   myReader->SetMesh(myMesh);
  92   myReader->SetMeshId(myMeshId);
  93   myReader->SetFile(myFile);
  94   myReader->SetFileId(-1);
  95
  96   myReader->Read();
  97 }
  98
  99 void DriverMED_R_SMESHDS_Mesh::Add()
 100 {
 101   string myClass = string("SMDS_Mesh");
 102   string myExtension = string("MED");
 103
 104   DriverMED_R_SMDS_Mesh *myReader = new DriverMED_R_SMDS_Mesh;
 105
 106   myReader->SetMesh(myMesh);
 107   myReader->SetMeshId(myMeshId);
 108
 109   SCRUTE(myFileId);
 110   myReader->SetFileId(myFileId);
 111
 112   myReader->Read();
 113 }
 114
 115
 116 static const SMDS_MeshNode*
 117 FindNode(const SMDS_Mesh* theMesh, med_int theId){
 118   const SMDS_MeshNode* aNode = theMesh->FindNode(theId);
 119   if(aNode) return aNode;
 120   EXCEPTION(runtime_error,"SMDS_Mesh::FindNode - cannot find a SMDS_MeshNode for ID = "<<theId);
 121 }
 122
 123
 124 DriverMED_R_SMESHDS_Mesh::ReadStatus DriverMED_R_SMESHDS_Mesh::ReadMySelf()
 125 {
 126   ReadStatus result = DRS_FAIL;
 127   try{
 128     using namespace MEDA;
 129
 130     myFamilies.clear();
 131     MESSAGE("ReadMySelf - myFile : "<<myFile);
 132     TWrapper aMed(myFile);
 133
 134     result = DRS_EMPTY;
 135     if(med_int aNbMeshes = aMed.GetNbMeshes()){
 136       for(int iMesh = 0; iMesh < aNbMeshes; iMesh++){
 137         // Reading the MED mesh
 138         //---------------------
 139         PMeshInfo aMeshInfo = aMed.GetMeshInfo(iMesh);
 140         string aMeshName;
 141         if (myMeshId != -1) {
 142           ostringstream aMeshNameStr;
 143           aMeshNameStr<<myMeshId;
 144           aMeshName = aMeshNameStr.str();
 145         } else {
 146           aMeshName = myMeshName;
 147         }
 148         MESSAGE("ReadMySelf - aMeshName : "<<aMeshName<<"; "<<aMeshInfo->GetName());
 149         if(aMeshName != aMeshInfo->GetName()) continue;
 150         result = DRS_OK;
 151         med_int aMeshDim = aMeshInfo->GetDim();
 152
 153         // Reading MED families to the temporary structure
 154         //------------------------------------------------
 155         med_int aNbFams = aMed.GetNbFamilies(aMeshInfo);
 156         MESSAGE("Read " << aNbFams << " families");
 157         for (med_int iFam = 0; iFam < aNbFams; iFam++) {
 158           PFamilyInfo aFamilyInfo = aMed.GetFamilyInfo(aMeshInfo, iFam);
 159           med_int aFamId = aFamilyInfo->GetId();
 160           MESSAGE("Family " << aFamId << " :");
 161
 162 //if (aFamId >= FIRST_VALID_FAMILY) {
 163             DriverMED_FamilyPtr aFamily (new DriverMED_Family);
 164
 165             med_int aNbGrp = aFamilyInfo->GetNbGroup();
 166             MESSAGE("belong to " << aNbGrp << " groups");
 167             for (med_int iGr = 0; iGr < aNbGrp; iGr++) {
 168               string aGroupName = aFamilyInfo->GetGroupName(iGr);
 169               MESSAGE(aGroupName);
 170               aFamily->AddGroupName(aGroupName);
 171             }
 172 //        aFamily->SetId(aFamId);
 173             myFamilies[aFamId] = aFamily;
 174 //          }
 175         }
 176
 177         // Reading MED nodes to the corresponding SMDS structure
 178         //------------------------------------------------------
 179         PNodeInfo aNodeInfo = aMed.GetNodeInfo(aMeshInfo);
 180         med_booleen anIsNodeNum = aNodeInfo->IsElemNum();
 181         med_int aNbElems = aNodeInfo->GetNbElem();
 182         MESSAGE("ReadMySelf - aNodeInfo->GetNbElem() = "<<aNbElems<<"; anIsNodeNum = "<<anIsNodeNum);
 183         for(med_int iElem = 0; iElem < aNbElems; iElem++){
 184           double aCoords[3] = {0.0, 0.0, 0.0};
 185           for(med_int iDim = 0; iDim < aMeshDim; iDim++)
 186             aCoords[iDim] = aNodeInfo->GetNodeCoord(iElem,iDim);
 187           const SMDS_MeshNode* aNode;
 188           if(anIsNodeNum) {
 189             aNode = myMesh->AddNodeWithID
 190               (aCoords[0],aCoords[1],aCoords[2],aNodeInfo->GetElemNum(iElem));
 191           } else {
 192             aNode = myMesh->AddNode
 193               (aCoords[0],aCoords[1],aCoords[2]);
 194           }
 195           //cout<<aNode->GetID()<<": "<<aNode->X()<<", "<<aNode->Y()<<", "<<aNode->Z()<<endl;
 196
 197           // Save reference to this node from its family
 198           med_int aFamNum = aNodeInfo->GetFamNum(iElem);
 199           if (myFamilies.find(aFamNum) != myFamilies.end())
 200           {
 201             myFamilies[aFamNum]->AddElement(aNode);
 202             myFamilies[aFamNum]->SetType(SMDSAbs_Node);
 203           }
 204         }
 205
 206         // Reading pre information about all MED cells
 207         //--------------------------------------------
 208         bool takeNumbers = true;  // initially we trust the numbers from file
 209         MED::TEntityInfo aEntityInfo = aMed.GetEntityInfo(aMeshInfo);
 210         MED::TEntityInfo::iterator anEntityIter = aEntityInfo.begin();
 211         for(; anEntityIter != aEntityInfo.end(); anEntityIter++){
 212           const med_entite_maillage& anEntity = anEntityIter->first;
 213           if(anEntity == MED_NOEUD) continue;
 214           // Reading MED cells to the corresponding SMDS structure
 215           //------------------------------------------------------
 216           const MED::TGeom& aTGeom = anEntityIter->second;
 217           MED::TGeom::const_iterator anTGeomIter = aTGeom.begin();
 218           for(; anTGeomIter != aTGeom.end(); anTGeomIter++){
 219             const med_geometrie_element& aGeom = anTGeomIter->first;
 220             if(aGeom == MED_POINT1) continue;
 221             PCellInfo aCellInfo = aMed.GetCellInfo(aMeshInfo,anEntity,aGeom);
 222             med_booleen anIsElemNum = takeNumbers ? aCellInfo->IsElemNum() : MED_FAUX;
 223             med_int aNbElems = aCellInfo->GetNbElem();
 224             MESSAGE("ReadMySelf - anEntity = "<<anEntity<<"; anIsElemNum = "<<anIsElemNum);
 225             MESSAGE("ReadMySelf - aGeom = "<<aGeom<<"; aNbElems = "<<aNbElems);
 226
 227             for(int iElem = 0; iElem < aNbElems; iElem++){
 228               med_int aNbNodes = -1;
 229               switch(aGeom){
 230               case MED_SEG2:
 231               case MED_SEG3:
 232                 aNbNodes = 2;
 233                 break;
 234               case MED_TRIA3:
 235               case MED_TRIA6:
 236                 aNbNodes = 3;
 237                 break;
 238                 break;
 239               case MED_QUAD4:
 240               case MED_QUAD8:
 241                 aNbNodes = 4;
 242                 break;
 243               case MED_TETRA4:
 244               case MED_TETRA10:
 245                 aNbNodes = 4;
 246                 break;
 247               case MED_PYRA5:
 248               case MED_PYRA13:
 249                 aNbNodes = 5;
 250                 break;
 251               case MED_PENTA6:
 252               case MED_PENTA15:
 253                 aNbNodes = 6;
 254                 break;
 255               case MED_HEXA8:
 256               case MED_HEXA20:
 257                 aNbNodes = 8;
 258                 break;
 259               }
 260 //            if(anIsElemNum)
 261 //              cout<<aCellInfo->GetElemNum(iElem)<<": ";
 262 //            else
 263 //              cout<<iElem<<": ";
 264               vector<med_int> aNodeIds(aNbNodes);
 265               for(int i = 0; i < aNbNodes; i++){
 266                 aNodeIds.at(i) = aCellInfo->GetConn(iElem,i);
 267                 //cout<<aNodeIds.at(i)<<", ";
 268               }
 269               //cout<<endl;
 270
 271               bool isRenum = false;
 272               SMDS_MeshElement* anElement = NULL;
 273               med_int aFamNum = aCellInfo->GetFamNum(iElem);
 274               try{
 275                 switch(aGeom){
 276                 case MED_SEG2:
 277                 case MED_SEG3:
 278                   if(anIsElemNum)
 279                     anElement = myMesh->AddEdgeWithID(aNodeIds.at(0),
 280                                                       aNodeIds.at(1),
 281                                                       aCellInfo->GetElemNum(iElem));
 282                   if (!anElement) {
 283                     anElement = myMesh->AddEdge(FindNode(myMesh,aNodeIds.at(0)),
 284                                                 FindNode(myMesh,aNodeIds.at(1)));
 285                     isRenum = anIsElemNum;
 286                   }
 287                   break;
 288                 case MED_TRIA3:
 289                 case MED_TRIA6:
 290                   aNbNodes = 3;
 291                   if(anIsElemNum)
 292                     anElement = myMesh->AddFaceWithID(aNodeIds.at(0),
 293                                                       aNodeIds.at(1),
 294                                                       aNodeIds.at(2),
 295                                                       aCellInfo->GetElemNum(iElem));
 296                   if (!anElement) {
 297                     anElement = myMesh->AddFace(FindNode(myMesh,aNodeIds.at(0)),
 298                                                 FindNode(myMesh,aNodeIds.at(1)),
 299                                                 FindNode(myMesh,aNodeIds.at(2)));
 300                     isRenum = anIsElemNum;
 301                   }
 302                   break;
 303                 case MED_QUAD4:
 304                 case MED_QUAD8:
 305                   aNbNodes = 4;
 306                   // There is some differnce between SMDS and MED
 307                   if(anIsElemNum)
 308                     anElement = myMesh->AddFaceWithID(aNodeIds.at(0),
 309                                                       aNodeIds.at(1),
 310                                                       aNodeIds.at(2),
 311                                                       aNodeIds.at(3),
 312                                                       aCellInfo->GetElemNum(iElem));
 313                   if (!anElement) {
 314                     anElement = myMesh->AddFace(FindNode(myMesh,aNodeIds.at(0)),
 315                                                 FindNode(myMesh,aNodeIds.at(1)),
 316                                                 FindNode(myMesh,aNodeIds.at(2)),
 317                                                 FindNode(myMesh,aNodeIds.at(3)));
 318                     isRenum = anIsElemNum;
 319                   }
 320                   break;
 321                 case MED_TETRA4:
 322                 case MED_TETRA10:
 323                   aNbNodes = 4;
 324                   if(anIsElemNum)
 325                     anElement = myMesh->AddVolumeWithID(aNodeIds.at(0),
 326                                                         aNodeIds.at(1),
 327                                                         aNodeIds.at(2),
 328                                                         aNodeIds.at(3),
 329                                                         aCellInfo->GetElemNum(iElem));
 330                   if (!anElement) {
 331                     anElement = myMesh->AddVolume(FindNode(myMesh,aNodeIds.at(0)),
 332                                                   FindNode(myMesh,aNodeIds.at(1)),
 333                                                   FindNode(myMesh,aNodeIds.at(2)),
 334                                                   FindNode(myMesh,aNodeIds.at(3)));
 335                     isRenum = anIsElemNum;
 336                   }
 337                   break;
 338                 case MED_PYRA5:
 339                 case MED_PYRA13:
 340                   aNbNodes = 5;
 341                   // There is some differnce between SMDS and MED
 342                   if(anIsElemNum)
 343                     anElement = myMesh->AddVolumeWithID(aNodeIds.at(0),
 344                                                         aNodeIds.at(1),
 345                                                         aNodeIds.at(2),
 346                                                         aNodeIds.at(3),
 347                                                         aNodeIds.at(4),
 348                                                         aCellInfo->GetElemNum(iElem));
 349                   if (!anElement) {
 350                     anElement = myMesh->AddVolume(FindNode(myMesh,aNodeIds.at(0)),
 351                                                   FindNode(myMesh,aNodeIds.at(1)),
 352                                                   FindNode(myMesh,aNodeIds.at(2)),
 353                                                   FindNode(myMesh,aNodeIds.at(3)),
 354                                                   FindNode(myMesh,aNodeIds.at(4)));
 355                     isRenum = anIsElemNum;
 356                   }
 357                   break;
 358                 case MED_PENTA6:
 359                 case MED_PENTA15:
 360                   aNbNodes = 6;
 361                   if(anIsElemNum)
 362                     anElement = myMesh->AddVolumeWithID(aNodeIds.at(0),
 363                                                         aNodeIds.at(1),
 364                                                         aNodeIds.at(2),
 365                                                         aNodeIds.at(3),
 366                                                         aNodeIds.at(4),
 367                                                         aNodeIds.at(5),
 368                                                         aCellInfo->GetElemNum(iElem));
 369                   if (!anElement) {
 370                     anElement = myMesh->AddVolume(FindNode(myMesh,aNodeIds.at(0)),
 371                                                   FindNode(myMesh,aNodeIds.at(1)),
 372                                                   FindNode(myMesh,aNodeIds.at(2)),
 373                                                   FindNode(myMesh,aNodeIds.at(3)),
 374                                                   FindNode(myMesh,aNodeIds.at(4)),
 375                                                   FindNode(myMesh,aNodeIds.at(5)));
 376                     isRenum = anIsElemNum;
 377                   }
 378                   break;
 379                 case MED_HEXA8:
 380                 case MED_HEXA20:
 381                   aNbNodes = 8;
 382                   if(anIsElemNum)
 383                     anElement = myMesh->AddVolumeWithID(aNodeIds.at(0),
 384                                                         aNodeIds.at(1),
 385                                                         aNodeIds.at(2),
 386                                                         aNodeIds.at(3),
 387                                                         aNodeIds.at(4),
 388                                                         aNodeIds.at(5),
 389                                                         aNodeIds.at(6),
 390                                                         aNodeIds.at(7),
 391                                                         aCellInfo->GetElemNum(iElem));
 392                   if (!anElement) {
 393                     anElement = myMesh->AddVolume(FindNode(myMesh,aNodeIds.at(0)),
 394                                                   FindNode(myMesh,aNodeIds.at(1)),
 395                                                   FindNode(myMesh,aNodeIds.at(2)),
 396                                                   FindNode(myMesh,aNodeIds.at(3)),
 397                                                   FindNode(myMesh,aNodeIds.at(4)),
 398                                                   FindNode(myMesh,aNodeIds.at(5)),
 399                                                   FindNode(myMesh,aNodeIds.at(6)),
 400                                                   FindNode(myMesh,aNodeIds.at(7)));
 401                     isRenum = anIsElemNum;
 402                   }
 403                   break;
 404                 }
 405               }catch(const std::exception& exc){
 406                 //INFOS("Follow exception was cought:\n\t"<<exc.what());
 407                 result = DRS_FAIL;
 408               }catch(...){
 409                 //INFOS("Unknown exception was cought !!!");
 410                 result = DRS_FAIL;
 411               }
 412
 413               if (!anElement) {
 414                 result = DRS_WARN_SKIP_ELEM;
 415               }
 416               else {
 417                 if (isRenum) {
 418                   anIsElemNum = MED_FAUX;
 419                   takeNumbers = false;
 420                   if (result < DRS_WARN_RENUMBER)
 421                     result = DRS_WARN_RENUMBER;
 422                 }
 423                 if (myFamilies.find(aFamNum) != myFamilies.end()) {
 424                   // Save reference to this element from its family
 425                   myFamilies[aFamNum]->AddElement(anElement);
 426                   myFamilies[aFamNum]->SetType(anElement->GetType());
 427                 }
 428               }
 429             }
 430           }
 431         }
 432         break;
 433       }
 434     }
 435   }catch(const std::exception& exc){
 436     INFOS("Follow exception was cought:\n\t"<<exc.what());
 437     result = DRS_FAIL;
 438   }catch(...){
 439     INFOS("Unknown exception was cought !!!");
 440     result = DRS_FAIL;
 441   }
 442   MESSAGE("ReadMySelf - result status = "<<result);
 443   return result;
 444 }
 445
 446 list<string> DriverMED_R_SMESHDS_Mesh::GetMeshNames()
 447 {
 448   list<string> aMeshNames;
 449
 450   try {
 451     using namespace MEDA;
 452
 453     MESSAGE("GetMeshNames - myFile : " << myFile);
 454     TWrapper aMed (myFile);
 455
 456     if (med_int aNbMeshes = aMed.GetNbMeshes()) {
 457       for (int iMesh = 0; iMesh < aNbMeshes; iMesh++) {
 458         // Reading the MED mesh
 459         //---------------------
 460         PMeshInfo aMeshInfo = aMed.GetMeshInfo(iMesh);
 461         aMeshNames.push_back(aMeshInfo->GetName());
 462       }
 463     }
 464   }catch(const std::exception& exc){
 465     INFOS("Follow exception was cought:\n\t"<<exc.what());
 466   }catch(...){
 467     INFOS("Unknown exception was cought !!!");
 468   }
 469
 470   return aMeshNames;
 471 }
 472
 473 list<string> DriverMED_R_SMESHDS_Mesh::GetGroupNames()
 474 {
 475   list<string> aResult;
 476   set<string> aResGroupNames;
 477
 478   map<int, DriverMED_FamilyPtr>::iterator aFamsIter = myFamilies.begin();
 479   for (; aFamsIter != myFamilies.end(); aFamsIter++)
 480   {
 481     DriverMED_FamilyPtr aFamily = (*aFamsIter).second;
 482     const MED::TStringSet& aGroupNames = aFamily->GetGroupNames();
 483     set<string>::iterator aGrNamesIter = aGroupNames.begin();
 484     for (; aGrNamesIter != aGroupNames.end(); aGrNamesIter++)
 485     {
 486       string aName = *aGrNamesIter;
 487       // Check, if this is a Group or SubMesh name
 488 //if (aName.substr(0, 5) == string("Group")) {
 489         if (aResGroupNames.find(aName) == aResGroupNames.end()) {
 490           aResGroupNames.insert(aName);
 491           aResult.push_back(aName);
 492         }
 493 //    }
 494     }
 495   }
 496
 497   return aResult;
 498 }
 499
 500 void DriverMED_R_SMESHDS_Mesh::GetGroup(SMESHDS_Group* theGroup)
 501 {
 502   string aGroupName (theGroup->GetStoreName());
 503   MESSAGE("Get Group " << aGroupName);
 504
 505   map<int, DriverMED_FamilyPtr>::iterator aFamsIter = myFamilies.begin();
 506   for (; aFamsIter != myFamilies.end(); aFamsIter++)
 507   {
 508     DriverMED_FamilyPtr aFamily = (*aFamsIter).second;
 509     if (aFamily->MemberOf(aGroupName))
 510     {
 511       const set<const SMDS_MeshElement *>& anElements = aFamily->GetElements();
 512       set<const SMDS_MeshElement *>::iterator anElemsIter = anElements.begin();
 513       for (; anElemsIter != anElements.end(); anElemsIter++)
 514       {
 515         theGroup->SMDS_MeshGroup::Add(*anElemsIter);
 516       }
 517     }
 518   }
 519 }
 520
 521 void DriverMED_R_SMESHDS_Mesh::GetSubMesh (SMESHDS_SubMesh* theSubMesh,
 522                                            const int theId)
 523 {
 524   char submeshGrpName[ 30 ];
 525   sprintf( submeshGrpName, "SubMesh %d", theId );
 526   string aName (submeshGrpName);
 527   map<int, DriverMED_FamilyPtr>::iterator aFamsIter = myFamilies.begin();
 528   for (; aFamsIter != myFamilies.end(); aFamsIter++)
 529   {
 530     DriverMED_FamilyPtr aFamily = (*aFamsIter).second;
 531     if (aFamily->MemberOf(aName))
 532     {
 533       const set<const SMDS_MeshElement *>& anElements = aFamily->GetElements();
 534       set<const SMDS_MeshElement *>::iterator anElemsIter = anElements.begin();
 535       if (aFamily->GetType() == SMDSAbs_Node)
 536       {
 537         for (; anElemsIter != anElements.end(); anElemsIter++)
 538         {
 539           const SMDS_MeshNode* node = static_cast<const SMDS_MeshNode*>(*anElemsIter);
 540           theSubMesh->AddNode(node);
 541         }
 542       }
 543       else
 544       {
 545         for (; anElemsIter != anElements.end(); anElemsIter++)
 546         {
 547           theSubMesh->AddElement(*anElemsIter);
 548         }
 549       }
 550     }
 551   }
 552 }
 553
 554 void DriverMED_R_SMESHDS_Mesh::CreateAllSubMeshes ()
 555 {
 556   SMESHDS_Mesh* aSMESHDSMesh = dynamic_cast<SMESHDS_Mesh*>(myMesh);
 557   if (!aSMESHDSMesh) {
 558     EXCEPTION(runtime_error,"Can not cast SMDS_Mesh to SMESHDS_Mesh");
 559   }
 560   map<int, DriverMED_FamilyPtr>::iterator aFamsIter = myFamilies.begin();
 561   for (; aFamsIter != myFamilies.end(); aFamsIter++)
 562   {
 563     DriverMED_FamilyPtr aFamily = (*aFamsIter).second;
 564     MED::TStringSet aGroupNames = aFamily->GetGroupNames();
 565     set<string>::iterator aGrNamesIter = aGroupNames.begin();
 566     for (; aGrNamesIter != aGroupNames.end(); aGrNamesIter++)
 567     {
 568       string aName = *aGrNamesIter;
 569       // Check, if this is a Group or SubMesh name
 570       if (aName.substr(0, 7) == string("SubMesh"))
 571       {
 572         int Id = atoi(string(aName).substr(7).c_str());
 573         set<const SMDS_MeshElement *> anElements = aFamily->GetElements();
 574         set<const SMDS_MeshElement *>::iterator anElemsIter = anElements.begin();
 575         if (aFamily->GetType() == SMDSAbs_Node)
 576         {
 577           for (; anElemsIter != anElements.end(); anElemsIter++)
 578           {
 579             const SMDS_MeshNode* node = static_cast<const SMDS_MeshNode*>(*anElemsIter);
 580             aSMESHDSMesh->SetNodeInVolume(node, Id);
 581 //            aSMESHDSMesh->SetNodeOnFace(node, Id);
 582 //            aSMESHDSMesh->SetNodeOnEdge(node, Id);
 583 //            aSMESHDSMesh->SetNodeOnVertex(node, Id);
 584           }
 585         }
 586         else
 587         {
 588           for (; anElemsIter != anElements.end(); anElemsIter++)
 589           {
 590             aSMESHDSMesh->SetMeshElementOnShape(*anElemsIter, Id);
 591           }
 592         }
 593       }
 594     }
 595   }
 596 }