X-Git-Url: http://git.salome-platform.org/gitweb/?p=modules%2Fsmesh.git;a=blobdiff_plain;f=src%2FSMESH_I%2FSMESH_Mesh_i.cxx;h=3794e7231bb9467f4280864eb06880a0a6fb84a1;hp=c24ea9465011d6132d2cb521571a2223997868ad;hb=20d9e162bd67182cbfa841bbfc9319919f4703e3;hpb=b0a908c0d20341651771d0249fb10882f54b2aad diff --git a/src/SMESH_I/SMESH_Mesh_i.cxx b/src/SMESH_I/SMESH_Mesh_i.cxx index c24ea9465..3794e7231 100644 --- a/src/SMESH_I/SMESH_Mesh_i.cxx +++ b/src/SMESH_I/SMESH_Mesh_i.cxx @@ -1,4 +1,4 @@ -// Copyright (C) 2007-2014 CEA/DEN, EDF R&D, OPEN CASCADE +// Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE // // Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS @@ -26,6 +26,7 @@ #include "SMESH_Mesh_i.hxx" #include "DriverMED_R_SMESHDS_Mesh.h" +#include "DriverMED_W_Field.h" #include "DriverMED_W_SMESHDS_Mesh.h" #include "MED_Factory.hxx" #include "SMDS_EdgePosition.hxx" @@ -40,10 +41,12 @@ #include "SMESHDS_Group.hxx" #include "SMESHDS_GroupOnGeom.hxx" #include "SMESH_Controls.hxx" +#include "SMESH_File.hxx" #include "SMESH_Filter_i.hxx" #include "SMESH_Gen_i.hxx" #include "SMESH_Group.hxx" #include "SMESH_Group_i.hxx" +#include "SMESH_Mesh.hxx" #include "SMESH_MeshAlgos.hxx" #include "SMESH_MeshEditor.hxx" #include "SMESH_MeshEditor_i.hxx" @@ -53,12 +56,9 @@ #include "SMESH_PythonDump.hxx" #include "SMESH_subMesh_i.hxx" -#include #include #include -#include #include -#include #include #include @@ -66,15 +66,8 @@ // OCCT Includes #include -#include -#include -#include -#include -#include -#include +#include #include -#include -#include #include #include #include @@ -83,11 +76,10 @@ // STL Includes #include -#include #include #include -#include +#include // to pass CORBA exception through SMESH_TRY #define SMY_OWN_CATCH catch( SALOME::SALOME_Exception& se ) { throw se; } @@ -113,10 +105,9 @@ int SMESH_Mesh_i::_idGenerator = 0; SMESH_Mesh_i::SMESH_Mesh_i( PortableServer::POA_ptr thePOA, SMESH_Gen_i* gen_i, - CORBA::Long studyId ) + CORBA::Long studyId ) : SALOME::GenericObj_i( thePOA ) { - MESSAGE("SMESH_Mesh_i"); _impl = NULL; _gen_i = gen_i; _id = _idGenerator++; @@ -124,6 +115,7 @@ SMESH_Mesh_i::SMESH_Mesh_i( PortableServer::POA_ptr thePOA, _editor = NULL; _previewEditor = NULL; _preMeshInfo = NULL; + _mainShapeTick = 0; } //============================================================================= @@ -134,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::iterator itGr; for (itGr = _mapGroups.begin(); itGr != _mapGroups.end(); itGr++) @@ -168,6 +158,11 @@ SMESH_Mesh_i::~SMESH_Mesh_i() } _mapHypo.clear(); + // clear cashed shapes if no more meshes remain; (the cash is blame, + // together with publishing, of spent time increasing in issue 22874) + if ( _impl->NbMeshes() == 1 ) + _gen_i->GetShapeReader()->ClearClientBuffer(); + delete _editor; _editor = NULL; delete _previewEditor; _previewEditor = NULL; delete _impl; _impl = NULL; @@ -197,6 +192,8 @@ void SMESH_Mesh_i::SetShape( GEOM::GEOM_Object_ptr theShapeObject ) // to track changes of GEOM groups SMESH::SMESH_Mesh_var mesh = _this(); addGeomGroupData( theShapeObject, mesh ); + if ( !CORBA::is_nil( theShapeObject )) + _mainShapeTick = theShapeObject->GetTick(); } //================================================================================ @@ -232,7 +229,25 @@ GEOM::GEOM_Object_ptr SMESH_Mesh_i::GetShapeToMesh() try { TopoDS_Shape S = _impl->GetMeshDS()->ShapeToMesh(); if ( !S.IsNull() ) + { aShapeObj = _gen_i->ShapeToGeomObject( S ); + if ( aShapeObj->_is_nil() ) + { + // S was removed from GEOM_Client by newGroupShape() called by other mesh; + // find GEOM_Object by entry (IPAL52735) + list::iterator data = _geomGroupData.begin(); + 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() ); + CORBA::Object_var obj = _gen_i->SObjectToObject( so ); + aShapeObj = GEOM::GEOM_Object::_narrow( obj ); + break; + } + } + } } catch(SALOME_Exception & S_ex) { THROW_SALOME_CORBA_EXCEPTION(S_ex.what(), SALOME::BAD_PARAM); @@ -275,11 +290,11 @@ void SMESH_Mesh_i::Clear() throw (SALOME::SALOME_Exception) { Unexpect aCatch(SALOME_SalomeException); if ( _preMeshInfo ) - _preMeshInfo->ForgetAllData(); + _preMeshInfo->ForgetOrLoad(); // load in case if !HasShapeToMesh() try { _impl->Clear(); - CheckGeomGroupModif(); // issue 20145 + //CheckGeomGroupModif(); // issue 20145 } catch(SALOME_Exception & S_ex) { THROW_SALOME_CORBA_EXCEPTION(S_ex.what(), SALOME::BAD_PARAM); @@ -400,14 +415,7 @@ SMESH_Mesh_i::ImportMEDFile( const char* theFileName, const char* theMeshName ) _medFileInfo->major = major; _medFileInfo->minor = minor; _medFileInfo->release = release; -#ifdef WIN32 - struct _stati64 d; - if ( ::_stati64( theFileName, &d ) != -1 ) -#else - struct stat64 d; - if ( ::stat64( theFileName, &d ) != -1 ) -#endif - _medFileInfo->fileSize = d.st_size; + _medFileInfo->fileSize = SMESH_File( theFileName ).size(); return ConvertDriverMEDReadStatus(status); } @@ -563,6 +571,7 @@ SMESH::Hypothesis_Status SMESH_Mesh_i::ConvertHypothesisStatus RETURNCASE( HYP_BAD_SUBSHAPE ); RETURNCASE( HYP_BAD_GEOMETRY ); RETURNCASE( HYP_NEED_SHAPE ); + RETURNCASE( HYP_INCOMPAT_HYPS ); default:; } return SMESH::HYP_UNKNOWN_FATAL; @@ -578,33 +587,31 @@ SMESH::Hypothesis_Status SMESH_Mesh_i::ConvertHypothesisStatus */ //============================================================================= -SMESH::Hypothesis_Status SMESH_Mesh_i::AddHypothesis(GEOM::GEOM_Object_ptr aSubShapeObject, - SMESH::SMESH_Hypothesis_ptr anHyp) +SMESH::Hypothesis_Status +SMESH_Mesh_i::AddHypothesis(GEOM::GEOM_Object_ptr aSubShape, + SMESH::SMESH_Hypothesis_ptr anHyp, + CORBA::String_out anErrorText) throw(SALOME::SALOME_Exception) { Unexpect aCatch(SALOME_SalomeException); if ( _preMeshInfo ) _preMeshInfo->ForgetOrLoad(); - SMESH_Hypothesis::Hypothesis_Status status = addHypothesis( aSubShapeObject, anHyp ); + std::string error; + SMESH_Hypothesis::Hypothesis_Status status = addHypothesis( aSubShape, anHyp, &error ); + anErrorText = error.c_str(); SMESH::SMESH_Mesh_var mesh( _this() ); if ( !SMESH_Hypothesis::IsStatusFatal(status) ) { SALOMEDS::Study_var study = _gen_i->GetCurrentStudy(); - _gen_i->AddHypothesisToShape( study, mesh, aSubShapeObject, anHyp ); + _gen_i->AddHypothesisToShape( study, mesh, aSubShape, anHyp ); } if(MYDEBUG) MESSAGE( " AddHypothesis(): status = " << status ); // Update Python script - //if(_impl->HasShapeToMesh()) - { - TPythonDump() << "status = " << mesh << ".AddHypothesis( " - << aSubShapeObject << ", " << anHyp << " )"; - } - // else { - // TPythonDump() << "status = " << mesh << ".AddHypothesis( "<< anHyp << " )"; - // } + TPythonDump() << "status = " << mesh << ".AddHypothesis( " + << aSubShape << ", " << anHyp << " )"; return ConvertHypothesisStatus(status); } @@ -616,12 +623,13 @@ SMESH::Hypothesis_Status SMESH_Mesh_i::AddHypothesis(GEOM::GEOM_Object_ptr //============================================================================= SMESH_Hypothesis::Hypothesis_Status -SMESH_Mesh_i::addHypothesis(GEOM::GEOM_Object_ptr aSubShapeObject, - SMESH::SMESH_Hypothesis_ptr anHyp) +SMESH_Mesh_i::addHypothesis(GEOM::GEOM_Object_ptr aSubShape, + SMESH::SMESH_Hypothesis_ptr anHyp, + std::string* anErrorText) { if(MYDEBUG) MESSAGE("addHypothesis"); - if (CORBA::is_nil( aSubShapeObject ) && HasShapeToMesh()) + if (CORBA::is_nil( aSubShape ) && HasShapeToMesh()) THROW_SALOME_CORBA_EXCEPTION("bad Sub-shape reference",SALOME::BAD_PARAM); if (CORBA::is_nil( anHyp )) @@ -633,22 +641,28 @@ SMESH_Mesh_i::addHypothesis(GEOM::GEOM_Object_ptr aSubShapeObject, TopoDS_Shape myLocSubShape; //use PseudoShape in case if mesh has no shape if(HasShapeToMesh()) - myLocSubShape = _gen_i->GeomObjectToShape( aSubShapeObject); + myLocSubShape = _gen_i->GeomObjectToShape( aSubShape); else myLocSubShape = _impl->GetShapeToMesh(); const int hypId = anHyp->GetId(); - status = _impl->AddHypothesis(myLocSubShape, hypId); - if ( !SMESH_Hypothesis::IsStatusFatal(status) ) { + std::string error; + status = _impl->AddHypothesis( myLocSubShape, hypId, &error ); + if ( !SMESH_Hypothesis::IsStatusFatal(status) ) + { _mapHypo[hypId] = SMESH::SMESH_Hypothesis::_duplicate( anHyp ); anHyp->Register(); // assure there is a corresponding submesh if ( !_impl->IsMainShape( myLocSubShape )) { int shapeId = _impl->GetMeshDS()->ShapeToIndex( myLocSubShape ); if ( _mapSubMesh_i.find( shapeId ) == _mapSubMesh_i.end() ) - SMESH::SMESH_subMesh_var( createSubMesh( aSubShapeObject )); + SMESH::SMESH_subMesh_var( createSubMesh( aSubShape )); } } + else if ( anErrorText ) + { + *anErrorText = error; + } } catch(SALOME_Exception & S_ex) { @@ -663,7 +677,7 @@ SMESH_Mesh_i::addHypothesis(GEOM::GEOM_Object_ptr aSubShapeObject, */ //============================================================================= -SMESH::Hypothesis_Status SMESH_Mesh_i::RemoveHypothesis(GEOM::GEOM_Object_ptr aSubShapeObject, +SMESH::Hypothesis_Status SMESH_Mesh_i::RemoveHypothesis(GEOM::GEOM_Object_ptr aSubShape, SMESH::SMESH_Hypothesis_ptr anHyp) throw(SALOME::SALOME_Exception) { @@ -671,18 +685,18 @@ SMESH::Hypothesis_Status SMESH_Mesh_i::RemoveHypothesis(GEOM::GEOM_Object_ptr aS if ( _preMeshInfo ) _preMeshInfo->ForgetOrLoad(); - SMESH_Hypothesis::Hypothesis_Status status = removeHypothesis( aSubShapeObject, anHyp ); + SMESH_Hypothesis::Hypothesis_Status status = removeHypothesis( aSubShape, anHyp ); SMESH::SMESH_Mesh_var mesh = _this(); if ( !SMESH_Hypothesis::IsStatusFatal(status) ) { SALOMEDS::Study_var study = _gen_i->GetCurrentStudy(); - _gen_i->RemoveHypothesisFromShape( study, mesh, aSubShapeObject, anHyp ); + _gen_i->RemoveHypothesisFromShape( study, mesh, aSubShape, anHyp ); } // Update Python script if(_impl->HasShapeToMesh()) TPythonDump() << "status = " << mesh << ".RemoveHypothesis( " - << aSubShapeObject << ", " << anHyp << " )"; + << aSubShape << ", " << anHyp << " )"; else TPythonDump() << "status = " << mesh << ".RemoveHypothesis( " << anHyp << " )"; @@ -697,12 +711,12 @@ SMESH::Hypothesis_Status SMESH_Mesh_i::RemoveHypothesis(GEOM::GEOM_Object_ptr aS //============================================================================= SMESH_Hypothesis::Hypothesis_Status -SMESH_Mesh_i::removeHypothesis(GEOM::GEOM_Object_ptr aSubShapeObject, +SMESH_Mesh_i::removeHypothesis(GEOM::GEOM_Object_ptr aSubShape, SMESH::SMESH_Hypothesis_ptr anHyp) { if(MYDEBUG) MESSAGE("removeHypothesis()"); - if (CORBA::is_nil( aSubShapeObject ) && HasShapeToMesh()) + if (CORBA::is_nil( aSubShape ) && HasShapeToMesh()) THROW_SALOME_CORBA_EXCEPTION("bad Sub-shape reference", SALOME::BAD_PARAM); if (CORBA::is_nil( anHyp )) @@ -714,7 +728,7 @@ SMESH_Mesh_i::removeHypothesis(GEOM::GEOM_Object_ptr aSubShapeObject, TopoDS_Shape myLocSubShape; //use PseudoShape in case if mesh has no shape if( _impl->HasShapeToMesh() ) - myLocSubShape = _gen_i->GeomObjectToShape( aSubShapeObject ); + myLocSubShape = _gen_i->GeomObjectToShape( aSubShape ); else myLocSubShape = _impl->GetShapeToMesh(); @@ -740,18 +754,18 @@ SMESH_Mesh_i::removeHypothesis(GEOM::GEOM_Object_ptr aSubShapeObject, //============================================================================= SMESH::ListOfHypothesis * -SMESH_Mesh_i::GetHypothesisList(GEOM::GEOM_Object_ptr aSubShapeObject) +SMESH_Mesh_i::GetHypothesisList(GEOM::GEOM_Object_ptr aSubShape) throw(SALOME::SALOME_Exception) { Unexpect aCatch(SALOME_SalomeException); if (MYDEBUG) MESSAGE("GetHypothesisList"); - if (_impl->HasShapeToMesh() && CORBA::is_nil(aSubShapeObject)) + if (_impl->HasShapeToMesh() && CORBA::is_nil(aSubShape)) THROW_SALOME_CORBA_EXCEPTION("bad Sub-shape reference", SALOME::BAD_PARAM); SMESH::ListOfHypothesis_var aList = new SMESH::ListOfHypothesis(); try { - TopoDS_Shape myLocSubShape = _gen_i->GeomObjectToShape(aSubShapeObject); + TopoDS_Shape myLocSubShape = _gen_i->GeomObjectToShape(aSubShape); if ( myLocSubShape.IsNull() && !_impl->HasShapeToMesh() ) myLocSubShape = _impl->GetShapeToMesh(); const list& aLocalList = _impl->GetHypothesisList( myLocSubShape ); @@ -817,18 +831,18 @@ SMESH::submesh_array* SMESH_Mesh_i::GetSubMeshes() throw (SALOME::SALOME_Excepti */ //============================================================================= -SMESH::SMESH_subMesh_ptr SMESH_Mesh_i::GetSubMesh(GEOM::GEOM_Object_ptr aSubShapeObject, +SMESH::SMESH_subMesh_ptr SMESH_Mesh_i::GetSubMesh(GEOM::GEOM_Object_ptr aSubShape, const char* theName ) throw(SALOME::SALOME_Exception) { Unexpect aCatch(SALOME_SalomeException); - if (CORBA::is_nil(aSubShapeObject)) + if (CORBA::is_nil(aSubShape)) THROW_SALOME_CORBA_EXCEPTION("bad Sub-shape reference", SALOME::BAD_PARAM); SMESH::SMESH_subMesh_var subMesh; SMESH::SMESH_Mesh_var aMesh = _this(); try { - TopoDS_Shape myLocSubShape = _gen_i->GeomObjectToShape(aSubShapeObject); + TopoDS_Shape myLocSubShape = _gen_i->GeomObjectToShape(aSubShape); //Get or Create the SMESH_subMesh object implementation @@ -844,16 +858,16 @@ SMESH::SMESH_subMesh_ptr SMESH_Mesh_i::GetSubMesh(GEOM::GEOM_Object_ptr aSubShap // create a new subMesh object servant if there is none for the shape if ( subMesh->_is_nil() ) - subMesh = createSubMesh( aSubShapeObject ); + 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, aSubShapeObject, theName ); + _gen_i->PublishSubMesh( study, aMesh, subMesh, aSubShape, theName ); if ( !aSO->_is_nil()) { // Update Python script TPythonDump() << aSO << " = " << aMesh << ".GetSubMesh( " - << aSubShapeObject << ", '" << theName << "' )"; + << aSubShape << ", '" << theName << "' )"; } } } @@ -877,7 +891,7 @@ void SMESH_Mesh_i::RemoveSubMesh( SMESH::SMESH_subMesh_ptr theSubMesh ) if ( theSubMesh->_is_nil() ) return; - GEOM::GEOM_Object_var aSubShapeObject; + GEOM::GEOM_Object_var aSubShape; SALOMEDS::Study_var aStudy = _gen_i->GetCurrentStudy(); if ( !aStudy->_is_nil() ) { // Remove submesh's SObject @@ -889,10 +903,10 @@ void SMESH_Mesh_i::RemoveSubMesh( SMESH::SMESH_subMesh_ptr theSubMesh ) anObj->ReferencedObject( aRef.inout() )) { CORBA::Object_var obj = aRef->GetObject(); - aSubShapeObject = GEOM::GEOM_Object::_narrow( obj ); + aSubShape = GEOM::GEOM_Object::_narrow( obj ); } - // if ( aSubShapeObject->_is_nil() ) // not published shape (IPAL13617) - // aSubShapeObject = theSubMesh->GetSubShape(); + // if ( aSubShape->_is_nil() ) // not published shape (IPAL13617) + // aSubShape = theSubMesh->GetSubShape(); SALOMEDS::StudyBuilder_var builder = aStudy->NewBuilder(); builder->RemoveObjectWithChildren( anSO ); @@ -902,7 +916,7 @@ void SMESH_Mesh_i::RemoveSubMesh( SMESH::SMESH_subMesh_ptr theSubMesh ) } } - if ( removeSubMesh( theSubMesh, aSubShapeObject.in() )) + if ( removeSubMesh( theSubMesh, aSubShape.in() )) if ( _preMeshInfo ) _preMeshInfo->ForgetOrLoad(); @@ -1058,6 +1072,7 @@ void SMESH_Mesh_i::RemoveGroup( SMESH::SMESH_GroupBase_ptr theGroup ) builder->RemoveObjectWithChildren( aGroupSO ); } } + aGroup->Modified(/*removed=*/true); // notify dependent Filter with FT_BelongToMeshGroup criterion // Remove the group from SMESH data structures removeGroup( aGroup->GetLocalID() ); @@ -1081,11 +1096,35 @@ void SMESH_Mesh_i::RemoveGroupWithContents( SMESH::SMESH_GroupBase_ptr theGroup if ( theGroup->_is_nil() ) return; + vector nodeIds; // to remove nodes becoming free + if ( !theGroup->IsEmpty() ) + { + CORBA::Long elemID = theGroup->GetID( 1 ); + int nbElemNodes = GetElemNbNodes( elemID ); + if ( nbElemNodes > 0 ) + nodeIds.reserve( theGroup->Size() * nbElemNodes ); + } + // Remove contents SMESH::SMESH_IDSource_var idSrc = SMESH::SMESH_IDSource::_narrow( theGroup ); SMDS_ElemIteratorPtr elemIt = GetElements( idSrc, theGroup->GetType() ); while ( elemIt->more() ) - _impl->GetMeshDS()->RemoveElement( elemIt->next() ); + { + const SMDS_MeshElement* e = elemIt->next(); + + SMDS_ElemIteratorPtr nIt = e->nodesIterator(); + while ( nIt->more() ) + nodeIds.push_back( nIt->next()->GetID() ); + + _impl->GetMeshDS()->RemoveElement( e ); + } + + // 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() @@ -1561,7 +1600,7 @@ SMESH_Mesh_i::CutListOfGroups(const SMESH::ListOfGroups& theMainGroups, // Update Python script pyDump << aResGrp << " = " << SMESH::SMESH_Mesh_var( _this() ) - << ".CutListOfGroups( " << theMainGroups + << ".CutListOfGroups( " << theMainGroups << ", " << theToolGroups << ", '" << theName << "' )"; SMESH_CATCH( SMESH::throwCorbaException ); @@ -1569,25 +1608,52 @@ SMESH_Mesh_i::CutListOfGroups(const SMESH::ListOfGroups& theMainGroups, return aResGrp._retn(); } +namespace // functions making checks according to SMESH::NB_COMMON_NODES_ENUM +{ + bool isAllNodesCommon(int nbChecked, int nbCommon, int nbNodes, int nbCorners, + bool & toStopChecking ) + { + toStopChecking = ( nbCommon < nbChecked ); + return nbCommon == nbNodes; + } + bool isMainNodesCommon(int nbChecked, int nbCommon, int nbNodes, int nbCorners, + bool & toStopChecking ) + { + toStopChecking = ( nbCommon < nbChecked || nbChecked >= nbCorners ); + return nbCommon == nbCorners; + } + bool isAtLeastOneNodeCommon(int nbChecked, int nbCommon, int nbNodes, int nbCorners, + bool & toStopChecking ) + { + return nbCommon > 0; + } + bool isMajorityOfNodesCommon(int nbChecked, int nbCommon, int nbNodes, int nbCorners, + bool & toStopChecking ) + { + return nbCommon >= (nbNodes+1) / 2; + } +} + //============================================================================= /*! - \brief Create groups of entities from existing groups of superior dimensions - System - 1) extract all nodes from each group, - 2) combine all elements of specified dimension laying on these nodes. - \param theGroups list of source groups - \param theElemType dimension of elements - \param theName name of new group - \return pointer on new group - * - IMP 19939 + * Create a group of entities basing on nodes of other groups. + * \param [in] theGroups - list of either groups, sub-meshes or filters. + * \param [in] anElemType - a type of elements to include to the new group. + * \param [in] theName - a name of the new group. + * \param [in] theNbCommonNodes - criterion of inclusion of an element to the new group. + * \param [in] theUnderlyingOnly - if \c True, an element is included to the + * new group provided that it is based on nodes of an element of \a aListOfGroups + * \return SMESH_Group - the created group */ +// IMP 19939, bug 22010, IMP 22635 //============================================================================= SMESH::SMESH_Group_ptr -SMESH_Mesh_i::CreateDimGroup(const SMESH::ListOfGroups& theGroups, - SMESH::ElementType theElemType, - const char* theName ) +SMESH_Mesh_i::CreateDimGroup(const SMESH::ListOfIDSources& theGroups, + SMESH::ElementType theElemType, + const char* theName, + SMESH::NB_COMMON_NODES_ENUM theNbCommonNodes, + CORBA::Boolean theUnderlyingOnly) throw (SALOME::SALOME_Exception) { SMESH::SMESH_Group_var aResGrp; @@ -1603,6 +1669,17 @@ SMESH_Mesh_i::CreateDimGroup(const SMESH::ListOfGroups& theGroups, SMDSAbs_ElementType anElemType = (SMDSAbs_ElementType)theElemType; + bool (*isToInclude)(int nbChecked, int nbCommon, int nbNodes, int nbCorners, bool & toStop); + SMESH_Comment nbCoNoStr( "SMESH."); + switch ( theNbCommonNodes ) { + case SMESH::ALL_NODES : isToInclude = isAllNodesCommon; nbCoNoStr<<"ALL_NODES" ;break; + case SMESH::MAIN : isToInclude = isMainNodesCommon; nbCoNoStr<<"MAIN" ;break; + case SMESH::AT_LEAST_ONE: isToInclude = isAtLeastOneNodeCommon; nbCoNoStr<<"AT_LEAST_ONE";break; + case SMESH::MAJORITY : isToInclude = isMajorityOfNodesCommon; nbCoNoStr<<"MAJORITY" ;break; + default: return aResGrp._retn(); + } + int nbChecked, nbCommon, nbNodes, nbCorners; + // Create a group TPythonDump pyDump; @@ -1615,14 +1692,19 @@ SMESH_Mesh_i::CreateDimGroup(const SMESH::ListOfGroups& theGroups, SMESH::DownCast( aResGrp )->GetGroupDS(); SMDS_MeshGroup& resGroupCore = static_cast< SMESHDS_Group* >( groupBaseDS )->SMDSGroup(); + vector isNodeInGroups; + for ( int g = 0, n = theGroups.length(); g < n; g++ ) // loop on theGroups { - SMESH::SMESH_GroupBase_var aGrp = theGroups[ g ]; + SMESH::SMESH_IDSource_var aGrp = theGroups[ g ]; if ( CORBA::is_nil( aGrp ) ) continue; + SMESH::SMESH_Mesh_var mesh = aGrp->GetMesh(); + if ( mesh->_is_nil() || mesh->GetId() != this->GetId() ) + continue; - groupBaseDS = SMESH::DownCast( aGrp )->GetGroupDS(); - SMDS_ElemIteratorPtr elIt = groupBaseDS->GetElements(); + SMDS_ElemIteratorPtr elIt = GetElements( aGrp, SMESH::ALL ); + if ( !elIt ) continue; if ( theElemType == SMESH::NODE ) // get all nodes of elements { @@ -1633,30 +1715,93 @@ SMESH_Mesh_i::CreateDimGroup(const SMESH::ListOfGroups& theGroups, resGroupCore.Add( nIt->next() ); } } - else // get elements of theElemType based on nodes of every element of group + // get elements of theElemType based on nodes of every element of group + else if ( theUnderlyingOnly ) { while ( elIt->more() ) { - const SMDS_MeshElement* el = elIt->next(); // an element of group + const SMDS_MeshElement* el = elIt->next(); // an element of ref group TIDSortedElemSet elNodes( el->begin_nodes(), el->end_nodes() ); TIDSortedElemSet checkedElems; - SMDS_ElemIteratorPtr nIt = el->nodesIterator(); + SMDS_NodeIteratorPtr nIt = el->nodeIterator(); while ( nIt->more() ) { - const SMDS_MeshNode* n = static_cast( nIt->next() ); + const SMDS_MeshNode* n = nIt->next(); SMDS_ElemIteratorPtr elOfTypeIt = n->GetInverseElementIterator( anElemType ); // check nodes of elements of theElemType around el while ( elOfTypeIt->more() ) { const SMDS_MeshElement* elOfType = elOfTypeIt->next(); if ( !checkedElems.insert( elOfType ).second ) continue; - + nbNodes = elOfType->NbNodes(); + nbCorners = elOfType->NbCornerNodes(); + nbCommon = 0; + bool toStopChecking = false; SMDS_ElemIteratorPtr nIt2 = elOfType->nodesIterator(); - bool allNodesOK = true; - while ( nIt2->more() && allNodesOK ) - allNodesOK = elNodes.count( nIt2->next() ); - if ( allNodesOK ) - resGroupCore.Add( elOfType ); + for ( nbChecked = 1; nIt2->more() && !toStopChecking; ++nbChecked ) + if ( elNodes.count( nIt2->next() ) && + isToInclude( nbChecked, ++nbCommon, nbNodes, nbCorners, toStopChecking )) + { + resGroupCore.Add( elOfType ); + break; + } + } + } + } + } + // get all nodes of elements of groups + else + { + while ( elIt->more() ) + { + const SMDS_MeshElement* el = elIt->next(); // an element of group + SMDS_NodeIteratorPtr nIt = el->nodeIterator(); + while ( nIt->more() ) + { + const SMDS_MeshNode* n = nIt->next(); + if ( n->GetID() >= (int) isNodeInGroups.size() ) + isNodeInGroups.resize( n->GetID() + 1, false ); + isNodeInGroups[ n->GetID() ] = true; + } + } + } + } + + // Get elements of theElemType based on a certain number of nodes of elements of groups + if ( !theUnderlyingOnly && !isNodeInGroups.empty() ) + { + const SMDS_MeshNode* n; + vector isElemChecked( aMeshDS->MaxElementID() + 1 ); + const int isNodeInGroupsSize = isNodeInGroups.size(); + for ( int iN = 0; iN < isNodeInGroupsSize; ++iN ) + { + if ( !isNodeInGroups[ iN ] || + !( n = aMeshDS->FindNode( iN ))) + continue; + + // check nodes of elements of theElemType around n + SMDS_ElemIteratorPtr elOfTypeIt = n->GetInverseElementIterator( anElemType ); + while ( elOfTypeIt->more() ) + { + const SMDS_MeshElement* elOfType = elOfTypeIt->next(); + vector::reference isChecked = isElemChecked[ elOfType->GetID() ]; + if ( isChecked ) + continue; + isChecked = true; + + nbNodes = elOfType->NbNodes(); + nbCorners = elOfType->NbCornerNodes(); + nbCommon = 0; + bool toStopChecking = false; + SMDS_ElemIteratorPtr nIt = elOfType->nodesIterator(); + for ( nbChecked = 1; nIt->more() && !toStopChecking; ++nbChecked ) + { + const int nID = nIt->next()->GetID(); + if ( nID < isNodeInGroupsSize && isNodeInGroups[ nID ] && + isToInclude( nbChecked, ++nbCommon, nbNodes, nbCorners, toStopChecking )) + { + resGroupCore.Add( elOfType ); + break; } } } @@ -1666,7 +1811,8 @@ SMESH_Mesh_i::CreateDimGroup(const SMESH::ListOfGroups& theGroups, // Update Python script pyDump << aResGrp << " = " << SMESH::SMESH_Mesh_var( _this()) << ".CreateDimGroup( " - << theGroups << ", " << theElemType << ", '" << theName << "' )"; + << theGroups << ", " << theElemType << ", '" << theName << "', " + << nbCoNoStr << ", " << theUnderlyingOnly << ")"; SMESH_CATCH( SMESH::throwCorbaException ); @@ -1702,10 +1848,13 @@ void SMESH_Mesh_i::addGeomGroupData(GEOM::GEOM_Object_ptr theGeomObj, CORBA::String_var entry = groupSO->GetID(); groupData._groupEntry = entry.in(); // indices - for ( int i = 0; i < ids->length(); ++i ) + for ( CORBA::ULong i = 0; i < ids->length(); ++i ) groupData._indices.insert( ids[i] ); // SMESH object groupData._smeshObject = CORBA::Object::_duplicate( theSmeshObj ); + // shape index in SMESHDS + // TopoDS_Shape shape = _gen_i->GeomObjectToShape( theGeomObj ); + // groupData._dsID = shape.IsNull() ? 0 : _impl->GetSubMesh( shape )->GetId(); } //================================================================================ @@ -1752,7 +1901,7 @@ TopoDS_Shape SMESH_Mesh_i::newGroupShape( TGeomGroupData & groupData) GEOM::GEOM_IGroupOperations_wrap groupOp = geomGen->GetIGroupOperations( _gen_i->GetCurrentStudyID() ); GEOM::ListOfLong_var ids = groupOp->GetObjects( geomGroup ); - for ( int i = 0; i < ids->length(); ++i ) + for ( CORBA::ULong i = 0; i < ids->length(); ++i ) curIndices.insert( ids[i] ); if ( groupData._indices == curIndices ) @@ -1779,22 +1928,182 @@ TopoDS_Shape SMESH_Mesh_i::newGroupShape( TGeomGroupData & groupData) namespace { - //============================================================================= + //----------------------------------------------------------------------------- /*! * \brief Storage of shape and index used in CheckGeomGroupModif() */ - //============================================================================= struct TIndexedShape { int _index; TopoDS_Shape _shape; TIndexedShape( int i, const TopoDS_Shape& s ):_index(i), _shape(s) {} }; + //----------------------------------------------------------------------------- + /*! + * \brief Data to re-create a group on geometry + */ + struct TGroupOnGeomData + { + int _oldID; + int _shapeID; + SMDSAbs_ElementType _type; + std::string _name; + Quantity_Color _color; + }; } + +//============================================================================= +/*! + * \brief Update data if geometry changes + * + * Issue 0022501 + */ +//============================================================================= + +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; + + // Update after group modification + + if ( mainGO->_is_nil() || /* shape was removed from GEOM_Client by newGroupShape() + called by other mesh (IPAL52735) */ + mainGO->GetType() == GEOM_GROUP || + mainGO->GetTick() == _mainShapeTick ) + { + CheckGeomGroupModif(); + return; + } + + // Update after shape transformation like Translate + + GEOM_Client* geomClient = _gen_i->GetShapeReader(); + if ( !geomClient ) return; + GEOM::GEOM_Gen_var geomGen = _gen_i->GetGeomEngine(); + if ( geomGen->_is_nil() ) return; + + CORBA::String_var ior = geomGen->GetStringFromIOR( mainGO ); + geomClient->RemoveShapeFromBuffer( ior.in() ); + + // Update data taking into account that + // all sub-shapes change but IDs of sub-shapes remain (except for geom groups) + + _impl->Clear(); + TopoDS_Shape newShape = _gen_i->GeomObjectToShape( mainGO ); + if ( newShape.IsNull() ) + return; + + _mainShapeTick = mainGO->GetTick(); + + SMESHDS_Mesh * meshDS = _impl->GetMeshDS(); + + // store data of groups on geometry + vector< TGroupOnGeomData > groupsData; + const set& groups = meshDS->GetGroups(); + groupsData.reserve( groups.size() ); + set::const_iterator g = groups.begin(); + for ( ; g != groups.end(); ++g ) + if ( const SMESHDS_GroupOnGeom* group = dynamic_cast< SMESHDS_GroupOnGeom* >( *g )) + { + TGroupOnGeomData data; + data._oldID = group->GetID(); + data._shapeID = meshDS->ShapeToIndex( group->GetShape() ); + data._type = group->GetType(); + data._name = group->GetStoreName(); + data._color = group->GetColor(); + groupsData.push_back( data ); + } + // store assigned hypotheses + vector< pair< int, THypList > > ids2Hyps; + const ShapeToHypothesis & hyps = meshDS->GetHypotheses(); + for ( ShapeToHypothesis::Iterator s2hyps( hyps ); s2hyps.More(); s2hyps.Next() ) + { + const TopoDS_Shape& s = s2hyps.Key(); + const THypList& hyps = s2hyps.ChangeValue(); + ids2Hyps.push_back( make_pair( meshDS->ShapeToIndex( s ), hyps )); + } + + // change shape to mesh + int oldNbSubShapes = meshDS->MaxShapeIndex(); + _impl->ShapeToMesh( TopoDS_Shape() ); + _impl->ShapeToMesh( newShape ); + + // re-add shapes of geom groups + list::iterator data = _geomGroupData.begin(); + for ( ; data != _geomGroupData.end(); ++data ) + { + TopoDS_Shape newShape = newGroupShape( *data ); + if ( !newShape.IsNull() ) + { + if ( meshDS->ShapeToIndex( newShape ) > 0 ) // a group reduced to one sub-shape + { + TopoDS_Compound compound; + BRep_Builder().MakeCompound( compound ); + BRep_Builder().Add( compound, newShape ); + newShape = compound; + } + _impl->GetSubMesh( newShape ); + } + } + if ( oldNbSubShapes != meshDS->MaxShapeIndex() ) + THROW_SALOME_CORBA_EXCEPTION( "SMESH_Mesh_i::CheckGeomModif() bug", + SALOME::INTERNAL_ERROR ); + + // re-assign hypotheses + for ( size_t i = 0; i < ids2Hyps.size(); ++i ) + { + const TopoDS_Shape& s = meshDS->IndexToShape( ids2Hyps[i].first ); + const THypList& hyps = ids2Hyps[i].second; + THypList::const_iterator h = hyps.begin(); + for ( ; h != hyps.end(); ++h ) + _impl->AddHypothesis( s, (*h)->GetID() ); + } + + // restore groups + for ( size_t i = 0; i < groupsData.size(); ++i ) + { + const TGroupOnGeomData& data = groupsData[i]; + + map::iterator i2g = _mapGroups.find( data._oldID ); + if ( i2g == _mapGroups.end() ) continue; + + SMESH_GroupBase_i* gr_i = SMESH::DownCast( i2g->second ); + if ( !gr_i ) continue; + + int id; + SMESH_Group* g = _impl->AddGroup( data._type, data._name.c_str(), id, + meshDS->IndexToShape( data._shapeID )); + if ( !g ) + { + _mapGroups.erase( i2g ); + } + else + { + g->GetGroupDS()->SetColor( data._color ); + gr_i->changeLocalId( id ); + _mapGroups[ id ] = i2g->second; + if ( data._oldID != id ) + _mapGroups.erase( i2g ); + } + } + + // update _mapSubMesh + map::iterator i_sm = _mapSubMesh.begin(); + for ( ; i_sm != _mapSubMesh.end(); ++i_sm ) + i_sm->second = _impl->GetSubMesh( meshDS->IndexToShape( i_sm->first )); + +} + //============================================================================= /*! * \brief Update objects depending on changed geom groups - * + * * NPAL16168: geometrical group edition from a submesh don't modifiy mesh computation * issue 0020210: Update of a smesh group after modification of the associated geom group */ @@ -1951,9 +2260,11 @@ void SMESH_Mesh_i::CheckGeomGroupModif() groupData.push_back ( make_pair( TIndexedShape( gog->GetID(),gog->GetShape()), gog->GetType())); } - // set new shape to mesh -> DS of submeshes and geom groups is deleted + // set new shape to mesh -> DS of sub-meshes and geom groups are deleted + _impl->Clear(); + _impl->ShapeToMesh( TopoDS_Shape() ); // IPAL52730 _impl->ShapeToMesh( newShape ); - + // reassign hypotheses TShapeHypList::iterator indS_hyps = assignedHyps.begin(); for ( ; indS_hyps != assignedHyps.end(); ++indS_hyps ) @@ -1970,7 +2281,7 @@ void SMESH_Mesh_i::CheckGeomGroupModif() continue; for ( hypIt = hyps.begin(); hypIt != hyps.end(); ++hypIt ) _impl->AddHypothesis( geom._shape, (*hypIt)->GetID()); - // care of submeshes + // care of sub-meshes SMESH_subMesh* newSubmesh = _impl->GetSubMesh( geom._shape ); if ( newID != oldID ) { _mapSubMesh [ newID ] = newSubmesh; @@ -2612,44 +2923,36 @@ CORBA::Boolean SMESH_Mesh_i::HasDuplicatedGroupNamesMED() void SMESH_Mesh_i::PrepareForWriting (const char* file, bool overwrite) { - TCollection_AsciiString aFullName ((char*)file); - OSD_Path aPath (aFullName); - OSD_File aFile (aPath); - if (aFile.Exists()) { + SMESH_File aFile( file ); + SMESH_Comment msg; + if (aFile.exists()) { // existing filesystem node - if (aFile.KindOfFile() == OSD_FILE) { - if (aFile.IsWriteable()) { - if (overwrite) { - aFile.Reset(); - aFile.Remove(); - } - if (aFile.Failed()) { - TCollection_AsciiString msg ("File "); - msg += aFullName + " cannot be replaced."; - THROW_SALOME_CORBA_EXCEPTION(msg.ToCString(), SALOME::BAD_PARAM); + if ( !aFile.isDirectory() ) { + if ( aFile.openForWriting() ) { + if ( overwrite && ! aFile.remove()) { + msg << "Can't replace " << aFile.getName(); } } else { - TCollection_AsciiString msg ("File "); - msg += aFullName + " cannot be overwritten."; - THROW_SALOME_CORBA_EXCEPTION(msg.ToCString(), SALOME::BAD_PARAM); + msg << "Can't write into " << aFile.getName(); } } else { - TCollection_AsciiString msg ("Location "); - msg += aFullName + " is not a file."; - THROW_SALOME_CORBA_EXCEPTION(msg.ToCString(), SALOME::BAD_PARAM); + msg << "Location " << aFile.getName() << " is not a file"; } - } else { + } + else { // nonexisting file; check if it can be created - aFile.Reset(); - aFile.Build(OSD_WriteOnly, OSD_Protection()); - if (aFile.Failed()) { - TCollection_AsciiString msg ("You cannot create the file "); - msg += aFullName + ". Check the directory existance and access rights."; - THROW_SALOME_CORBA_EXCEPTION(msg.ToCString(), SALOME::BAD_PARAM); - } else { - aFile.Close(); - aFile.Remove(); + if ( !aFile.openForWriting() ) { + msg << "You cannot create the file " + << aFile.getName() + << ". Check the directory existance and access rights"; } + aFile.remove(); + } + + if ( !msg.empty() ) + { + msg << "."; + THROW_SALOME_CORBA_EXCEPTION(msg.c_str(), SALOME::BAD_PARAM); } } @@ -2719,13 +3022,13 @@ void SMESH_Mesh_i::ExportToMEDX (const char* file, _preMeshInfo->FullLoadFromFile(); string aMeshName = prepareMeshNameAndGroups(file, overwrite); + _impl->ExportMED( file, aMeshName.c_str(), auto_groups, theVersion, 0, autoDimension ); + TPythonDump() << SMESH::SMESH_Mesh_var(_this()) << ".ExportToMEDX( r'" << file << "', " << auto_groups << ", " << theVersion << ", " << overwrite << ", " << autoDimension << " )"; - _impl->ExportMED( file, aMeshName.c_str(), auto_groups, theVersion, 0, autoDimension ); - SMESH_CATCH( SMESH::throwCorbaException ); } @@ -2853,20 +3156,65 @@ 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::Boolean overwrite, - ::CORBA::Boolean autoDimension) +void SMESH_Mesh_i::ExportPartToMED(SMESH::SMESH_IDSource_ptr meshPart, + const char* file, + CORBA::Boolean auto_groups, + SMESH::MED_VERSION version, + CORBA::Boolean overwrite, + CORBA::Boolean autoDimension, + const GEOM::ListOfFields& fields, + const char* geomAssocFields) throw (SALOME::SALOME_Exception) { - Unexpect aCatch(SALOME_SalomeException); - TPythonDump pyDump; + SMESH_TRY; + if ( _preMeshInfo ) + _preMeshInfo->FullLoadFromFile(); - if ( SMESH_Mesh_i * mesh = SMESH::DownCast< SMESH_Mesh_i* >( meshPart )) + // check fields + bool have0dField = false; + if ( fields.length() > 0 ) { - mesh->ExportToMEDX( file, auto_groups, version, autoDimension ); + GEOM::GEOM_Object_var shapeToMesh = GetShapeToMesh(); + if ( shapeToMesh->_is_nil() ) + THROW_SALOME_CORBA_EXCEPTION( "No shape to mesh", SALOME::INTERNAL_ERROR ); + + for ( size_t i = 0; i < fields.length(); ++i ) + { + if ( fields[i]->GetDataType() == GEOM::FDT_String ) + THROW_SALOME_CORBA_EXCEPTION + ( "Export of string fields is not supported", SALOME::BAD_PARAM); + GEOM::GEOM_Object_var fieldShape = fields[i]->GetShape(); + if ( fieldShape->_is_nil() ) + THROW_SALOME_CORBA_EXCEPTION( "Null shape under a field", SALOME::INTERNAL_ERROR ); + if ( !fieldShape->IsSame( shapeToMesh ) ) + THROW_SALOME_CORBA_EXCEPTION + ( "Field defined not on shape", SALOME::BAD_PARAM); + if ( fields[i]->GetDimension() == 0 ) + have0dField = true; + } + if ( geomAssocFields ) + for ( int i = 0; geomAssocFields[i]; ++i ) + switch ( geomAssocFields[i] ) { + case 'v':case 'e':case 'f':case 's': break; + case 'V':case 'E':case 'F':case 'S': break; + default: THROW_SALOME_CORBA_EXCEPTION + ( "geomAssocFields can include only [vefs] characters", SALOME::BAD_PARAM); + } + } + + SMESHDS_Mesh* meshDS = _impl->GetMeshDS(); + + // write mesh + + string aMeshName = "Mesh"; + SMESHUtils::Deleter< SMESH_MeshPartDS > tmpDSDeleter(0); + if ( CORBA::is_nil( meshPart ) || + SMESH::DownCast< SMESH_Mesh_i* >( meshPart )) + { + aMeshName = prepareMeshNameAndGroups(file, overwrite); + _impl->ExportMED( file, aMeshName.c_str(), auto_groups, + version, 0, autoDimension, /*addODOnVertices=*/have0dField); + meshDS = _impl->GetMeshDS(); } else { @@ -2875,7 +3223,6 @@ void SMESH_Mesh_i::ExportPartToMED(::SMESH::SMESH_IDSource_ptr meshPart, PrepareForWriting(file, overwrite); - string aMeshName = "Mesh"; SALOMEDS::Study_var aStudy = _gen_i->GetCurrentStudy(); if ( !aStudy->_is_nil() ) { SALOMEDS::SObject_wrap SO = _gen_i->ObjectToSObject( aStudy, meshPart ); @@ -2884,13 +3231,308 @@ void SMESH_Mesh_i::ExportPartToMED(::SMESH::SMESH_IDSource_ptr meshPart, aMeshName = name; } } - SMESH_MeshPartDS partDS( meshPart ); - _impl->ExportMED( file, aMeshName.c_str(), auto_groups, version, &partDS, autoDimension ); + SMESH_MeshPartDS* partDS = new SMESH_MeshPartDS( meshPart ); + _impl->ExportMED( file, aMeshName.c_str(), auto_groups, + version, partDS, autoDimension, /*addODOnVertices=*/have0dField); + meshDS = tmpDSDeleter._obj = partDS; + } + + // write fields + + if ( _impl->HasShapeToMesh() ) + { + DriverMED_W_Field fieldWriter; + fieldWriter.SetFile( file ); + fieldWriter.SetMeshName( aMeshName ); + fieldWriter.AddODOnVertices( have0dField ); + + exportMEDFields( fieldWriter, meshDS, fields, geomAssocFields ); } - pyDump << SMESH::SMESH_Mesh_var(_this()) << ".ExportPartToMED( " - << meshPart << ", r'" << file << "', " - << auto_groups << ", " << version << ", " << overwrite << ", " - << autoDimension << " )"; + + // dump + GEOM::ListOfGBO_var goList = new GEOM::ListOfGBO; + goList->length( fields.length() ); + for ( size_t i = 0; i < fields.length(); ++i ) + { + GEOM::GEOM_BaseObject_var gbo = GEOM::GEOM_BaseObject::_narrow( fields[i] ); + goList[i] = gbo; + } + TPythonDump() << _this() << ".ExportPartToMED( " + << meshPart << ", r'" << file << "', " + << auto_groups << ", " << version << ", " << overwrite << ", " + << autoDimension << ", " << goList + << ", '" << ( geomAssocFields ? geomAssocFields : "" ) << "'" << " )"; + + SMESH_CATCH( SMESH::throwCorbaException ); +} + +//================================================================================ +/*! + * Write GEOM fields to MED file + */ +//================================================================================ + +void SMESH_Mesh_i::exportMEDFields( DriverMED_W_Field& fieldWriter, + SMESHDS_Mesh* meshDS, + const GEOM::ListOfFields& fields, + const char* geomAssocFields) +{ +#define METH "SMESH_Mesh_i::exportMEDFields() " + + if (( fields.length() < 1 ) && + ( !geomAssocFields || !geomAssocFields[0] )) + return; + + 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; + + for ( size_t iF = 0; iF < fields.length(); ++iF ) + { + // set field data + + int dim = fields[ iF ]->GetDimension(); + SMDSAbs_ElementType elemType; + TopAbs_ShapeEnum shapeType; + switch ( dim ) { + case 0: elemType = SMDSAbs_0DElement; shapeType = TopAbs_VERTEX; break; + case 1: elemType = SMDSAbs_Edge; shapeType = TopAbs_EDGE; break; + case 2: elemType = SMDSAbs_Face; shapeType = TopAbs_FACE; break; + case 3: elemType = SMDSAbs_Volume; shapeType = TopAbs_SOLID; break; + default: + continue; // skip fields on whole shape + } + GEOM::field_data_type dataType = fields[ iF ]->GetDataType(); + if ( dataType == GEOM::FDT_String ) + continue; + GEOM::ListOfLong_var stepIDs = fields[ iF ]->GetSteps(); + if ( stepIDs->length() < 1 ) + continue; + GEOM::string_array_var comps = fields[ iF ]->GetComponents(); + if ( comps->length() < 1 ) + continue; + CORBA::String_var name = fields[ iF ]->GetName(); + + if ( !fieldWriter.Set( meshDS, + name.in(), + elemType, + comps->length(), + /*isIntData=*/false ))//( dataType == GEOM::FDT_Int ))) + continue; + + 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 ]; + if ( subIds.empty() ) + for ( int id = 1; id <= meshDS->MaxShapeIndex(); ++id ) + if ( meshDS->IndexToShape( id ).ShapeType() == shapeType ) + subIds.push_back( id ); + + // write steps + + SMDS_ElemIteratorPtr elemIt = fieldWriter.GetOrderedElems(); + if ( !elemIt ) + continue; + + for ( size_t iS = 0; iS < stepIDs->length(); ++iS ) + { + GEOM::GEOM_FieldStep_var step = fields[ iF ]->GetStep( stepIDs[ iS ]); + if ( step->_is_nil() ) + continue; + + CORBA::Long stamp = step->GetStamp(); + CORBA::Long id = step->GetID(); + 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: + { + 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() * comps->length() ) + THROW_SALOME_CORBA_EXCEPTION( METH "BUG: wrong nb subIds", SALOME::INTERNAL_ERROR ); + 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: + { + 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() * comps->length() ) + THROW_SALOME_CORBA_EXCEPTION( METH "BUG: wrong nb subIds", SALOME::INTERNAL_ERROR ); + 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: + { + 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() * comps->length() ) + THROW_SALOME_CORBA_EXCEPTION( METH "BUG: wrong nb subIds", SALOME::INTERNAL_ERROR ); + 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; + } + + // pass values to fieldWriter + elemIt = fieldWriter.GetOrderedElems(); + if ( dataType == GEOM::FDT_Double ) + while ( elemIt->more() ) + { + const SMDS_MeshElement* e = elemIt->next(); + const int shapeID = e->getshapeId(); + if ( shapeID < 1 || shapeID >= (int) dblVals[0].size() ) + for ( size_t iC = 0; iC < comps->length(); ++iC ) + fieldWriter.AddValue( noneDblValue ); + else + 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[0].size() ) + for ( size_t iC = 0; iC < comps->length(); ++iC ) + fieldWriter.AddValue( (double) noneIntValue ); + else + for ( size_t iC = 0; iC < comps->length(); ++iC ) + fieldWriter.AddValue( (double) intVals[ iC ][ shapeID ]); + } + + // write a step + fieldWriter.Perform(); + SMESH_ComputeErrorPtr res = fieldWriter.GetError(); + if ( res && res->IsKO() ) + { + if ( res->myComment.empty() ) + { THROW_SALOME_CORBA_EXCEPTION( METH "Fatal error", SALOME::INTERNAL_ERROR ); } + else + { THROW_SALOME_CORBA_EXCEPTION( res->myComment.c_str(), SALOME::INTERNAL_ERROR ); } + } + + } // loop on steps + } // loop on fields + + if ( !geomAssocFields || !geomAssocFields[0] ) + return; + + // write geomAssocFields + + std::vector< int > shapeDim( TopAbs_SHAPE + 1 ); + shapeDim[ TopAbs_COMPOUND ] = 3; + shapeDim[ TopAbs_COMPSOLID ] = 3; + shapeDim[ TopAbs_SOLID ] = 3; + shapeDim[ TopAbs_SHELL ] = 2; + shapeDim[ TopAbs_FACE ] = 2; + shapeDim[ TopAbs_WIRE ] = 1; + shapeDim[ TopAbs_EDGE ] = 1; + shapeDim[ TopAbs_VERTEX ] = 0; + shapeDim[ TopAbs_SHAPE ] = 3; + + for ( int iF = 0; geomAssocFields[ iF ]; ++iF ) + { + std::vector< std::string > compNames; + switch ( geomAssocFields[ iF ]) { + case 'v': case 'V': + fieldWriter.Set( meshDS, "_vertices_", SMDSAbs_Node, /*nbComps=*/2, /*isInt=*/false ); + compNames.push_back( "dim" ); + break; + case 'e': case 'E': + fieldWriter.Set( meshDS, "_edges_", SMDSAbs_Edge, /*nbComps=*/1, /*isInt=*/false ); + break; + case 'f': case 'F': + fieldWriter.Set( meshDS, "_faces_", SMDSAbs_Face, /*nbComps=*/1, /*isInt=*/false ); + break; + case 's': case 'S': + fieldWriter.Set( meshDS, "_solids_", SMDSAbs_Volume, /*nbComps=*/1, /*isInt=*/false ); + break; + default: continue; + } + compNames.push_back( "id" ); + for ( size_t iC = 0; iC < compNames.size(); ++iC ) + fieldWriter.SetCompName( iC, compNames[ iC ].c_str() ); + + fieldWriter.SetDtIt( -1, -1 ); + + SMDS_ElemIteratorPtr elemIt = fieldWriter.GetOrderedElems(); + if ( !elemIt ) + continue; + + if ( compNames.size() == 2 ) // _vertices_ + while ( elemIt->more() ) + { + const SMDS_MeshElement* e = elemIt->next(); + const int shapeID = e->getshapeId(); + if ( shapeID < 1 ) + { + fieldWriter.AddValue( (double) -1 ); + fieldWriter.AddValue( (double) -1 ); + } + else + { + const TopoDS_Shape& S = meshDS->IndexToShape( shapeID ); + fieldWriter.AddValue( (double) ( S.IsNull() ? -1 : shapeDim[ S.ShapeType() ])); + fieldWriter.AddValue( (double) shapeID ); + } + } + else + while ( elemIt->more() ) + { + const SMDS_MeshElement* e = elemIt->next(); + const int shapeID = e->getshapeId(); + if ( shapeID < 1 ) + fieldWriter.AddValue( (double) -1 ); + else + fieldWriter.AddValue( (double) shapeID ); + } + + // write a step + fieldWriter.Perform(); + SMESH_ComputeErrorPtr res = fieldWriter.GetError(); + if ( res && res->IsKO() ) + { + if ( res->myComment.empty() ) + { THROW_SALOME_CORBA_EXCEPTION( METH "Fatal error", SALOME::INTERNAL_ERROR ); } + else + { THROW_SALOME_CORBA_EXCEPTION( res->myComment.c_str(), SALOME::INTERNAL_ERROR ); } + } + + } // loop on geomAssocFields + +#undef METH } //================================================================================ @@ -2979,8 +3621,16 @@ 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 ); + if ( !so->_is_nil() ) + { + CORBA::String_var name = so->GetName(); + meshName = name.in(); + } SMESH_MeshPartDS partDS( meshPart ); - _impl->ExportCGNS(file, &partDS); + _impl->ExportCGNS(file, &partDS, meshName.c_str() ); TPythonDump() << SMESH::SMESH_Mesh_var(_this()) << ".ExportCGNS( " << meshPart<< ", r'" << file << "', " << overwrite << ")"; @@ -3133,7 +3783,7 @@ CORBA::Long SMESH_Mesh_i::NbBiQuadQuadrangles()throw(SALOME::SALOME_Exception) return _impl->NbBiQuadQuadrangles(); } -CORBA::Long SMESH_Mesh_i::NbPolygons()throw(SALOME::SALOME_Exception) +CORBA::Long SMESH_Mesh_i::NbPolygons() throw(SALOME::SALOME_Exception) { Unexpect aCatch(SALOME_SalomeException); if ( _preMeshInfo ) @@ -3142,6 +3792,15 @@ CORBA::Long SMESH_Mesh_i::NbPolygons()throw(SALOME::SALOME_Exception) return _impl->NbPolygons(); } +CORBA::Long SMESH_Mesh_i::NbPolygonsOfOrder(SMESH::ElementOrder order) throw(SALOME::SALOME_Exception) +{ + Unexpect aCatch(SALOME_SalomeException); + if ( _preMeshInfo ) + return _preMeshInfo->NbPolygons((SMDSAbs_ElementOrder) order); + + return _impl->NbPolygons((SMDSAbs_ElementOrder)order); +} + CORBA::Long SMESH_Mesh_i::NbFacesOfOrder(SMESH::ElementOrder order) throw(SALOME::SALOME_Exception) { @@ -3438,7 +4097,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 ) @@ -3586,7 +4245,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 ) @@ -3624,8 +4283,7 @@ CORBA::LongLong SMESH_Mesh_i::GetMeshPtr() _preMeshInfo->FullLoadFromFile(); CORBA::LongLong pointeur = CORBA::LongLong(_impl); - if ( MYDEBUG ) - MESSAGE("CORBA::LongLong SMESH_Mesh_i::GetMeshPtr() "<GetInverseElementIterator(); - TColStd_SequenceOfInteger IDs; - while(eIt->more()) { + aResult->length( aNode->NbInverseElements() ); + for( int i = 0; eIt->more(); ++i ) + { const SMDS_MeshElement* elem = eIt->next(); - IDs.Append(elem->GetID()); - } - if(IDs.Length()>0) { - aResult->length(IDs.Length()); - int i = 1; - for(; i<=IDs.Length(); i++) { - aResult[i-1] = IDs.Value(i); - } + aResult[ i ] = elem->GetID(); } return aResult._retn(); } @@ -4038,7 +4690,7 @@ SMESH::long_array* SMESH_Mesh_i::GetElemFaceNodes(CORBA::Long elemId, { aResult->length( vtool.NbFaceNodes( faceIndex )); const SMDS_MeshNode** nn = vtool.GetFaceNodes( faceIndex ); - for ( int i = 0; i < aResult->length(); ++i ) + for ( CORBA::ULong i = 0; i < aResult->length(); ++i ) aResult[ i ] = nn[ i ]->GetID(); } } @@ -4087,7 +4739,7 @@ CORBA::Long SMESH_Mesh_i::FindElementByNodes(const SMESH::long_array& nodes) if ( SMESHDS_Mesh* mesh = _impl->GetMeshDS() ) { vector< const SMDS_MeshNode * > nn( nodes.length() ); - for ( int i = 0; i < nodes.length(); ++i ) + for ( CORBA::ULong i = 0; i < nodes.length(); ++i ) if ( !( nn[i] = mesh->FindNode( nodes[i] ))) return elemID; @@ -4225,6 +4877,7 @@ SMESH_Mesh_i::MakeGroupsOfBadInputElements( int theSubShapeID, THROW_SALOME_CORBA_EXCEPTION( "empty group name",SALOME::BAD_PARAM ); SMESH::ListOfGroups_var groups = new SMESH::ListOfGroups; + ::SMESH_MeshEditor::ElemFeatures elemType; // submesh by subshape id if ( !_impl->HasShapeToMesh() ) theSubShapeID = 1; @@ -4257,7 +4910,7 @@ SMESH_Mesh_i::MakeGroupsOfBadInputElements( int theSubShapeID, if ( elem ) { ::SMESH_MeshEditor editor( _impl ); - elem = editor.AddElement( nodes, elem->GetType(), elem->IsPoly() ); + elem = editor.AddElement( nodes, elemType.Init( elem )); } } if ( elem ) @@ -4284,7 +4937,6 @@ SMESH_Mesh_i::MakeGroupsOfBadInputElements( int theSubShapeID, SALOMEDS::SObject_wrap aSO = _gen_i->PublishGroup( study, mesh, groups[ iG ], GEOM::GEOM_Object::_nil(), theGroupName); - aSO->_is_nil(); // avoid "unused variable" warning } SMESH_GroupBase_i* grp_i = SMESH::DownCast< SMESH_GroupBase_i* >( groups[ iG ]); if ( !grp_i ) continue; @@ -4476,11 +5128,11 @@ SMESH::string_array* SMESH_Mesh_i::GetLastParameters() 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(int i = 0;i < aVars.length();i++) - aResult[i] = CORBA::string_dup( aVars[i]); + 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] ); } } } @@ -4506,6 +5158,8 @@ SMESH::array_of_ElementType* SMESH_Mesh_i::GetTypes() if (_impl->NbVolumes()) types[nbTypes++] = SMESH::VOLUME; if (_impl->Nb0DElements()) types[nbTypes++] = SMESH::ELEM0D; if (_impl->NbBalls()) types[nbTypes++] = SMESH::BALL; + if (_impl->NbNodes() && + nbTypes == 0 ) types[nbTypes++] = SMESH::NODE; types->length( nbTypes ); return types._retn(); @@ -4595,6 +5249,37 @@ void SMESH_Mesh_i::CollectMeshInfo(const SMDS_ElemIteratorPtr theItr, while (theItr->more()) theInfo[ theItr->next()->GetEntityType() ]++; } +//============================================================================= +/* + * Returns mesh unstructed grid information. + */ +//============================================================================= + +SALOMEDS::TMPFile* SMESH_Mesh_i::GetVtkUgStream() +{ + SALOMEDS::TMPFile_var SeqFile; + if ( SMESHDS_Mesh* aMeshDS = _impl->GetMeshDS() ) { + SMDS_UnstructuredGrid* aGrid = aMeshDS->getGrid(); + if(aGrid) { + vtkUnstructuredGridWriter* aWriter = vtkUnstructuredGridWriter::New(); + aWriter->WriteToOutputStringOn(); + aWriter->SetInputData(aGrid); + aWriter->SetFileTypeToBinary(); + aWriter->Write(); + char* str = aWriter->GetOutputString(); + int size = aWriter->GetOutputStringLength(); + + //Allocate octect buffer of required size + CORBA::Octet* OctetBuf = SALOMEDS::TMPFile::allocbuf(size); + //Copy ostrstream content to the octect buffer + memcpy(OctetBuf, str, size); + //Create and return TMPFile + SeqFile = new SALOMEDS::TMPFile(size, size, OctetBuf, 1); + aWriter->Delete(); + } + } + return SeqFile._retn(); +} //============================================================================= namespace /* Iterators used in SMESH_Mesh_i::GetElements(SMESH::SMESH_IDSource_var obj, @@ -4678,7 +5363,7 @@ namespace /* Iterators used in SMESH_Mesh_i::GetElements(SMESH::SMESH_IDSource_v _elem = _mesh->FindNode( *_idPtr++ ); } else if ((_elem = _mesh->FindElement( *_idPtr++ )) && - _elem->GetType() != _type ) + (_elem->GetType() != _type && _type != SMDSAbs_All )) { _elem = 0; } @@ -4739,7 +5424,7 @@ SMDS_ElemIteratorPtr SMESH_Mesh_i::GetElements(SMESH::SMESH_IDSource_ptr theObje SMESH::ElementType theType) { SMDS_ElemIteratorPtr elemIt; - bool typeOK = false; + bool typeOK = ( theType == SMESH::ALL ); SMDSAbs_ElementType elemType = SMDSAbs_ElementType( theType ); SMESH::SMESH_Mesh_var meshVar = theObject->GetMesh(); @@ -4758,7 +5443,7 @@ SMDS_ElemIteratorPtr SMESH_Mesh_i::GetElements(SMESH::SMESH_IDSource_ptr theObje if ( sm ) { elemIt = sm->GetElements(); - if ( elemType != SMDSAbs_Node ) + if ( elemType != SMDSAbs_Node && elemType != SMDSAbs_All ) { typeOK = ( elemIt && elemIt->more() && elemIt->next()->GetType() == elemType ); elemIt = typeOK ? sm->GetElements() : SMDS_ElemIteratorPtr(); @@ -4768,15 +5453,19 @@ SMDS_ElemIteratorPtr SMESH_Mesh_i::GetElements(SMESH::SMESH_IDSource_ptr theObje else if ( SMESH_GroupBase_i* group_i = SMESH::DownCast( theObject )) { SMESHDS_GroupBase* groupDS = group_i->GetGroupDS(); - if ( groupDS && ( groupDS->GetType() == elemType || elemType == SMDSAbs_Node )) + if ( groupDS && ( elemType == groupDS->GetType() || + elemType == SMDSAbs_Node || + elemType == SMDSAbs_All )) { elemIt = groupDS->GetElements(); - typeOK = ( groupDS->GetType() == elemType ); + typeOK = ( groupDS->GetType() == elemType || elemType == SMDSAbs_All ); } } else if ( SMESH::Filter_i* filter_i = SMESH::DownCast( theObject )) { - if ( filter_i->GetElementType() == theType || elemType == SMDSAbs_Node ) + if ( filter_i->GetElementType() == theType || + elemType == SMDSAbs_Node || + elemType == SMDSAbs_All) { SMESH::Predicate_i* pred_i = filter_i->GetPredicate_i(); if ( pred_i && pred_i->GetPredicate() ) @@ -4784,7 +5473,7 @@ SMDS_ElemIteratorPtr SMESH_Mesh_i::GetElements(SMESH::SMESH_IDSource_ptr theObje SMDSAbs_ElementType filterType = SMDSAbs_ElementType( filter_i->GetElementType() ); SMDS_ElemIteratorPtr allElemIt = meshDS->elementsIterator( filterType ); elemIt = SMDS_ElemIteratorPtr( new PredicateIterator( allElemIt, pred_i->GetPredicate() )); - typeOK = ( filterType == elemType ); + typeOK = ( filterType == elemType || elemType == SMDSAbs_All ); } } } @@ -4792,7 +5481,7 @@ SMDS_ElemIteratorPtr SMESH_Mesh_i::GetElements(SMESH::SMESH_IDSource_ptr theObje { SMESH::array_of_ElementType_var types = theObject->GetTypes(); const bool isNodes = ( types->length() == 1 && types[0] == SMESH::NODE ); - if ( isNodes && elemType != SMDSAbs_Node ) + if ( isNodes && elemType != SMDSAbs_Node && elemType != SMDSAbs_All ) return elemIt; if ( SMESH_MeshEditor_i::IsTemporaryIDSource( theObject )) { @@ -4805,7 +5494,7 @@ SMDS_ElemIteratorPtr SMESH_Mesh_i::GetElements(SMESH::SMESH_IDSource_ptr theObje SMESH::long_array_var ids = theObject->GetIDs(); elemIt = SMDS_ElemIteratorPtr( new IDSourceIterator( meshDS, ids._retn(), elemType )); } - typeOK = ( isNodes == ( elemType == SMDSAbs_Node )); + typeOK = ( isNodes == ( elemType == SMDSAbs_Node )) || ( elemType == SMDSAbs_All ); } if ( elemIt && elemIt->more() && !typeOK ) @@ -4965,7 +5654,7 @@ class SMESH_DimHyp if ( find( theOther->_hypotheses.begin(), otheEndIt, *hypIt ) != otheEndIt ) nbSame++; // the submeshes are concurrent if their algorithms has different parameters - return nbSame != theOther->_hypotheses.size() - 1; + return nbSame != (int)theOther->_hypotheses.size() - 1; } // Return true if algorithm of this SMESH_DimHyp is used if no @@ -5276,6 +5965,8 @@ TListOfListOfInt SMESH_Mesh_i::findConcurrentSubMeshes() { const SMESH::submesh_array& aSMArray = theSubMeshArray[i]; TListOfInt subMeshIds; + if ( i > 0 ) + aPythonDump << ", "; aPythonDump << "[ "; // Collect subMeshes which should be clear // do it list-by-list, because modification of submesh order @@ -5396,14 +6087,14 @@ SMESH_MeshPartDS::SMESH_MeshPartDS(SMESH::SMESH_IDSource_ptr meshPart): SMESH::array_of_ElementType_var types = meshPart->GetTypes(); if ( types->length() == 1 && types[0] == SMESH::NODE ) // group of nodes { - for (int i=0; i < anIDs->length(); i++) - if ( const SMDS_MeshNode * n = _meshDS->FindNode(anIDs[i])) + for ( CORBA::ULong i=0; i < anIDs->length(); i++ ) + if ( const SMDS_MeshNode * n = _meshDS->FindNode( anIDs[i] )) if ( _elements[ SMDSAbs_Node ].insert( n ).second ) tmpInfo.Add( n ); } else { - for (int i=0; i < anIDs->length(); i++) + for ( CORBA::ULong i=0; i < anIDs->length(); i++ ) if ( const SMDS_MeshElement * e = _meshDS->FindElement(anIDs[i])) if ( _elements[ e->GetType() ].insert( e ).second ) { @@ -5419,6 +6110,8 @@ SMESH_MeshPartDS::SMESH_MeshPartDS(SMESH::SMESH_IDSource_ptr meshPart): } myInfo = tmpInfo; + ShapeToMesh( _meshDS->ShapeToMesh() ); + _meshDS = 0; // to enforce iteration on _elements and _nodes } }