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               vector<med_int> aNodeIds(aNbNodes);
 261               if(anIsNodeNum) {
 262                 for(int i = 0; i < aNbNodes; i++){
 263                   aNodeIds.at(i) = aNodeInfo->GetElemNum(aCellInfo->GetConn(iElem,i)-1);
 264                 }
 265               }else{
 266                 for(int i = 0; i < aNbNodes; i++){
 267                   aNodeIds.at(i) = aCellInfo->GetConn(iElem,i);
 268                 }
 269               }
 270               //if(anIsElemNum)
 271               //        cout<<aCellInfo->GetElemNum(iElem)<<": ";
 272               //else
 273               //        cout<<iElem<<": ";
 274               //for(int i = 0; i < aNbNodes; i++){
 275               //        cout<<aNodeIds.at(i)<<", ";
 276               //}
 277
 278               bool isRenum = false;
 279               SMDS_MeshElement* anElement = NULL;
 280               med_int aFamNum = aCellInfo->GetFamNum(iElem);
 281               try{
 282                 switch(aGeom){
 283                 case MED_SEG2:
 284                 case MED_SEG3:
 285                   if(anIsElemNum)
 286                     anElement = myMesh->AddEdgeWithID(aNodeIds.at(0),
 287                                                       aNodeIds.at(1),
 288                                                       aCellInfo->GetElemNum(iElem));
 289                   if (!anElement) {
 290                     anElement = myMesh->AddEdge(FindNode(myMesh,aNodeIds.at(0)),
 291                                                 FindNode(myMesh,aNodeIds.at(1)));
 292                     isRenum = anIsElemNum;
 293                   }
 294                   break;
 295                 case MED_TRIA3:
 296                 case MED_TRIA6:
 297                   aNbNodes = 3;
 298                   if(anIsElemNum)
 299                     anElement = myMesh->AddFaceWithID(aNodeIds.at(0),
 300                                                       aNodeIds.at(1),
 301                                                       aNodeIds.at(2),
 302                                                       aCellInfo->GetElemNum(iElem));
 303                   if (!anElement) {
 304                     anElement = myMesh->AddFace(FindNode(myMesh,aNodeIds.at(0)),
 305                                                 FindNode(myMesh,aNodeIds.at(1)),
 306                                                 FindNode(myMesh,aNodeIds.at(2)));
 307                     isRenum = anIsElemNum;
 308                   }
 309                   break;
 310                 case MED_QUAD4:
 311                 case MED_QUAD8:
 312                   aNbNodes = 4;
 313                   // There is some differnce between SMDS and MED
 314                   if(anIsElemNum)
 315                     anElement = myMesh->AddFaceWithID(aNodeIds.at(0),
 316                                                       aNodeIds.at(1),
 317                                                       aNodeIds.at(2),
 318                                                       aNodeIds.at(3),
 319                                                       aCellInfo->GetElemNum(iElem));
 320                   if (!anElement) {
 321                     anElement = myMesh->AddFace(FindNode(myMesh,aNodeIds.at(0)),
 322                                                 FindNode(myMesh,aNodeIds.at(1)),
 323                                                 FindNode(myMesh,aNodeIds.at(2)),
 324                                                 FindNode(myMesh,aNodeIds.at(3)));
 325                     isRenum = anIsElemNum;
 326                   }
 327                   break;
 328                 case MED_TETRA4:
 329                 case MED_TETRA10:
 330                   aNbNodes = 4;
 331                   if(anIsElemNum)
 332                     anElement = myMesh->AddVolumeWithID(aNodeIds.at(0),
 333                                                         aNodeIds.at(1),
 334                                                         aNodeIds.at(2),
 335                                                         aNodeIds.at(3),
 336                                                         aCellInfo->GetElemNum(iElem));
 337                   if (!anElement) {
 338                     anElement = myMesh->AddVolume(FindNode(myMesh,aNodeIds.at(0)),
 339                                                   FindNode(myMesh,aNodeIds.at(1)),
 340                                                   FindNode(myMesh,aNodeIds.at(2)),
 341                                                   FindNode(myMesh,aNodeIds.at(3)));
 342                     isRenum = anIsElemNum;
 343                   }
 344                   break;
 345                 case MED_PYRA5:
 346                 case MED_PYRA13:
 347                   aNbNodes = 5;
 348                   // There is some differnce between SMDS and MED
 349                   if(anIsElemNum)
 350                     anElement = myMesh->AddVolumeWithID(aNodeIds.at(0),
 351                                                         aNodeIds.at(1),
 352                                                         aNodeIds.at(2),
 353                                                         aNodeIds.at(3),
 354                                                         aNodeIds.at(4),
 355                                                         aCellInfo->GetElemNum(iElem));
 356                   if (!anElement) {
 357                     anElement = myMesh->AddVolume(FindNode(myMesh,aNodeIds.at(0)),
 358                                                   FindNode(myMesh,aNodeIds.at(1)),
 359                                                   FindNode(myMesh,aNodeIds.at(2)),
 360                                                   FindNode(myMesh,aNodeIds.at(3)),
 361                                                   FindNode(myMesh,aNodeIds.at(4)));
 362                     isRenum = anIsElemNum;
 363                   }
 364                   break;
 365                 case MED_PENTA6:
 366                 case MED_PENTA15:
 367                   aNbNodes = 6;
 368                   if(anIsElemNum)
 369                     anElement = myMesh->AddVolumeWithID(aNodeIds.at(0),
 370                                                         aNodeIds.at(1),
 371                                                         aNodeIds.at(2),
 372                                                         aNodeIds.at(3),
 373                                                         aNodeIds.at(4),
 374                                                         aNodeIds.at(5),
 375                                                         aCellInfo->GetElemNum(iElem));
 376                   if (!anElement) {
 377                     anElement = myMesh->AddVolume(FindNode(myMesh,aNodeIds.at(0)),
 378                                                   FindNode(myMesh,aNodeIds.at(1)),
 379                                                   FindNode(myMesh,aNodeIds.at(2)),
 380                                                   FindNode(myMesh,aNodeIds.at(3)),
 381                                                   FindNode(myMesh,aNodeIds.at(4)),
 382                                                   FindNode(myMesh,aNodeIds.at(5)));
 383                     isRenum = anIsElemNum;
 384                   }
 385                   break;
 386                 case MED_HEXA8:
 387                 case MED_HEXA20:
 388                   aNbNodes = 8;
 389                   if(anIsElemNum)
 390                     anElement = myMesh->AddVolumeWithID(aNodeIds.at(0),
 391                                                         aNodeIds.at(1),
 392                                                         aNodeIds.at(2),
 393                                                         aNodeIds.at(3),
 394                                                         aNodeIds.at(4),
 395                                                         aNodeIds.at(5),
 396                                                         aNodeIds.at(6),
 397                                                         aNodeIds.at(7),
 398                                                         aCellInfo->GetElemNum(iElem));
 399                   if (!anElement) {
 400                     anElement = myMesh->AddVolume(FindNode(myMesh,aNodeIds.at(0)),
 401                                                   FindNode(myMesh,aNodeIds.at(1)),
 402                                                   FindNode(myMesh,aNodeIds.at(2)),
 403                                                   FindNode(myMesh,aNodeIds.at(3)),
 404                                                   FindNode(myMesh,aNodeIds.at(4)),
 405                                                   FindNode(myMesh,aNodeIds.at(5)),
 406                                                   FindNode(myMesh,aNodeIds.at(6)),
 407                                                   FindNode(myMesh,aNodeIds.at(7)));
 408                     isRenum = anIsElemNum;
 409                   }
 410                   break;
 411                 }
 412               }catch(const std::exception& exc){
 413                 //INFOS("Follow exception was cought:\n\t"<<exc.what());
 414                 result = DRS_FAIL;
 415               }catch(...){
 416                 //INFOS("Unknown exception was cought !!!");
 417                 result = DRS_FAIL;
 418               }
 419
 420               if (!anElement) {
 421                 result = DRS_WARN_SKIP_ELEM;
 422               }
 423               else {
 424                 if (isRenum) {
 425                   anIsElemNum = MED_FAUX;
 426                   takeNumbers = false;
 427                   if (result < DRS_WARN_RENUMBER)
 428                     result = DRS_WARN_RENUMBER;
 429                 }
 430                 if (myFamilies.find(aFamNum) != myFamilies.end()) {
 431                   // Save reference to this element from its family
 432                   myFamilies[aFamNum]->AddElement(anElement);
 433                   myFamilies[aFamNum]->SetType(anElement->GetType());
 434                 }
 435               }
 436             }
 437           }
 438         }
 439         break;
 440       }
 441     }
 442   }catch(const std::exception& exc){
 443     INFOS("Follow exception was cought:\n\t"<<exc.what());
 444     result = DRS_FAIL;
 445   }catch(...){
 446     INFOS("Unknown exception was cought !!!");
 447     result = DRS_FAIL;
 448   }
 449   MESSAGE("ReadMySelf - result status = "<<result);
 450   return result;
 451 }
 452
 453 list<string> DriverMED_R_SMESHDS_Mesh::GetMeshNames()
 454 {
 455   list<string> aMeshNames;
 456
 457   try {
 458     using namespace MEDA;
 459
 460     MESSAGE("GetMeshNames - myFile : " << myFile);
 461     TWrapper aMed (myFile);
 462
 463     if (med_int aNbMeshes = aMed.GetNbMeshes()) {
 464       for (int iMesh = 0; iMesh < aNbMeshes; iMesh++) {
 465         // Reading the MED mesh
 466         //---------------------
 467         PMeshInfo aMeshInfo = aMed.GetMeshInfo(iMesh);
 468         aMeshNames.push_back(aMeshInfo->GetName());
 469       }
 470     }
 471   }catch(const std::exception& exc){
 472     INFOS("Follow exception was cought:\n\t"<<exc.what());
 473   }catch(...){
 474     INFOS("Unknown exception was cought !!!");
 475   }
 476
 477   return aMeshNames;
 478 }
 479
 480 list<string> DriverMED_R_SMESHDS_Mesh::GetGroupNames()
 481 {
 482   list<string> aResult;
 483   set<string> aResGroupNames;
 484
 485   map<int, DriverMED_FamilyPtr>::iterator aFamsIter = myFamilies.begin();
 486   for (; aFamsIter != myFamilies.end(); aFamsIter++)
 487   {
 488     DriverMED_FamilyPtr aFamily = (*aFamsIter).second;
 489     const MED::TStringSet& aGroupNames = aFamily->GetGroupNames();
 490     set<string>::iterator aGrNamesIter = aGroupNames.begin();
 491     for (; aGrNamesIter != aGroupNames.end(); aGrNamesIter++)
 492     {
 493       string aName = *aGrNamesIter;
 494       // Check, if this is a Group or SubMesh name
 495 //if (aName.substr(0, 5) == string("Group")) {
 496         if (aResGroupNames.find(aName) == aResGroupNames.end()) {
 497           aResGroupNames.insert(aName);
 498           aResult.push_back(aName);
 499         }
 500 //    }
 501     }
 502   }
 503
 504   return aResult;
 505 }
 506
 507 void DriverMED_R_SMESHDS_Mesh::GetGroup(SMESHDS_Group* theGroup)
 508 {
 509   string aGroupName (theGroup->GetStoreName());
 510   MESSAGE("Get Group " << aGroupName);
 511
 512   map<int, DriverMED_FamilyPtr>::iterator aFamsIter = myFamilies.begin();
 513   for (; aFamsIter != myFamilies.end(); aFamsIter++)
 514   {
 515     DriverMED_FamilyPtr aFamily = (*aFamsIter).second;
 516     if (aFamily->MemberOf(aGroupName))
 517     {
 518       const set<const SMDS_MeshElement *>& anElements = aFamily->GetElements();
 519       set<const SMDS_MeshElement *>::iterator anElemsIter = anElements.begin();
 520       for (; anElemsIter != anElements.end(); anElemsIter++)
 521       {
 522         theGroup->SMDS_MeshGroup::Add(*anElemsIter);
 523       }
 524     }
 525   }
 526 }
 527
 528 void DriverMED_R_SMESHDS_Mesh::GetSubMesh (SMESHDS_SubMesh* theSubMesh,
 529                                            const int theId)
 530 {
 531   char submeshGrpName[ 30 ];
 532   sprintf( submeshGrpName, "SubMesh %d", theId );
 533   string aName (submeshGrpName);
 534   map<int, DriverMED_FamilyPtr>::iterator aFamsIter = myFamilies.begin();
 535   for (; aFamsIter != myFamilies.end(); aFamsIter++)
 536   {
 537     DriverMED_FamilyPtr aFamily = (*aFamsIter).second;
 538     if (aFamily->MemberOf(aName))
 539     {
 540       const set<const SMDS_MeshElement *>& anElements = aFamily->GetElements();
 541       set<const SMDS_MeshElement *>::iterator anElemsIter = anElements.begin();
 542       if (aFamily->GetType() == SMDSAbs_Node)
 543       {
 544         for (; anElemsIter != anElements.end(); anElemsIter++)
 545         {
 546           const SMDS_MeshNode* node = static_cast<const SMDS_MeshNode*>(*anElemsIter);
 547           theSubMesh->AddNode(node);
 548         }
 549       }
 550       else
 551       {
 552         for (; anElemsIter != anElements.end(); anElemsIter++)
 553         {
 554           theSubMesh->AddElement(*anElemsIter);
 555         }
 556       }
 557     }
 558   }
 559 }
 560
 561 void DriverMED_R_SMESHDS_Mesh::CreateAllSubMeshes ()
 562 {
 563   SMESHDS_Mesh* aSMESHDSMesh = dynamic_cast<SMESHDS_Mesh*>(myMesh);
 564   if (!aSMESHDSMesh) {
 565     EXCEPTION(runtime_error,"Can not cast SMDS_Mesh to SMESHDS_Mesh");
 566   }
 567   map<int, DriverMED_FamilyPtr>::iterator aFamsIter = myFamilies.begin();
 568   for (; aFamsIter != myFamilies.end(); aFamsIter++)
 569   {
 570     DriverMED_FamilyPtr aFamily = (*aFamsIter).second;
 571     MED::TStringSet aGroupNames = aFamily->GetGroupNames();
 572     set<string>::iterator aGrNamesIter = aGroupNames.begin();
 573     for (; aGrNamesIter != aGroupNames.end(); aGrNamesIter++)
 574     {
 575       string aName = *aGrNamesIter;
 576       // Check, if this is a Group or SubMesh name
 577       if (aName.substr(0, 7) == string("SubMesh"))
 578       {
 579         int Id = atoi(string(aName).substr(7).c_str());
 580         set<const SMDS_MeshElement *> anElements = aFamily->GetElements();
 581         set<const SMDS_MeshElement *>::iterator anElemsIter = anElements.begin();
 582         if (aFamily->GetType() == SMDSAbs_Node)
 583         {
 584           for (; anElemsIter != anElements.end(); anElemsIter++)
 585           {
 586             const SMDS_MeshNode* node = static_cast<const SMDS_MeshNode*>(*anElemsIter);
 587             aSMESHDSMesh->SetNodeInVolume(node, Id);
 588 //            aSMESHDSMesh->SetNodeOnFace(node, Id);
 589 //            aSMESHDSMesh->SetNodeOnEdge(node, Id);
 590 //            aSMESHDSMesh->SetNodeOnVertex(node, Id);
 591           }
 592         }
 593         else
 594         {
 595           for (; anElemsIter != anElements.end(); anElemsIter++)
 596           {
 597             aSMESHDSMesh->SetMeshElementOnShape(*anElemsIter, Id);
 598           }
 599         }
 600       }
 601     }
 602   }
 603 }