Salome HOME
Fix Python dump of ExportPartToMED()
[modules/smesh.git] / src / SMESH_I / SMESH_Mesh_i.cxx
index 1390b2276a3b59a58c9ae6062688e5d2aa4c8ba5..8dc1b25b585e3bb0def9dcdef7cef4d507dc6adc 100644 (file)
 #include "DriverMED_W_Field.h"
 #include "DriverMED_W_SMESHDS_Mesh.h"
 #include "MED_Factory.hxx"
+#include "SMDS_LinearEdge.hxx"
 #include "SMDS_EdgePosition.hxx"
 #include "SMDS_ElemIterator.hxx"
 #include "SMDS_FacePosition.hxx"
 #include "SMDS_IteratorOnIterators.hxx"
 #include "SMDS_MeshGroup.hxx"
 #include "SMDS_SetIterator.hxx"
+#include "SMDS_StdIterator.hxx"
 #include "SMDS_VolumeTool.hxx"
 #include "SMESHDS_Command.hxx"
 #include "SMESHDS_CommandType.hxx"
@@ -104,15 +106,12 @@ int SMESH_Mesh_i::_idGenerator = 0;
 //=============================================================================
 
 SMESH_Mesh_i::SMESH_Mesh_i( PortableServer::POA_ptr thePOA,
-                            SMESH_Gen_i*            gen_i,
-                            CORBA::Long             studyId )
+                            SMESH_Gen_i*            gen_i )
 : SALOME::GenericObj_i( thePOA )
 {
-  MESSAGE("SMESH_Mesh_i");
   _impl          = NULL;
   _gen_i         = gen_i;
   _id            = _idGenerator++;
-  _studyId       = studyId;
   _editor        = NULL;
   _previewEditor = NULL;
   _preMeshInfo   = NULL;
@@ -127,8 +126,6 @@ SMESH_Mesh_i::SMESH_Mesh_i( PortableServer::POA_ptr thePOA,
 
 SMESH_Mesh_i::~SMESH_Mesh_i()
 {
-  MESSAGE("~SMESH_Mesh_i");
-
   // destroy groups
   map<int, SMESH::SMESH_GroupBase_ptr>::iterator itGr;
   for (itGr = _mapGroups.begin(); itGr != _mapGroups.end(); itGr++)
@@ -161,7 +158,7 @@ SMESH_Mesh_i::~SMESH_Mesh_i()
   }
   _mapHypo.clear();
 
-  // clear cashed shapes if no more meshes remain; (the cash is blame,
+  // clear cached shapes if no more meshes remain; (the cache is blame,
   // together with publishing, of spent time increasing in issue 22874)
   if ( _impl->NbMeshes() == 1 )
     _gen_i->GetShapeReader()->ClearClientBuffer();
@@ -242,9 +239,7 @@ GEOM::GEOM_Object_ptr SMESH_Mesh_i::GetShapeToMesh()
         for ( ; data != _geomGroupData.end(); ++data )
           if ( data->_smeshObject->_is_equivalent( _this() ))
           {
-            SALOMEDS::Study_var study = _gen_i->GetCurrentStudy();
-            if ( study->_is_nil() ) break;
-            SALOMEDS::SObject_wrap so = study->FindObjectID( data->_groupEntry.c_str() );
+            SALOMEDS::SObject_wrap so = SMESH_Gen_i::getStudyServant()->FindObjectID( data->_groupEntry.c_str() );
             CORBA::Object_var     obj = _gen_i->SObjectToObject( so );
             aShapeObj = GEOM::GEOM_Object::_narrow( obj );
             break;
@@ -302,9 +297,11 @@ void SMESH_Mesh_i::Clear() throw (SALOME::SALOME_Exception)
   catch(SALOME_Exception & S_ex) {
     THROW_SALOME_CORBA_EXCEPTION(S_ex.what(), SALOME::BAD_PARAM);
   }
-  _impl->GetMeshDS()->Modified();
 
   TPythonDump() <<  SMESH::SMESH_Mesh_var(_this()) << ".Clear()";
+
+  SMESH::SMESH_Mesh_var mesh = _this();
+  _gen_i->UpdateIcons( mesh );
 }
 
 //================================================================================
@@ -410,8 +407,8 @@ SMESH_Mesh_i::ImportMEDFile( const char* theFileName, const char* theMeshName )
   CreateGroupServants();
 
   int major, minor, release;
-  if( !MED::getMEDVersion( theFileName, major, minor, release ) )
-    major = minor = release = -1;
+  major = minor = release = 0;
+  MED::GetMEDVersion(theFileName, major, minor, release);
   _medFileInfo           = new SMESH::MedFileInfo();
   _medFileInfo->fileName = theFileName;
   _medFileInfo->fileSize = 0;
@@ -448,6 +445,13 @@ SMESH::DriverMED_ReadStatus SMESH_Mesh_i::ImportCGNSFile( const char*  theFileNa
 
   CreateGroupServants();
 
+  _medFileInfo           = new SMESH::MedFileInfo();
+  _medFileInfo->fileName = theFileName;
+  _medFileInfo->major    = 0;
+  _medFileInfo->minor    = 0;
+  _medFileInfo->release  = 0;
+  _medFileInfo->fileSize = SMESH_File( theFileName ).size();
+
   return ConvertDriverMEDReadStatus(status);
 }
 
@@ -457,9 +461,9 @@ SMESH::DriverMED_ReadStatus SMESH_Mesh_i::ImportCGNSFile( const char*  theFileNa
  */
 //================================================================================
 
-char* SMESH_Mesh_i::GetVersionString(SMESH::MED_VERSION version, CORBA::Short nbDigits)
+char* SMESH_Mesh_i::GetVersionString(CORBA::Long minor, CORBA::Short nbDigits)
 {
-  string ver = DriverMED_W_SMESHDS_Mesh::GetVersionString(MED::EVersion(version),
+  string ver = DriverMED_W_SMESHDS_Mesh::GetVersionString(minor,
                                                           nbDigits);
   return CORBA::string_dup( ver.c_str() );
 }
@@ -482,6 +486,13 @@ int SMESH_Mesh_i::ImportUNVFile( const char* theFileName )
 
   CreateGroupServants();
 
+  _medFileInfo           = new SMESH::MedFileInfo();
+  _medFileInfo->fileName = theFileName;
+  _medFileInfo->major    = 0;
+  _medFileInfo->minor    = 0;
+  _medFileInfo->release  = 0;
+  _medFileInfo->fileSize = SMESH_File( theFileName ).size();
+
   SMESH_CATCH( SMESH::throwCorbaException );
 
   return 1;
@@ -500,7 +511,18 @@ int SMESH_Mesh_i::ImportSTLFile( const char* theFileName )
   SMESH_TRY;
 
   // Read mesh with name = <theMeshName> into SMESH_Mesh
-  _impl->STLToMesh( theFileName );
+  std::string name = _impl->STLToMesh( theFileName );
+  if ( !name.empty() )
+  {
+    SALOMEDS::SObject_wrap meshSO = _gen_i->ObjectToSObject( _this() );
+    _gen_i->SetName( meshSO, name.c_str() );
+  }
+  _medFileInfo           = new SMESH::MedFileInfo();
+  _medFileInfo->fileName = theFileName;
+  _medFileInfo->major    = 0;
+  _medFileInfo->minor    = 0;
+  _medFileInfo->release  = 0;
+  _medFileInfo->fileSize = SMESH_File( theFileName ).size();
 
   SMESH_CATCH( SMESH::throwCorbaException );
 
@@ -539,6 +561,13 @@ SMESH::ComputeError* SMESH_Mesh_i::ImportGMFFile( const char* theFileName,
 
   error = _impl->GMFToMesh( theFileName, theMakeRequiredGroups );
 
+  _medFileInfo           = new SMESH::MedFileInfo();
+  _medFileInfo->fileName = theFileName;
+  _medFileInfo->major    = 0;
+  _medFileInfo->minor    = 0;
+  _medFileInfo->release  = 0;
+  _medFileInfo->fileSize = SMESH_File( theFileName ).size();
+
   SMESH_CATCH( exceptionToComputeError );
 #undef SMESH_CAUGHT
 #define SMESH_CAUGHT
@@ -562,7 +591,7 @@ SMESH::Hypothesis_Status SMESH_Mesh_i::ConvertHypothesisStatus
   switch (theStatus) {
   RETURNCASE( HYP_OK            );
   RETURNCASE( HYP_MISSING       );
-  RETURNCASE( HYP_CONCURENT     );
+  RETURNCASE( HYP_CONCURRENT    );
   RETURNCASE( HYP_BAD_PARAMETER );
   RETURNCASE( HYP_HIDDEN_ALGO   );
   RETURNCASE( HYP_HIDING_ALGO   );
@@ -607,8 +636,8 @@ SMESH_Mesh_i::AddHypothesis(GEOM::GEOM_Object_ptr       aSubShape,
   SMESH::SMESH_Mesh_var mesh( _this() );
   if ( !SMESH_Hypothesis::IsStatusFatal(status) )
   {
-    SALOMEDS::Study_var study = _gen_i->GetCurrentStudy();
-    _gen_i->AddHypothesisToShape( study, mesh, aSubShape, anHyp );
+    _gen_i->AddHypothesisToShape( mesh, aSubShape, anHyp );
+    _gen_i->UpdateIcons( mesh );
   }
   if(MYDEBUG) MESSAGE( " AddHypothesis(): status = " << status );
 
@@ -693,8 +722,8 @@ SMESH::Hypothesis_Status SMESH_Mesh_i::RemoveHypothesis(GEOM::GEOM_Object_ptr aS
 
   if ( !SMESH_Hypothesis::IsStatusFatal(status) )
   {
-    SALOMEDS::Study_var study = _gen_i->GetCurrentStudy();
-    _gen_i->RemoveHypothesisFromShape( study, mesh, aSubShape, anHyp );
+    _gen_i->RemoveHypothesisFromShape( mesh, aSubShape, anHyp );
+    _gen_i->UpdateIcons( mesh );
   }
   // Update Python script
   if(_impl->HasShapeToMesh())
@@ -864,9 +893,8 @@ SMESH::SMESH_subMesh_ptr SMESH_Mesh_i::GetSubMesh(GEOM::GEOM_Object_ptr aSubShap
       subMesh = createSubMesh( aSubShape );
     if ( _gen_i->CanPublishInStudy( subMesh ))
     {
-      SALOMEDS::Study_var study = _gen_i->GetCurrentStudy();
       SALOMEDS::SObject_wrap aSO =
-        _gen_i->PublishSubMesh( study, aMesh, subMesh, aSubShape, theName );
+        _gen_i->PublishSubMesh( aMesh, subMesh, aSubShape, theName );
       if ( !aSO->_is_nil()) {
         // Update Python script
         TPythonDump() << aSO << " = " << aMesh << ".GetSubMesh( "
@@ -895,28 +923,25 @@ void SMESH_Mesh_i::RemoveSubMesh( SMESH::SMESH_subMesh_ptr theSubMesh )
     return;
 
   GEOM::GEOM_Object_var aSubShape;
-  SALOMEDS::Study_var aStudy = _gen_i->GetCurrentStudy();
-  if ( !aStudy->_is_nil() )  {
-    // Remove submesh's SObject
-    SALOMEDS::SObject_wrap anSO = _gen_i->ObjectToSObject( aStudy, theSubMesh );
-    if ( !anSO->_is_nil() ) {
-      long aTag = SMESH_Gen_i::GetRefOnShapeTag();
-      SALOMEDS::SObject_wrap anObj, aRef;
-      if ( anSO->FindSubObject( aTag, anObj.inout() ) &&
-           anObj->ReferencedObject( aRef.inout() ))
-      {
-        CORBA::Object_var obj = aRef->GetObject();
-        aSubShape = GEOM::GEOM_Object::_narrow( obj );
-      }
-      // if ( aSubShape->_is_nil() ) // not published shape (IPAL13617)
-      //   aSubShape = theSubMesh->GetSubShape();
+  // Remove submesh's SObject
+  SALOMEDS::SObject_wrap anSO = _gen_i->ObjectToSObject( theSubMesh );
+  if ( !anSO->_is_nil() ) {
+    long aTag = SMESH_Gen_i::GetRefOnShapeTag();
+    SALOMEDS::SObject_wrap anObj, aRef;
+    if ( anSO->FindSubObject( aTag, anObj.inout() ) &&
+         anObj->ReferencedObject( aRef.inout() ))
+    {
+      CORBA::Object_var obj = aRef->GetObject();
+      aSubShape = GEOM::GEOM_Object::_narrow( obj );
+    }
+    // if ( aSubShape->_is_nil() ) // not published shape (IPAL13617)
+    //   aSubShape = theSubMesh->GetSubShape();
 
-      SALOMEDS::StudyBuilder_var builder = aStudy->NewBuilder();
-      builder->RemoveObjectWithChildren( anSO );
+    SALOMEDS::StudyBuilder_var builder = SMESH_Gen_i::getStudyServant()->NewBuilder();
+    builder->RemoveObjectWithChildren( anSO );
 
-      // Update Python script
-      TPythonDump() << SMESH::SMESH_Mesh_var( _this() ) << ".RemoveSubMesh( " << anSO << " )";
-    }
+    // Update Python script
+    TPythonDump() << SMESH::SMESH_Mesh_var( _this() ) << ".RemoveSubMesh( " << anSO << " )";
   }
 
   if ( removeSubMesh( theSubMesh, aSubShape.in() ))
@@ -946,9 +971,8 @@ SMESH::SMESH_Group_ptr SMESH_Mesh_i::CreateGroup( SMESH::ElementType theElemType
   if ( _gen_i->CanPublishInStudy( aNewGroup ) )
   {
     SMESH::SMESH_Mesh_var mesh = _this();
-    SALOMEDS::Study_var  study = _gen_i->GetCurrentStudy();
     SALOMEDS::SObject_wrap aSO =
-      _gen_i->PublishGroup( study, mesh, aNewGroup, GEOM::GEOM_Object::_nil(), theName);
+      _gen_i->PublishGroup( mesh, aNewGroup, GEOM::GEOM_Object::_nil(), theName);
     if ( !aSO->_is_nil())
       // Update Python script
       TPythonDump() << aSO << " = " << mesh << ".CreateGroup( "
@@ -983,9 +1007,8 @@ SMESH_Mesh_i::CreateGroupFromGEOM (SMESH::ElementType    theElemType,
     if ( _gen_i->CanPublishInStudy( aNewGroup ) )
     {
       SMESH::SMESH_Mesh_var mesh = _this();
-      SALOMEDS::Study_var  study = _gen_i->GetCurrentStudy();
       SALOMEDS::SObject_wrap aSO =
-        _gen_i->PublishGroup( study, mesh, aNewGroup, theGeomObj, theName );
+        _gen_i->PublishGroup( mesh, aNewGroup, theGeomObj, theName );
       if ( !aSO->_is_nil())
         TPythonDump() << aSO << " = " << mesh << ".CreateGroupFromGEOM( "
                       << theElemType << ", '" << theName << "', " << theGeomObj << " )";
@@ -1032,9 +1055,8 @@ SMESH_Mesh_i::CreateGroupFromFilter(SMESH::ElementType theElemType,
   if ( _gen_i->CanPublishInStudy( aNewGroup ) )
   {
     SMESH::SMESH_Mesh_var mesh = _this();
-    SALOMEDS::Study_var  study = _gen_i->GetCurrentStudy();
     SALOMEDS::SObject_wrap aSO =
-      _gen_i->PublishGroup( study, mesh, aNewGroup, GEOM::GEOM_Object::_nil(), theName );
+      _gen_i->PublishGroup( mesh, aNewGroup, GEOM::GEOM_Object::_nil(), theName );
 
     if ( !aSO->_is_nil())
       pd << aSO << " = " << mesh << ".CreateGroupFromFilter( "
@@ -1061,19 +1083,15 @@ void SMESH_Mesh_i::RemoveGroup( SMESH::SMESH_GroupBase_ptr theGroup )
   if ( !aGroup )
     return;
 
-  SALOMEDS::Study_var aStudy = _gen_i->GetCurrentStudy();
-  if ( !aStudy->_is_nil() )
+  SALOMEDS::SObject_wrap aGroupSO = _gen_i->ObjectToSObject( theGroup );
+  if ( !aGroupSO->_is_nil() )
   {
-    SALOMEDS::SObject_wrap aGroupSO = _gen_i->ObjectToSObject( aStudy, theGroup );
-    if ( !aGroupSO->_is_nil() )
-    {
-      // Update Python script
-      TPythonDump() << SMESH::SMESH_Mesh_var(_this()) << ".RemoveGroup( " << aGroupSO << " )";
+    // Update Python script
+    TPythonDump() << SMESH::SMESH_Mesh_var(_this()) << ".RemoveGroup( " << aGroupSO << " )";
 
-      // Remove group's SObject
-      SALOMEDS::StudyBuilder_var builder = aStudy->NewBuilder();
-      builder->RemoveObjectWithChildren( aGroupSO );
-    }
+    // Remove group's SObject
+    SALOMEDS::StudyBuilder_var builder = SMESH_Gen_i::getStudyServant()->NewBuilder();
+    builder->RemoveObjectWithChildren( aGroupSO );
   }
   aGroup->Modified(/*removed=*/true); // notify dependent Filter with FT_BelongToMeshGroup criterion
 
@@ -1100,7 +1118,8 @@ void SMESH_Mesh_i::RemoveGroupWithContents( SMESH::SMESH_GroupBase_ptr theGroup
     return;
 
   vector<int> nodeIds; // to remove nodes becoming free
-  if ( !theGroup->IsEmpty() )
+  bool isNodal = ( theGroup->GetType() == SMESH::NODE );
+  if ( !isNodal && !theGroup->IsEmpty() )
   {
     CORBA::Long elemID = theGroup->GetID( 1 );
     int nbElemNodes = GetElemNbNodes( elemID );
@@ -1108,36 +1127,46 @@ void SMESH_Mesh_i::RemoveGroupWithContents( SMESH::SMESH_GroupBase_ptr theGroup
       nodeIds.reserve( theGroup->Size() * nbElemNodes );
   }
 
-  // Remove contents
+  // Retrieve contents
   SMESH::SMESH_IDSource_var idSrc = SMESH::SMESH_IDSource::_narrow( theGroup );
   SMDS_ElemIteratorPtr     elemIt = GetElements( idSrc, theGroup->GetType() );
-  while ( elemIt->more() )
-  {
-    const SMDS_MeshElement* e = elemIt->next();
+  SMDS_StdIterator< const SMDS_MeshElement*, SMDS_ElemIteratorPtr > elemBeg( elemIt ), elemEnd;
+  std::vector< const SMDS_MeshElement* > elems( theGroup->Size() );
+  elems.assign( elemBeg, elemEnd );
+
+  TPythonDump pyDump; // Suppress dump from RemoveGroup()
 
-    SMDS_ElemIteratorPtr nIt = e->nodesIterator();
-    while ( nIt->more() )
-      nodeIds.push_back( nIt->next()->GetID() );
+  // Remove group
+  RemoveGroup( theGroup );
 
-    _impl->GetMeshDS()->RemoveElement( e );
+  // Remove contents
+  for ( size_t i = 0; i < elems.size(); ++i )
+  {
+    // if ( !_impl->GetMeshDS()->Contains( elems[i] ))
+    //   continue;
+    if ( !isNodal )
+    {
+      for ( SMDS_ElemIteratorPtr nIt = elems[i]->nodesIterator(); nIt->more(); )
+        nodeIds.push_back( nIt->next()->GetID() );
+
+      _impl->GetMeshDS()->RemoveFreeElement( elems[i], /*sm=*/0 );
+    }
+    else
+    {
+      _impl->GetMeshDS()->RemoveElement( elems[i] );
+    }
   }
 
   // Remove free nodes
-  if ( theGroup->GetType() != SMESH::NODE )
-    for ( size_t i = 0 ; i < nodeIds.size(); ++i )
-      if ( const SMDS_MeshNode* n = _impl->GetMeshDS()->FindNode( nodeIds[i] ))
-        if ( n->NbInverseElements() == 0 )
-          _impl->GetMeshDS()->RemoveFreeNode( n, /*sm=*/0 );
-
-  TPythonDump pyDump; // Supress dump from RemoveGroup()
+  for ( size_t i = 0 ; i < nodeIds.size(); ++i )
+    if ( const SMDS_MeshNode* n = _impl->GetMeshDS()->FindNode( nodeIds[i] ))
+      if ( n->NbInverseElements() == 0 )
+        _impl->GetMeshDS()->RemoveFreeNode( n, /*sm=*/0 );
 
   // Update Python script (theGroup must be alive for this)
   pyDump << SMESH::SMESH_Mesh_var(_this())
          << ".RemoveGroupWithContents( " << theGroup << " )";
 
-  // Remove group
-  RemoveGroup( theGroup );
-
   SMESH_CATCH( SMESH::throwCorbaException );
 }
 
@@ -1834,14 +1863,13 @@ void SMESH_Mesh_i::addGeomGroupData(GEOM::GEOM_Object_ptr theGeomObj,
   if ( CORBA::is_nil( theGeomObj ) || theGeomObj->GetType() != GEOM_GROUP )
     return;
   // group SO
-  SALOMEDS::Study_var    study   = _gen_i->GetCurrentStudy();
-  SALOMEDS::SObject_wrap groupSO = _gen_i->ObjectToSObject( study, theGeomObj );
+  SALOMEDS::SObject_wrap groupSO = _gen_i->ObjectToSObject( theGeomObj );
   if ( groupSO->_is_nil() )
     return;
   // group indices
   GEOM::GEOM_Gen_var geomGen = _gen_i->GetGeomEngine();
   GEOM::GEOM_IGroupOperations_wrap groupOp =
-    geomGen->GetIGroupOperations( _gen_i->GetCurrentStudyID() );
+    geomGen->GetIGroupOperations();
   GEOM::ListOfLong_var ids = groupOp->GetObjects( theGeomObj );
 
   // store data
@@ -1889,9 +1917,7 @@ TopoDS_Shape SMESH_Mesh_i::newGroupShape( TGeomGroupData & groupData)
   TopoDS_Shape newShape;
 
   // get geom group
-  SALOMEDS::Study_var study = _gen_i->GetCurrentStudy();
-  if ( study->_is_nil() ) return newShape; // means "not changed"
-  SALOMEDS::SObject_wrap groupSO = study->FindObjectID( groupData._groupEntry.c_str() );
+  SALOMEDS::SObject_wrap groupSO = SMESH_Gen_i::getStudyServant()->FindObjectID( groupData._groupEntry.c_str() );
   if ( !groupSO->_is_nil() )
   {
     CORBA::Object_var groupObj = _gen_i->SObjectToObject( groupSO );
@@ -1902,7 +1928,7 @@ TopoDS_Shape SMESH_Mesh_i::newGroupShape( TGeomGroupData & groupData)
     set<int> curIndices;
     GEOM::GEOM_Gen_var geomGen = _gen_i->GetGeomEngine();
     GEOM::GEOM_IGroupOperations_wrap groupOp =
-      geomGen->GetIGroupOperations( _gen_i->GetCurrentStudyID() );
+      geomGen->GetIGroupOperations();
     GEOM::ListOfLong_var   ids = groupOp->GetObjects( geomGroup );
     for ( CORBA::ULong i = 0; i < ids->length(); ++i )
       curIndices.insert( ids[i] );
@@ -1967,9 +1993,6 @@ void SMESH_Mesh_i::CheckGeomModif()
 {
   if ( !_impl->HasShapeToMesh() ) return;
 
-  SALOMEDS::Study_var study = _gen_i->GetCurrentStudy();
-  if ( study->_is_nil() ) return;
-
   GEOM::GEOM_Object_var mainGO = _gen_i->ShapeToGeomObject( _impl->GetShapeToMesh() );
   //if ( mainGO->_is_nil() ) return;
 
@@ -2107,7 +2130,7 @@ void SMESH_Mesh_i::CheckGeomModif()
 /*!
  * \brief Update objects depending on changed geom groups
  *
- * NPAL16168: geometrical group edition from a submesh don't modifiy mesh computation
+ * NPAL16168: geometrical group edition from a submesh don't modify mesh computation
  * issue 0020210: Update of a smesh group after modification of the associated geom group
  */
 //=============================================================================
@@ -2116,9 +2139,6 @@ void SMESH_Mesh_i::CheckGeomGroupModif()
 {
   if ( !_impl->HasShapeToMesh() ) return;
 
-  SALOMEDS::Study_var study = _gen_i->GetCurrentStudy();
-  if ( study->_is_nil() ) return;
-
   CORBA::Long nbEntities = NbNodes() + NbElements();
 
   // Check if group contents changed
@@ -2305,7 +2325,7 @@ void SMESH_Mesh_i::CheckGeomGroupModif()
         if ( _mapGroups.find( oldID ) == _mapGroups.end() )
           continue;
         // get group name
-        SALOMEDS::SObject_wrap groupSO = _gen_i->ObjectToSObject( study,_mapGroups[oldID] );
+        SALOMEDS::SObject_wrap groupSO = _gen_i->ObjectToSObject( _mapGroups[oldID] );
         CORBA::String_var      name    = groupSO->GetName();
         // update
         SMESH_GroupBase_i*  group_i    = SMESH::DownCast<SMESH_GroupBase_i*>(_mapGroups[oldID] );
@@ -2326,15 +2346,15 @@ void SMESH_Mesh_i::CheckGeomGroupModif()
   if ( newNbEntities != nbEntities )
   {
     // Add all SObjects with icons to soToUpdateIcons
-    soToUpdateIcons.push_back( _gen_i->ObjectToSObject( study, _this() )); // mesh
+    soToUpdateIcons.push_back( _gen_i->ObjectToSObject( _this() )); // mesh
 
     for (map<int, SMESH::SMESH_subMesh_ptr>::iterator i_sm = _mapSubMeshIor.begin();
          i_sm != _mapSubMeshIor.end(); ++i_sm ) // submeshes
-      soToUpdateIcons.push_back( _gen_i->ObjectToSObject( study, i_sm->second ));
+      soToUpdateIcons.push_back( _gen_i->ObjectToSObject( i_sm->second ));
 
     for ( map<int, SMESH::SMESH_GroupBase_ptr>::iterator i_gr = _mapGroups.begin();
           i_gr != _mapGroups.end(); ++i_gr ) // groups
-      soToUpdateIcons.push_back( _gen_i->ObjectToSObject( study, i_gr->second ));
+      soToUpdateIcons.push_back( _gen_i->ObjectToSObject( i_gr->second ));
   }
 
   list< SALOMEDS::SObject_wrap >::iterator so = soToUpdateIcons.begin();
@@ -2380,10 +2400,10 @@ SMESH::SMESH_Group_ptr SMESH_Mesh_i::ConvertToStandalone( SMESH::SMESH_GroupBase
 
   SALOMEDS::StudyBuilder_var builder;
   SALOMEDS::SObject_wrap     aGroupSO;
-  SALOMEDS::Study_var        aStudy = _gen_i->GetCurrentStudy();
+  SALOMEDS::Study_var        aStudy = SMESH_Gen_i::getStudyServant();
   if ( !aStudy->_is_nil() ) {
     builder  = aStudy->NewBuilder();
-    aGroupSO = _gen_i->ObjectToSObject( aStudy, theGroup );
+    aGroupSO = _gen_i->ObjectToSObject( theGroup );
     if ( !aGroupSO->_is_nil() )
     {
       // remove reference to geometry
@@ -2550,7 +2570,7 @@ SMESH::SMESH_GroupBase_ptr SMESH_Mesh_i::createGroup (SMESH::ElementType
                                                       const SMESH_PredicatePtr& thePredicate )
 {
   std::string newName;
-  if ( !theName || strlen( theName ) == 0 )
+  if ( !theName || !theName[0] )
   {
     std::set< std::string > presentNames;
     std::map<int, SMESH::SMESH_GroupBase_ptr>::const_iterator i_gr = _mapGroups.begin();
@@ -2704,17 +2724,6 @@ CORBA::Long SMESH_Mesh_i::GetId()throw(SALOME::SALOME_Exception)
   return _id;
 }
 
-//=============================================================================
-/*!
- *
- */
-//=============================================================================
-
-CORBA::Long SMESH_Mesh_i::GetStudyId()throw(SALOME::SALOME_Exception)
-{
-  return _studyId;
-}
-
 //=============================================================================
 namespace
 {
@@ -2741,6 +2750,9 @@ void SMESH_Mesh_i::onHypothesisModified()
 {
   if ( _preMeshInfo )
     _preMeshInfo->ForgetOrLoad();
+
+  SMESH::SMESH_Mesh_var mesh = _this();
+  _gen_i->UpdateIcons( mesh );
 }
 
 //=============================================================================
@@ -2947,7 +2959,7 @@ void SMESH_Mesh_i::PrepareForWriting (const char* file, bool overwrite)
     if ( !aFile.openForWriting() ) {
       msg << "You cannot create the file "
           << aFile.getName()
-          << ". Check the directory existance and access rights";
+          << ". Check the directory existence and access rights";
     }
     aFile.remove();
   }
@@ -2974,9 +2986,9 @@ string SMESH_Mesh_i::prepareMeshNameAndGroups(const char*    file,
   // Perform Export
   PrepareForWriting(file, overwrite);
   string aMeshName = "Mesh";
-  SALOMEDS::Study_var aStudy = _gen_i->GetCurrentStudy();
+  SALOMEDS::Study_var aStudy = SMESH_Gen_i::getStudyServant();
   if ( !aStudy->_is_nil() ) {
-    SALOMEDS::SObject_wrap aMeshSO = _gen_i->ObjectToSObject( aStudy, _this() );
+    SALOMEDS::SObject_wrap aMeshSO = _gen_i->ObjectToSObject(  _this() );
     if ( !aMeshSO->_is_nil() ) {
       CORBA::String_var name = aMeshSO->GetName();
       aMeshName = name;
@@ -3009,59 +3021,36 @@ string SMESH_Mesh_i::prepareMeshNameAndGroups(const char*    file,
 
 //================================================================================
 /*!
- * \brief Export to med file
+ * \brief Export to MED file
  */
 //================================================================================
 
-void SMESH_Mesh_i::ExportToMEDX (const char*        file,
-                                 CORBA::Boolean     auto_groups,
-                                 SMESH::MED_VERSION theVersion,
-                                 CORBA::Boolean     overwrite,
-                                 CORBA::Boolean     autoDimension)
+void SMESH_Mesh_i::ExportMED(const char*        file,
+                             CORBA::Boolean     auto_groups,
+                             CORBA::Long        minor,
+                             CORBA::Boolean     overwrite,
+                             CORBA::Boolean     autoDimension)
   throw(SALOME::SALOME_Exception)
 {
+  //MESSAGE("MED minor version: "<< minor);
   SMESH_TRY;
   if ( _preMeshInfo )
     _preMeshInfo->FullLoadFromFile();
 
   string aMeshName = prepareMeshNameAndGroups(file, overwrite);
-  _impl->ExportMED( file, aMeshName.c_str(), auto_groups, theVersion, 0, autoDimension );
+  _impl->ExportMED( file, aMeshName.c_str(), auto_groups, minor, 0, autoDimension );
 
-  TPythonDump() << SMESH::SMESH_Mesh_var(_this()) << ".ExportToMEDX( r'"
-                << file << "', " << auto_groups << ", "
-                << theVersion << ", " << overwrite << ", "
-                << autoDimension << " )";
+  TPythonDump() << SMESH::SMESH_Mesh_var(_this()) << ".ExportMED( r'"
+                << file << "', "
+                << "auto_groups=" <<auto_groups << ", "
+                << "minor=" << minor <<  ", "
+                << "overwrite=" << overwrite << ", "
+                << "meshPart=None, "
+                << "autoDimension=" << autoDimension << " )";
 
   SMESH_CATCH( SMESH::throwCorbaException );
 }
 
-//================================================================================
-/*!
- * \brief Export a mesh to a med file
- */
-//================================================================================
-
-void SMESH_Mesh_i::ExportToMED (const char*        file,
-                                CORBA::Boolean     auto_groups,
-                                SMESH::MED_VERSION theVersion)
-  throw(SALOME::SALOME_Exception)
-{
-  ExportToMEDX(file,auto_groups,theVersion,true);
-}
-
-//================================================================================
-/*!
- * \brief Export a mesh to a med file
- */
-//================================================================================
-
-void SMESH_Mesh_i::ExportMED (const char* file,
-                              CORBA::Boolean auto_groups)
-  throw(SALOME::SALOME_Exception)
-{
-  ExportToMEDX(file,auto_groups,SMESH::MED_V2_2,true);
-}
-
 //================================================================================
 /*!
  * \brief Export a mesh to a SAUV file
@@ -3148,9 +3137,14 @@ void SMESH_Mesh_i::ExportSTL (const char *file, const bool isascii)
   TPythonDump() << SMESH::SMESH_Mesh_var(_this())
                 << ".ExportSTL( r'" << file << "', " << isascii << " )";
 
+  CORBA::String_var name;
+  SALOMEDS::SObject_wrap so = _gen_i->ObjectToSObject( _this() );
+  if ( !so->_is_nil() )
+    name = so->GetName();
+
   // Perform Export
-  PrepareForWriting(file);
-  _impl->ExportSTL(file, isascii);
+  PrepareForWriting( file );
+  _impl->ExportSTL( file, isascii, name.in() );
 }
 
 //================================================================================
@@ -3162,13 +3156,14 @@ void SMESH_Mesh_i::ExportSTL (const char *file, const bool isascii)
 void SMESH_Mesh_i::ExportPartToMED(SMESH::SMESH_IDSource_ptr meshPart,
                                    const char*               file,
                                    CORBA::Boolean            auto_groups,
-                                   SMESH::MED_VERSION        version,
+                                   CORBA::Long               minor,
                                    CORBA::Boolean            overwrite,
                                    CORBA::Boolean            autoDimension,
                                    const GEOM::ListOfFields& fields,
                                    const char*               geomAssocFields)
   throw (SALOME::SALOME_Exception)
 {
+  //MESSAGE("MED minor version: "<< minor);
   SMESH_TRY;
   if ( _preMeshInfo )
     _preMeshInfo->FullLoadFromFile();
@@ -3215,8 +3210,8 @@ void SMESH_Mesh_i::ExportPartToMED(SMESH::SMESH_IDSource_ptr meshPart,
        SMESH::DownCast< SMESH_Mesh_i* >( meshPart ))
   {
     aMeshName = prepareMeshNameAndGroups(file, overwrite);
-    _impl->ExportMED( file, aMeshName.c_str(), auto_groups,
-                      version, 0, autoDimension, /*addODOnVertices=*/have0dField);
+    _impl->ExportMED( file, aMeshName.c_str(), auto_groups, minor,
+                      0, autoDimension, /*addODOnVertices=*/have0dField);
     meshDS = _impl->GetMeshDS();
   }
   else
@@ -3226,17 +3221,15 @@ void SMESH_Mesh_i::ExportPartToMED(SMESH::SMESH_IDSource_ptr meshPart,
 
     PrepareForWriting(file, overwrite);
 
-    SALOMEDS::Study_var aStudy = _gen_i->GetCurrentStudy();
-    if ( !aStudy->_is_nil() ) {
-      SALOMEDS::SObject_wrap SO = _gen_i->ObjectToSObject( aStudy, meshPart );
-      if ( !SO->_is_nil() ) {
-        CORBA::String_var name = SO->GetName();
-        aMeshName = name;
-      }
+    SALOMEDS::SObject_wrap SO = _gen_i->ObjectToSObject( meshPart );
+    if ( !SO->_is_nil() ) {
+      CORBA::String_var name = SO->GetName();
+      aMeshName = name;
     }
+
     SMESH_MeshPartDS* partDS = new SMESH_MeshPartDS( meshPart );
-    _impl->ExportMED( file, aMeshName.c_str(), auto_groups,
-                      version, partDS, autoDimension, /*addODOnVertices=*/have0dField);
+    _impl->ExportMED( file, aMeshName.c_str(), auto_groups, minor,
+                      partDS, autoDimension, /*addODOnVertices=*/have0dField);
     meshDS = tmpDSDeleter._obj = partDS;
   }
 
@@ -3261,10 +3254,14 @@ void SMESH_Mesh_i::ExportPartToMED(SMESH::SMESH_IDSource_ptr meshPart,
     goList[i] = gbo;
   }
   TPythonDump() << _this() << ".ExportPartToMED( "
-                << meshPart << ", r'" << file << "', "
-                << auto_groups << ", " << version << ", " << overwrite << ", "
-                << autoDimension << ", " << goList
-                << ", '" << ( geomAssocFields ? geomAssocFields : "" ) << "'" << " )";
+                << meshPart << ", r'"
+                << file << "', "
+                << auto_groups << ", "
+                << minor << ", "
+                << overwrite << ", "
+                << autoDimension << ", "
+                << goList << ", '"
+                << ( geomAssocFields ? geomAssocFields : "" ) << "'" << " )";
 
   SMESH_CATCH( SMESH::throwCorbaException );
 }
@@ -3286,9 +3283,9 @@ void SMESH_Mesh_i::exportMEDFields( DriverMED_W_Field&        fieldWriter,
       ( !geomAssocFields || !geomAssocFields[0] ))
     return;
 
-  std::vector< double > dblVals( meshDS->MaxShapeIndex()+1 );
-  std::vector< int >    intVals( meshDS->MaxShapeIndex()+1 );
-  std::vector< int >    subIdsByDim[ 4 ];
+  std::vector< std::vector< double > > dblVals;
+  std::vector< std::vector< int > >    intVals;
+  std::vector< int >                   subIdsByDim[ 4 ];
   const double noneDblValue = 0.;
   const double noneIntValue = 0;
 
@@ -3328,6 +3325,9 @@ void SMESH_Mesh_i::exportMEDFields( DriverMED_W_Field&        fieldWriter,
     for ( size_t iC = 0; iC < comps->length(); ++iC )
       fieldWriter.SetCompName( iC, comps[ iC ].in() );
 
+    dblVals.resize( comps->length() );
+    intVals.resize( comps->length() );
+
     // find sub-shape IDs
 
     std::vector< int >& subIds = subIdsByDim[ dim ];
@@ -3353,6 +3353,17 @@ void SMESH_Mesh_i::exportMEDFields( DriverMED_W_Field&        fieldWriter,
       fieldWriter.SetDtIt( int( stamp ), int( id ));
 
       // fill dblVals or intVals
+      for ( size_t iC = 0; iC < comps->length(); ++iC )
+        if ( dataType == GEOM::FDT_Double )
+        {
+          dblVals[ iC ].clear();
+          dblVals[ iC ].resize( meshDS->MaxShapeIndex()+1, 0 );
+        }
+        else
+        {
+          intVals[ iC ].clear();
+          intVals[ iC ].resize( meshDS->MaxShapeIndex()+1, 0 );
+        }
       switch ( dataType )
       {
       case GEOM::FDT_Double:
@@ -3360,10 +3371,11 @@ void SMESH_Mesh_i::exportMEDFields( DriverMED_W_Field&        fieldWriter,
         GEOM::GEOM_DoubleFieldStep_var dblStep = GEOM::GEOM_DoubleFieldStep::_narrow( step );
         if ( dblStep->_is_nil() ) continue;
         GEOM::ListOfDouble_var vv = dblStep->GetValues();
-        if ( vv->length() != subIds.size() )
+        if ( vv->length() != subIds.size() * comps->length() )
           THROW_SALOME_CORBA_EXCEPTION( METH "BUG: wrong nb subIds", SALOME::INTERNAL_ERROR );
-        for ( size_t i = 0; i < vv->length(); ++i )
-          dblVals[ subIds[ i ]] = vv[ i ];
+        for ( size_t iS = 0, iV = 0; iS < subIds.size(); ++iS )
+          for ( size_t iC = 0; iC < comps->length(); ++iC )
+            dblVals[ iC ][ subIds[ iS ]] = vv[ iV++ ];
         break;
       }
       case GEOM::FDT_Int:
@@ -3371,10 +3383,11 @@ void SMESH_Mesh_i::exportMEDFields( DriverMED_W_Field&        fieldWriter,
         GEOM::GEOM_IntFieldStep_var intStep = GEOM::GEOM_IntFieldStep::_narrow( step );
         if ( intStep->_is_nil() ) continue;
         GEOM::ListOfLong_var vv = intStep->GetValues();
-        if ( vv->length() != subIds.size() )
+        if ( vv->length() != subIds.size() * comps->length() )
           THROW_SALOME_CORBA_EXCEPTION( METH "BUG: wrong nb subIds", SALOME::INTERNAL_ERROR );
-        for ( size_t i = 0; i < vv->length(); ++i )
-          intVals[ subIds[ i ]] = (int) vv[ i ];
+        for ( size_t iS = 0, iV = 0; iS < subIds.size(); ++iS )
+          for ( size_t iC = 0; iC < comps->length(); ++iC )
+            intVals[ iC ][ subIds[ iS ]] = (int) vv[ iV++ ];
         break;
       }
       case GEOM::FDT_Bool:
@@ -3382,10 +3395,11 @@ void SMESH_Mesh_i::exportMEDFields( DriverMED_W_Field&        fieldWriter,
         GEOM::GEOM_BoolFieldStep_var boolStep = GEOM::GEOM_BoolFieldStep::_narrow( step );
         if ( boolStep->_is_nil() ) continue;
         GEOM::short_array_var vv = boolStep->GetValues();
-        if ( vv->length() != subIds.size() )
+        if ( vv->length() != subIds.size() * comps->length() )
           THROW_SALOME_CORBA_EXCEPTION( METH "BUG: wrong nb subIds", SALOME::INTERNAL_ERROR );
-        for ( size_t i = 0; i < vv->length(); ++i )
-          intVals[ subIds[ i ]] = (int) vv[ i ];
+        for ( size_t iS = 0, iV = 0; iS < subIds.size(); ++iS )
+          for ( size_t iC = 0; iC < comps->length(); ++iC )
+            intVals[ iC ][ subIds[ iS ]] = (int) vv[ iV++ ];
         break;
       }
       default: continue;
@@ -3398,20 +3412,24 @@ void SMESH_Mesh_i::exportMEDFields( DriverMED_W_Field&        fieldWriter,
         {
           const SMDS_MeshElement* e = elemIt->next();
           const int shapeID = e->getshapeId();
-          if ( shapeID < 1 || shapeID >= (int) dblVals.size() )
-            fieldWriter.AddValue( noneDblValue );
+          if ( shapeID < 1 || shapeID >= (int) dblVals[0].size() )
+            for ( size_t iC = 0; iC < comps->length(); ++iC )
+              fieldWriter.AddValue( noneDblValue );
           else
-            fieldWriter.AddValue( dblVals[ shapeID ]);
+            for ( size_t iC = 0; iC < comps->length(); ++iC )
+              fieldWriter.AddValue( dblVals[ iC ][ shapeID ]);
         }
       else
         while ( elemIt->more() )
         {
           const SMDS_MeshElement* e = elemIt->next();
           const int shapeID = e->getshapeId();
-          if ( shapeID < 1 || shapeID >= (int) intVals.size() )
-            fieldWriter.AddValue( (double) noneIntValue );
+          if ( shapeID < 1 || shapeID >= (int) intVals[0].size() )
+            for ( size_t iC = 0; iC < comps->length(); ++iC )
+              fieldWriter.AddValue( (double) noneIntValue );
           else
-            fieldWriter.AddValue( (double) intVals[ shapeID ]);
+            for ( size_t iC = 0; iC < comps->length(); ++iC )
+              fieldWriter.AddValue( (double) intVals[ iC ][ shapeID ]);
         }
 
       // write a step
@@ -3578,8 +3596,13 @@ void SMESH_Mesh_i::ExportPartToSTL(::SMESH::SMESH_IDSource_ptr meshPart,
 
   PrepareForWriting(file);
 
+  CORBA::String_var name;
+  SALOMEDS::SObject_wrap so = _gen_i->ObjectToSObject( meshPart );
+  if ( !so->_is_nil() )
+    name = so->GetName();
+
   SMESH_MeshPartDS partDS( meshPart );
-  _impl->ExportSTL(file, isascii, &partDS);
+  _impl->ExportSTL( file, isascii, name.in(), &partDS );
 
   TPythonDump() << SMESH::SMESH_Mesh_var(_this()) << ".ExportPartToSTL( "
                 << meshPart<< ", r'" << file << "', " << isascii << ")";
@@ -3593,7 +3616,8 @@ void SMESH_Mesh_i::ExportPartToSTL(::SMESH::SMESH_IDSource_ptr meshPart,
 
 void SMESH_Mesh_i::ExportCGNS(::SMESH::SMESH_IDSource_ptr meshPart,
                               const char*                 file,
-                              CORBA::Boolean              overwrite)
+                              CORBA::Boolean              overwrite,
+                              CORBA::Boolean              groupElemsByType)
   throw (SALOME::SALOME_Exception)
 {
 #ifdef WITH_CGNS
@@ -3604,15 +3628,18 @@ void SMESH_Mesh_i::ExportCGNS(::SMESH::SMESH_IDSource_ptr meshPart,
   PrepareForWriting(file,overwrite);
 
   std::string meshName("");
-  SALOMEDS::Study_var study = _gen_i->GetCurrentStudy();
-  SALOMEDS::SObject_wrap so = _gen_i->ObjectToSObject( study, meshPart );
+  SALOMEDS::SObject_wrap so = _gen_i->ObjectToSObject( meshPart );
   if ( !so->_is_nil() )
   {
     CORBA::String_var name = so->GetName();
     meshName = name.in();
   }
+  SMESH_TRY;
+
   SMESH_MeshPartDS partDS( meshPart );
-  _impl->ExportCGNS(file, &partDS, meshName.c_str() );
+  _impl->ExportCGNS(file, &partDS, meshName.c_str(), groupElemsByType );
+
+  SMESH_CATCH( SMESH::throwCorbaException );
 
   TPythonDump() << SMESH::SMESH_Mesh_var(_this()) << ".ExportCGNS( "
                 << meshPart<< ", r'" << file << "', " << overwrite << ")";
@@ -4056,14 +4083,14 @@ SMESH::long_array* SMESH_Mesh_i::GetNodesId()
     _preMeshInfo->FullLoadFromFile();
 
   SMESH::long_array_var aResult = new SMESH::long_array();
-  SMESHDS_Mesh* aSMESHDS_Mesh = _impl->GetMeshDS();
+  SMESHDS_Mesh* aMeshDS = _impl->GetMeshDS();
 
-  if ( aSMESHDS_Mesh == NULL )
+  if ( aMeshDS == NULL )
     return aResult._retn();
 
   long nbNodes = NbNodes();
   aResult->length( nbNodes );
-  SMDS_NodeIteratorPtr anIt = aSMESHDS_Mesh->nodesIterator(/*idInceasingOrder=*/true);
+  SMDS_NodeIteratorPtr anIt = aMeshDS->nodesIterator();
   for ( int i = 0, n = nbNodes; i < n && anIt->more(); i++ )
     aResult[i] = anIt->next()->GetID();
 
@@ -4079,7 +4106,7 @@ SMESH::long_array* SMESH_Mesh_i::GetNodesId()
 SMESH::ElementType SMESH_Mesh_i::GetElementType( const CORBA::Long id, const bool iselem )
   throw (SALOME::SALOME_Exception)
 {
-  SMESH::ElementType type;
+  SMESH::ElementType type = SMESH::ALL;
   SMESH_TRY;
 
   if ( _preMeshInfo )
@@ -4227,7 +4254,7 @@ SMESH::long_array* SMESH_Mesh_i::GetSubMeshNodesId(const CORBA::Long ShapeID,
 SMESH::ElementType SMESH_Mesh_i::GetSubMeshElementType(const CORBA::Long ShapeID)
   throw (SALOME::SALOME_Exception)
 {
-  SMESH::ElementType type;
+  SMESH::ElementType type = SMESH::ALL;
 
   SMESH_TRY;
   if ( _preMeshInfo )
@@ -4265,8 +4292,7 @@ CORBA::LongLong SMESH_Mesh_i::GetMeshPtr()
     _preMeshInfo->FullLoadFromFile();
 
   CORBA::LongLong pointeur = CORBA::LongLong(_impl);
-  if ( MYDEBUG )
-    MESSAGE("CORBA::LongLong SMESH_Mesh_i::GetMeshPtr() "<<pointeur);
+  if ( MYDEBUG ) MESSAGE("CORBA::LongLong SMESH_Mesh_i::GetMeshPtr() "<<pointeur);
   return pointeur;
 }
 
@@ -4284,12 +4310,12 @@ SMESH::double_array* SMESH_Mesh_i::GetNodeXYZ(const CORBA::Long id)
     _preMeshInfo->FullLoadFromFile();
 
   SMESH::double_array_var aResult = new SMESH::double_array();
-  SMESHDS_Mesh* aSMESHDS_Mesh = _impl->GetMeshDS();
-  if ( aSMESHDS_Mesh == NULL )
+  SMESHDS_Mesh* aMeshDS = _impl->GetMeshDS();
+  if ( aMeshDS == NULL )
     return aResult._retn();
 
   // find node
-  const SMDS_MeshNode* aNode = aSMESHDS_Mesh->FindNode(id);
+  const SMDS_MeshNode* aNode = aMeshDS->FindNode(id);
   if(!aNode)
     return aResult._retn();
 
@@ -4315,12 +4341,12 @@ SMESH::long_array* SMESH_Mesh_i::GetNodeInverseElements(const CORBA::Long id)
     _preMeshInfo->FullLoadFromFile();
 
   SMESH::long_array_var aResult = new SMESH::long_array();
-  SMESHDS_Mesh* aSMESHDS_Mesh = _impl->GetMeshDS();
-  if ( aSMESHDS_Mesh == NULL )
+  SMESHDS_Mesh* aMeshDS = _impl->GetMeshDS();
+  if ( aMeshDS == NULL )
     return aResult._retn();
 
   // find node
-  const SMDS_MeshNode* aNode = aSMESHDS_Mesh->FindNode(id);
+  const SMDS_MeshNode* aNode = aMeshDS->FindNode(id);
   if(!aNode)
     return aResult._retn();
 
@@ -4362,17 +4388,16 @@ SMESH::NodePosition* SMESH_Mesh_i::GetNodePosition(CORBA::Long NodeID)
       case SMDS_TOP_EDGE:
         aNodePosition->shapeType = GEOM::EDGE;
         aNodePosition->params.length(1);
-        aNodePosition->params[0] =
-          static_cast<SMDS_EdgePosition*>( pos )->GetUParameter();
+        aNodePosition->params[0] = SMDS_EdgePositionPtr( pos )->GetUParameter();
         break;
-      case SMDS_TOP_FACE:
+      case SMDS_TOP_FACE: {
+        SMDS_FacePositionPtr fPos = pos;
         aNodePosition->shapeType = GEOM::FACE;
         aNodePosition->params.length(2);
-        aNodePosition->params[0] =
-          static_cast<SMDS_FacePosition*>( pos )->GetUParameter();
-        aNodePosition->params[1] =
-          static_cast<SMDS_FacePosition*>( pos )->GetVParameter();
+        aNodePosition->params[0] = fPos->GetUParameter();
+        aNodePosition->params[1] = fPos->GetVParameter();
         break;
+      }
       case SMDS_TOP_VERTEX:
         aNodePosition->shapeType = GEOM::VERTEX;
         break;
@@ -4447,12 +4472,12 @@ CORBA::Long SMESH_Mesh_i::GetShapeID(const CORBA::Long id)
   if ( _preMeshInfo )
     _preMeshInfo->FullLoadFromFile();
 
-  SMESHDS_Mesh* aSMESHDS_Mesh = _impl->GetMeshDS();
-  if ( aSMESHDS_Mesh == NULL )
+  SMESHDS_Mesh* aMeshDS = _impl->GetMeshDS();
+  if ( aMeshDS == NULL )
     return -1;
 
   // try to find node
-  const SMDS_MeshNode* aNode = aSMESHDS_Mesh->FindNode(id);
+  const SMDS_MeshNode* aNode = aMeshDS->FindNode(id);
   if(aNode) {
     return aNode->getshapeId();
   }
@@ -4474,12 +4499,12 @@ CORBA::Long SMESH_Mesh_i::GetShapeIDForElem(const CORBA::Long id)
   if ( _preMeshInfo )
     _preMeshInfo->FullLoadFromFile();
 
-  SMESHDS_Mesh* aSMESHDS_Mesh = _impl->GetMeshDS();
-  if ( aSMESHDS_Mesh == NULL )
+  SMESHDS_Mesh* aMeshDS = _impl->GetMeshDS();
+  if ( aMeshDS == NULL )
     return -1;
 
   // try to find element
-  const SMDS_MeshElement* elem = aSMESHDS_Mesh->FindElement(id);
+  const SMDS_MeshElement* elem = aMeshDS->FindElement(id);
   if(!elem)
     return -1;
 
@@ -4504,10 +4529,10 @@ CORBA::Long SMESH_Mesh_i::GetElemNbNodes(const CORBA::Long id)
   if ( _preMeshInfo )
     _preMeshInfo->FullLoadFromFile();
 
-  SMESHDS_Mesh* aSMESHDS_Mesh = _impl->GetMeshDS();
-  if ( aSMESHDS_Mesh == NULL ) return -1;
+  SMESHDS_Mesh* aMeshDS = _impl->GetMeshDS();
+  if ( aMeshDS == NULL ) return -1;
   // try to find element
-  const SMDS_MeshElement* elem = aSMESHDS_Mesh->FindElement(id);
+  const SMDS_MeshElement* elem = aMeshDS->FindElement(id);
   if(!elem) return -1;
   return elem->NbNodes();
 }
@@ -4526,9 +4551,9 @@ CORBA::Long SMESH_Mesh_i::GetElemNode(const CORBA::Long id, const CORBA::Long in
   if ( _preMeshInfo )
     _preMeshInfo->FullLoadFromFile();
 
-  SMESHDS_Mesh* aSMESHDS_Mesh = _impl->GetMeshDS();
-  if ( aSMESHDS_Mesh == NULL ) return -1;
-  const SMDS_MeshElement* elem = aSMESHDS_Mesh->FindElement(id);
+  SMESHDS_Mesh* aMeshDS = _impl->GetMeshDS();
+  if ( aMeshDS == NULL ) return -1;
+  const SMDS_MeshElement* elem = aMeshDS->FindElement(id);
   if(!elem) return -1;
   if( index>=elem->NbNodes() || index<0 ) return -1;
   return elem->GetNode(index)->GetID();
@@ -4546,9 +4571,9 @@ SMESH::long_array* SMESH_Mesh_i::GetElemNodes(const CORBA::Long id)
     _preMeshInfo->FullLoadFromFile();
 
   SMESH::long_array_var aResult = new SMESH::long_array();
-  if ( SMESHDS_Mesh* aSMESHDS_Mesh = _impl->GetMeshDS() )
+  if ( SMESHDS_Mesh* aMeshDS = _impl->GetMeshDS() )
   {
-    if ( const SMDS_MeshElement* elem = aSMESHDS_Mesh->FindElement(id) )
+    if ( const SMDS_MeshElement* elem = aMeshDS->FindElement(id) )
     {
       aResult->length( elem->NbNodes() );
       for ( int i = 0; i < elem->NbNodes(); ++i )
@@ -4570,13 +4595,13 @@ CORBA::Boolean SMESH_Mesh_i::IsMediumNode(const CORBA::Long ide, const CORBA::Lo
   if ( _preMeshInfo )
     _preMeshInfo->FullLoadFromFile();
 
-  SMESHDS_Mesh* aSMESHDS_Mesh = _impl->GetMeshDS();
-  if ( aSMESHDS_Mesh == NULL ) return false;
+  SMESHDS_Mesh* aMeshDS = _impl->GetMeshDS();
+  if ( aMeshDS == NULL ) return false;
   // try to find node
-  const SMDS_MeshNode* aNode = aSMESHDS_Mesh->FindNode(idn);
+  const SMDS_MeshNode* aNode = aMeshDS->FindNode(idn);
   if(!aNode) return false;
   // try to find element
-  const SMDS_MeshElement* elem = aSMESHDS_Mesh->FindElement(ide);
+  const SMDS_MeshElement* elem = aMeshDS->FindElement(ide);
   if(!elem) return false;
 
   return elem->IsMediumNode(aNode);
@@ -4596,11 +4621,11 @@ CORBA::Boolean SMESH_Mesh_i::IsMediumNodeOfAnyElem(const CORBA::Long idn,
   if ( _preMeshInfo )
     _preMeshInfo->FullLoadFromFile();
 
-  SMESHDS_Mesh* aSMESHDS_Mesh = _impl->GetMeshDS();
-  if ( aSMESHDS_Mesh == NULL ) return false;
+  SMESHDS_Mesh* aMeshDS = _impl->GetMeshDS();
+  if ( aMeshDS == NULL ) return false;
 
   // try to find node
-  const SMDS_MeshNode* aNode = aSMESHDS_Mesh->FindNode(idn);
+  const SMDS_MeshNode* aNode = aMeshDS->FindNode(idn);
   if(!aNode) return false;
 
   SMESH_MesherHelper aHelper( *(_impl) );
@@ -4626,9 +4651,9 @@ CORBA::Long SMESH_Mesh_i::ElemNbEdges(const CORBA::Long id)
   if ( _preMeshInfo )
     _preMeshInfo->FullLoadFromFile();
 
-  SMESHDS_Mesh* aSMESHDS_Mesh = _impl->GetMeshDS();
-  if ( aSMESHDS_Mesh == NULL ) return -1;
-  const SMDS_MeshElement* elem = aSMESHDS_Mesh->FindElement(id);
+  SMESHDS_Mesh* aMeshDS = _impl->GetMeshDS();
+  if ( aMeshDS == NULL ) return -1;
+  const SMDS_MeshElement* elem = aMeshDS->FindElement(id);
   if(!elem) return -1;
   return elem->NbEdges();
 }
@@ -4645,9 +4670,9 @@ CORBA::Long SMESH_Mesh_i::ElemNbFaces(const CORBA::Long id)
   if ( _preMeshInfo )
     _preMeshInfo->FullLoadFromFile();
 
-  SMESHDS_Mesh* aSMESHDS_Mesh = _impl->GetMeshDS();
-  if ( aSMESHDS_Mesh == NULL ) return -1;
-  const SMDS_MeshElement* elem = aSMESHDS_Mesh->FindElement(id);
+  SMESHDS_Mesh* aMeshDS = _impl->GetMeshDS();
+  if ( aMeshDS == NULL ) return -1;
+  const SMDS_MeshElement* elem = aMeshDS->FindElement(id);
   if(!elem) return -1;
   return elem->NbFaces();
 }
@@ -4664,9 +4689,9 @@ SMESH::long_array* SMESH_Mesh_i::GetElemFaceNodes(CORBA::Long  elemId,
     _preMeshInfo->FullLoadFromFile();
 
   SMESH::long_array_var aResult = new SMESH::long_array();
-  if ( SMESHDS_Mesh* aSMESHDS_Mesh = _impl->GetMeshDS() )
+  if ( SMESHDS_Mesh* aMeshDS = _impl->GetMeshDS() )
   {
-    if ( const SMDS_MeshElement* elem = aSMESHDS_Mesh->FindElement(elemId) )
+    if ( const SMDS_MeshElement* elem = aMeshDS->FindElement(elemId) )
     {
       SMDS_VolumeTool vtool( elem );
       if ( faceIndex < vtool.NbFaces() )
@@ -4737,6 +4762,35 @@ CORBA::Long SMESH_Mesh_i::FindElementByNodes(const SMESH::long_array& nodes)
   return elemID;
 }
 
+//================================================================================
+/*!
+ * \brief Return elements including all given nodes.
+ */
+//================================================================================
+
+SMESH::long_array* SMESH_Mesh_i::GetElementsByNodes(const SMESH::long_array& nodes,
+                                                    SMESH::ElementType       elemType)
+{
+  if ( _preMeshInfo )
+    _preMeshInfo->FullLoadFromFile();
+
+  SMESH::long_array_var result = new SMESH::long_array();
+
+  if ( SMESHDS_Mesh* mesh = _impl->GetMeshDS() )
+  {
+    vector< const SMDS_MeshNode * > nn( nodes.length() );
+    for ( CORBA::ULong i = 0; i < nodes.length(); ++i )
+      nn[i] = mesh->FindNode( nodes[i] );
+
+    std::vector<const SMDS_MeshElement *> elems;
+    mesh->GetElementsByNodes( nn, elems, (SMDSAbs_ElementType) elemType );
+    result->length( elems.size() );
+    for ( size_t i = 0; i < elems.size(); ++i )
+      result[i] = elems[i]->GetID();
+  }
+  return result._retn();
+}
+
 //=============================================================================
 /*!
  * Returns true if given element is polygon
@@ -4748,9 +4802,9 @@ CORBA::Boolean SMESH_Mesh_i::IsPoly(const CORBA::Long id)
   if ( _preMeshInfo )
     _preMeshInfo->FullLoadFromFile();
 
-  SMESHDS_Mesh* aSMESHDS_Mesh = _impl->GetMeshDS();
-  if ( aSMESHDS_Mesh == NULL ) return false;
-  const SMDS_MeshElement* elem = aSMESHDS_Mesh->FindElement(id);
+  SMESHDS_Mesh* aMeshDS = _impl->GetMeshDS();
+  if ( aMeshDS == NULL ) return false;
+  const SMDS_MeshElement* elem = aMeshDS->FindElement(id);
   if(!elem) return false;
   return elem->IsPoly();
 }
@@ -4767,9 +4821,9 @@ CORBA::Boolean SMESH_Mesh_i::IsQuadratic(const CORBA::Long id)
   if ( _preMeshInfo )
     _preMeshInfo->FullLoadFromFile();
 
-  SMESHDS_Mesh* aSMESHDS_Mesh = _impl->GetMeshDS();
-  if ( aSMESHDS_Mesh == NULL ) return false;
-  const SMDS_MeshElement* elem = aSMESHDS_Mesh->FindElement(id);
+  SMESHDS_Mesh* aMeshDS = _impl->GetMeshDS();
+  if ( aMeshDS == NULL ) return false;
+  const SMDS_MeshElement* elem = aMeshDS->FindElement(id);
   if(!elem) return false;
   return elem->IsQuadratic();
 }
@@ -4786,7 +4840,7 @@ CORBA::Double SMESH_Mesh_i::GetBallDiameter(CORBA::Long id)
     _preMeshInfo->FullLoadFromFile();
 
   if ( const SMDS_BallElement* ball =
-       dynamic_cast<const SMDS_BallElement*>( _impl->GetMeshDS()->FindElement( id )))
+       SMDS_Mesh::DownCast<SMDS_BallElement>( _impl->GetMeshDS()->FindElement( id )))
     return ball->GetDiameter();
 
   return 0;
@@ -4804,11 +4858,11 @@ SMESH::double_array* SMESH_Mesh_i::BaryCenter(const CORBA::Long id)
     _preMeshInfo->FullLoadFromFile();
 
   SMESH::double_array_var aResult = new SMESH::double_array();
-  SMESHDS_Mesh* aSMESHDS_Mesh = _impl->GetMeshDS();
-  if ( aSMESHDS_Mesh == NULL )
+  SMESHDS_Mesh* aMeshDS = _impl->GetMeshDS();
+  if ( aMeshDS == NULL )
     return aResult._retn();
 
-  const SMDS_MeshElement* elem = aSMESHDS_Mesh->FindElement(id);
+  const SMDS_MeshElement* elem = aMeshDS->FindElement(id);
   if(!elem)
     return aResult._retn();
 
@@ -4868,12 +4922,14 @@ SMESH_Mesh_i::MakeGroupsOfBadInputElements( int         theSubShapeID,
   {
     // compute error
     SMESH_ComputeErrorPtr error = sm->GetComputeError();
-    if ( error && !error->myBadElements.empty())
+    if ( error && error->HasBadElems() )
     {
       // sort bad elements by type
       vector< const SMDS_MeshElement* > elemsByType[ SMDSAbs_NbElementTypes ];
-      list<const SMDS_MeshElement*>::iterator elemIt  = error->myBadElements.begin();
-      list<const SMDS_MeshElement*>::iterator elemEnd = error->myBadElements.end();
+      const list<const SMDS_MeshElement*>& badElems =
+        static_cast<SMESH_BadInputElements*>( error.get() )->myBadElements;
+      list<const SMDS_MeshElement*>::const_iterator elemIt  = badElems.begin();
+      list<const SMDS_MeshElement*>::const_iterator elemEnd = badElems.end();
       for ( ; elemIt != elemEnd; ++elemIt )
       {
         const SMDS_MeshElement* elem = *elemIt;
@@ -4915,10 +4971,9 @@ SMESH_Mesh_i::MakeGroupsOfBadInputElements( int         theSubShapeID,
         groups[ ++iG ] = createGroup( SMESH::ElementType(i), theGroupName );
         if ( _gen_i->CanPublishInStudy( groups[ iG ] ))
         {
-          SALOMEDS::Study_var  study = _gen_i->GetCurrentStudy();
           SMESH::SMESH_Mesh_var mesh = _this();
           SALOMEDS::SObject_wrap aSO =
-            _gen_i->PublishGroup( study, mesh, groups[ iG ],
+            _gen_i->PublishGroup( mesh, groups[ iG ],
                                  GEOM::GEOM_Object::_nil(), theGroupName);
         }
         SMESH_GroupBase_i* grp_i = SMESH::DownCast< SMESH_GroupBase_i* >( groups[ iG ]);
@@ -4942,7 +4997,6 @@ SMESH_Mesh_i::MakeGroupsOfBadInputElements( int         theSubShapeID,
 
 void SMESH_Mesh_i::CreateGroupServants()
 {
-  SALOMEDS::Study_var  aStudy = _gen_i->GetCurrentStudy();
   SMESH::SMESH_Mesh_var aMesh = _this();
 
   set<int> addedIDs;
@@ -4979,10 +5033,8 @@ void SMESH_Mesh_i::CreateGroupServants()
     else        { nextId = 0; } // avoid "unused variable" warning in release mode
 
     // publishing the groups in the study
-    if ( !aStudy->_is_nil() ) {
-      GEOM::GEOM_Object_var shapeVar = _gen_i->ShapeToGeomObject( shape );
-      _gen_i->PublishGroup( aStudy, aMesh, groupVar, shapeVar, group->GetName());
-    }
+    GEOM::GEOM_Object_var shapeVar = _gen_i->ShapeToGeomObject( shape );
+    _gen_i->PublishGroup( aMesh, groupVar, shapeVar, group->GetName());
   }
   if ( !addedIDs.empty() )
   {
@@ -4997,6 +5049,17 @@ void SMESH_Mesh_i::CreateGroupServants()
   }
 }
 
+//=============================================================================
+/*!
+ * \brief Return true if all sub-meshes are computed OK - to update an icon
+ */
+//=============================================================================
+
+bool SMESH_Mesh_i::IsComputedOK()
+{
+  return _impl->IsComputedOK();
+}
+
 //=============================================================================
 /*!
  * \brief Return groups cantained in _mapGroups by their IDs
@@ -5037,6 +5100,48 @@ SMESH::MedFileInfo* SMESH_Mesh_i::GetMEDFileInfo()
   return res._retn();
 }
 
+//=======================================================================
+//function : FileInfoToString
+//purpose  : Persistence of file info
+//=======================================================================
+
+std::string SMESH_Mesh_i::FileInfoToString()
+{
+  std::string s;
+  if ( &_medFileInfo.in() && _medFileInfo->fileName[0] )
+  {
+    s = SMESH_Comment( _medFileInfo->fileSize )
+      << " " << _medFileInfo->major
+      << " " << _medFileInfo->minor
+      << " " << _medFileInfo->release
+      << " " << _medFileInfo->fileName;
+  }
+  return s;
+}
+
+//=======================================================================
+//function : FileInfoFromString
+//purpose  : Persistence of file info
+//=======================================================================
+
+void SMESH_Mesh_i::FileInfoFromString(const std::string& info)
+{
+  std::string size, major, minor, release, fileName;
+  std::istringstream is(info);
+  is >> size >> major >> minor >> release;
+  fileName = info.data() + ( size.size()   + 1 +
+                             major.size()  + 1 +
+                             minor.size()  + 1 +
+                             release.size()+ 1 );
+
+  _medFileInfo           = new SMESH::MedFileInfo();
+  _medFileInfo->fileName = fileName.c_str();
+  _medFileInfo->fileSize = atoi( size.c_str() );
+  _medFileInfo->major    = atoi( major.c_str() );
+  _medFileInfo->minor    = atoi( minor.c_str() );
+  _medFileInfo->release  = atoi( release.c_str() );
+}
+
 //=============================================================================
 /*!
  * \brief Pass names of mesh groups from study to mesh DS
@@ -5048,10 +5153,6 @@ void SMESH_Mesh_i::checkGroupNames()
   int nbGrp = NbGroups();
   if ( !nbGrp )
     return;
-
-  SALOMEDS::Study_var aStudy = _gen_i->GetCurrentStudy();
-  if ( aStudy->_is_nil() )
-    return; // nothing to do
   
   SMESH::ListOfGroups* grpList = 0;
   // avoid dump of "GetGroups"
@@ -5065,7 +5166,7 @@ void SMESH_Mesh_i::checkGroupNames()
     SMESH::SMESH_GroupBase_ptr aGrp = (*grpList)[ gIndx ];
     if ( !aGrp )
       continue;
-    SALOMEDS::SObject_wrap aGrpSO = _gen_i->ObjectToSObject( aStudy, aGrp );
+    SALOMEDS::SObject_wrap aGrpSO = _gen_i->ObjectToSObject( aGrp );
     if ( aGrpSO->_is_nil() )
       continue;
     // correct name of the mesh group if necessary
@@ -5108,15 +5209,12 @@ SMESH::string_array* SMESH_Mesh_i::GetLastParameters()
   SMESH_Gen_i *gen = SMESH_Gen_i::GetSMESHGen();
   if(gen) {
     CORBA::String_var aParameters = GetParameters();
-    SALOMEDS::Study_var    aStudy = gen->GetCurrentStudy();
-    if ( !aStudy->_is_nil()) {
-      SALOMEDS::ListOfListOfStrings_var aSections = aStudy->ParseVariables(aParameters); 
-      if ( aSections->length() > 0 ) {
-        SALOMEDS::ListOfStrings aVars = aSections[ aSections->length() - 1 ];
-        aResult->length( aVars.length() );
-        for ( CORBA::ULong i = 0;i < aVars.length(); i++ )
-          aResult[i] = CORBA::string_dup( aVars[i] );
-      }
+    SALOMEDS::ListOfListOfStrings_var aSections = SMESH_Gen_i::getStudyServant()->ParseVariables(aParameters);
+    if ( aSections->length() > 0 ) {
+      SALOMEDS::ListOfStrings aVars = aSections[ aSections->length() - 1 ];
+      aResult->length( aVars.length() );
+      for ( CORBA::ULong i = 0;i < aVars.length(); i++ )
+        aResult[i] = CORBA::string_dup( aVars[i] );
     }
   }
   return aResult._retn();
@@ -5242,7 +5340,7 @@ SALOMEDS::TMPFile* SMESH_Mesh_i::GetVtkUgStream()
 {
   SALOMEDS::TMPFile_var SeqFile;
   if ( SMESHDS_Mesh* aMeshDS = _impl->GetMeshDS() ) {
-    SMDS_UnstructuredGrid* aGrid = aMeshDS->getGrid();
+    SMDS_UnstructuredGrid* aGrid = aMeshDS->GetGrid();
     if(aGrid) {
       vtkUnstructuredGridWriter* aWriter = vtkUnstructuredGridWriter::New();
       aWriter->WriteToOutputStringOn();
@@ -5379,7 +5477,7 @@ namespace /* Iterators used in SMESH_Mesh_i::GetElements(SMESH::SMESH_IDSource_v
     {
       const SMDS_MeshElement* res = _node;
       _node = 0;
-      while (( _elemIter->more() || _nodeIter->more() ) && !_node )
+      while ( !_node && ( _elemIter->more() || _nodeIter->more() ))
       {
         if ( _nodeIter->more() )
         {
@@ -5517,17 +5615,17 @@ TopAbs_ShapeEnum shapeTypeByDim(const int theDim)
 
 //-----------------------------------------------------------------------------
 /*!
- * \brief Internal structure used to find concurent submeshes
+ * \brief Internal structure used to find concurrent submeshes
  *
- * It represents a pair < submesh, concurent dimension >, where
- * 'concurrent dimension' is dimension of shape where the submesh can concurent
+ * It represents a pair < submesh, concurrent dimension >, where
+ * 'concurrent dimension' is dimension of shape where the submesh can concurrent
  *  with another submesh. In other words, it is dimension of a hypothesis assigned
  *  to submesh.
  */
 class SMESH_DimHyp
 {
  public:
-  //! fileds
+  //! fields
   int _dim;    //!< a dimension the algo can build (concurrent dimension)
   int _ownDim; //!< dimension of shape of _subMesh (>=_dim)
   TopTools_MapOfShape _shapeMap;
@@ -5912,7 +6010,7 @@ TListOfListOfInt SMESH_Mesh_i::findConcurrentSubMeshes()
     
     removeDimHyps(dimHypListArr);
     
-    // now, minimise the number of concurrent groups
+    // now, minimize the number of concurrent groups
     // Here we assume that lists of submeshes can have same submesh
     // in case of multi-dimension algorithms, as result
     //  list with common submesh has to be united into one list
@@ -5981,6 +6079,9 @@ TListOfListOfInt SMESH_Mesh_i::findConcurrentSubMeshes()
   mesh.SetMeshOrder( subMeshOrder );
   res = true;
   
+  SMESH::SMESH_Mesh_var me = _this();
+  _gen_i->UpdateIcons( me );
+
   return res;
 }
 
@@ -6009,7 +6110,7 @@ void SMESH_Mesh_i::convertMeshOrder (const TListOfListOfInt&     theIdsOrder,
       continue;
     if ( theIsDump )
       aPythonDump << "[ ";
-    // convert shape indeces into interfaces
+    // convert shape indices into interfaces
     SMESH::submesh_array_var aResSubSet = new SMESH::submesh_array();
     aResSubSet->length(aSubOrder.size());
     TListOfInt::const_iterator subIt = aSubOrder.begin();
@@ -6041,6 +6142,24 @@ void SMESH_Mesh_i::convertMeshOrder (const TListOfListOfInt&     theIdsOrder,
   }
 }
 
+namespace // utils used by SMESH_MeshPartDS
+{
+  /*!
+   * \brief Class used to access to protected data of SMDS_MeshInfo
+   */
+  struct TMeshInfo : public SMDS_MeshInfo
+  {
+    void Add(const SMDS_MeshElement* e) { SMDS_MeshInfo::addWithPoly( e ); }
+  };
+  /*!
+   * \brief Element holing its ID only
+   */
+  struct TElemID : public SMDS_LinearEdge
+  {
+    TElemID(int ID) : SMDS_LinearEdge(0,0) { setID( ID ); }
+  };
+}
+
 //================================================================================
 //
 // Implementation of SMESH_MeshPartDS
@@ -6051,6 +6170,7 @@ SMESH_MeshPartDS::SMESH_MeshPartDS(SMESH::SMESH_IDSource_ptr meshPart):
   SMESH::SMESH_Mesh_var mesh = meshPart->GetMesh();
   SMESH_Mesh_i*       mesh_i = SMESH::DownCast<SMESH_Mesh_i*>( mesh );
 
+  mesh_i->Load();
   _meshDS = mesh_i->GetImpl().GetMeshDS();
 
   SetPersistentId( _meshDS->GetPersistentId() );
@@ -6120,6 +6240,21 @@ SMESH_MeshPartDS::SMESH_MeshPartDS(const std::list< const SMDS_MeshElement* > &
   myInfo = tmpInfo;
 }
 // -------------------------------------------------------------------------------------
+const SMDS_MeshElement * SMESH_MeshPartDS::FindElement(int IDelem) const
+{
+  if ( _meshDS ) return _meshDS->FindElement( IDelem );
+
+  TElemID elem( IDelem );
+  for ( int iType = SMDSAbs_Edge; iType < SMDSAbs_NbElementTypes; ++iType )
+    if ( !_elements[ iType ].empty() )
+    {
+      TIDSortedElemSet::const_iterator it = _elements[ iType ].find( &elem );
+      if ( it != _elements[ iType ].end() )
+        return *it;
+    }
+  return 0;
+}
+// -------------------------------------------------------------------------------------
 SMDS_ElemIteratorPtr SMESH_MeshPartDS::elementGeomIterator(SMDSAbs_GeometryType geomType) const
 {
   if ( _meshDS ) return _meshDS->elementGeomIterator( geomType );
@@ -6131,7 +6266,7 @@ SMDS_ElemIteratorPtr SMESH_MeshPartDS::elementGeomIterator(SMDSAbs_GeometryType
     SMDS_MeshElement::GeomFilter
     > TIter;
 
-  SMDSAbs_ElementType type = SMDS_MeshCell::toSmdsType( geomType );
+  SMDSAbs_ElementType type = SMDS_MeshCell::ElemType( geomType );
 
   return SMDS_ElemIteratorPtr( new TIter( _elements[type].begin(),
                                           _elements[type].end(),
@@ -6149,7 +6284,7 @@ SMDS_ElemIteratorPtr SMESH_MeshPartDS::elementEntityIterator(SMDSAbs_EntityType
     SMDS_MeshElement::EntityFilter
     > TIter;
 
-  SMDSAbs_ElementType type = SMDS_MeshCell::toSmdsType( entity );
+  SMDSAbs_ElementType type = SMDS_MeshCell::ElemType( entity );
 
   return SMDS_ElemIteratorPtr( new TIter( _elements[type].begin(),
                                           _elements[type].end(),
@@ -6176,10 +6311,10 @@ SMDS_ElemIteratorPtr SMESH_MeshPartDS::elementsIterator(SMDSAbs_ElementType type
 }
 // -------------------------------------------------------------------------------------
 #define _GET_ITER_DEFINE( iterType, methName, elem, elemType)                       \
-  iterType SMESH_MeshPartDS::methName( bool idInceasingOrder) const                 \
+  iterType SMESH_MeshPartDS::methName() const                 \
   {                                                                                 \
     typedef SMDS_SetIterator<const elem*, TIDSortedElemSet::const_iterator > TIter; \
-    return _meshDS ? _meshDS->methName(idInceasingOrder) : iterType                 \
+    return _meshDS ? _meshDS->methName() : iterType                 \
       ( new TIter( _elements[elemType].begin(), _elements[elemType].end() ));       \
   }
 // -------------------------------------------------------------------------------------