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=2e4d1772c2a1bd5c01ea74c750e27528eda85aeb;hp=8371ccf2f28b34df70397330b2d982b4343012b9;hb=bd4e115a78b52e3fbc016e5e30bb0e19b2a9e7d6;hpb=0635c9fc80f67d1e5dc0e94ec85f487286a92070 diff --git a/src/SMESH_I/SMESH_Mesh_i.cxx b/src/SMESH_I/SMESH_Mesh_i.cxx index 8371ccf2f..2e4d1772c 100644 --- a/src/SMESH_I/SMESH_Mesh_i.cxx +++ b/src/SMESH_I/SMESH_Mesh_i.cxx @@ -1,57 +1,60 @@ -// Copyright (C) 2007-2008 CEA/DEN, EDF R&D, OPEN CASCADE +// Copyright (C) 2007-2012 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 +// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, +// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS // -// This library is free software; you can redistribute it and/or -// modify it under the terms of the GNU Lesser General Public -// License as published by the Free Software Foundation; either -// version 2.1 of the License. +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License. // -// This library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -// Lesser General Public License for more details. +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. // -// You should have received a copy of the GNU Lesser General Public -// License along with this library; if not, write to the Free Software -// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA // -// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com // -// SMESH SMESH_I : idl implementation based on 'SMESH' unit's calsses // File : SMESH_Mesh_i.cxx // Author : Paul RASCLE, EDF // Module : SMESH -// -#include "SMESH_Mesh_i.hxx" -#include "SMESH_Filter_i.hxx" -#include "SMESH_Gen_i.hxx" -#include "SMESH_Group_i.hxx" -#include "SMESH_MEDMesh_i.hxx" -#include "SMESH_MeshEditor_i.hxx" -#include "SMESH_PythonDump.hxx" -#include "SMESH_subMesh_i.hxx" +#include "SMESH_Mesh_i.hxx" #include "DriverMED_R_SMESHDS_Mesh.h" #include "DriverMED_W_SMESHDS_Mesh.h" +#include "SMDS_EdgePosition.hxx" +#include "SMDS_ElemIterator.hxx" +#include "SMDS_FacePosition.hxx" +#include "SMDS_IteratorOnIterators.hxx" +#include "SMDS_SetIterator.hxx" #include "SMDS_VolumeTool.hxx" #include "SMESHDS_Command.hxx" #include "SMESHDS_CommandType.hxx" #include "SMESHDS_GroupOnGeom.hxx" +#include "SMESH_Filter_i.hxx" +#include "SMESH_Gen_i.hxx" #include "SMESH_Group.hxx" +#include "SMESH_Group_i.hxx" +#include "SMESH_MEDMesh_i.hxx" #include "SMESH_MeshEditor.hxx" +#include "SMESH_MeshEditor_i.hxx" #include "SMESH_MesherHelper.hxx" -#include "SMDS_EdgePosition.hxx" -#include "SMDS_FacePosition.hxx" +#include "SMESH_PreMeshInfo.hxx" +#include "SMESH_PythonDump.hxx" +#include "SMESH_subMesh_i.hxx" -#include "OpUtil.hxx" -#include "SALOME_NamingService.hxx" -#include "Utils_CorbaException.hxx" -#include "Utils_ExceptHandlers.hxx" -#include "Utils_SINGLETON.hxx" -#include "utilities.h" +#include +#include +#include +#include +#include +#include +#include // OCCT Includes #include @@ -63,10 +66,14 @@ #include #include #include +#include #include #include +#include +#include // STL Includes +#include #include #include #include @@ -81,9 +88,11 @@ static int MYDEBUG = 0; using namespace std; using SMESH::TPythonDump; -int SMESH_Mesh_i::myIdGenerator = 0; - +int SMESH_Mesh_i::_idGenerator = 0; +//To disable automatic genericobj management, the following line should be commented. +//Otherwise, it should be uncommented. Refer to KERNEL_SRC/src/SALOMEDSImpl/SALOMEDSImpl_AttributeIOR.cxx +#define WITHGENERICOBJ //============================================================================= /*! @@ -92,15 +101,16 @@ int SMESH_Mesh_i::myIdGenerator = 0; //============================================================================= SMESH_Mesh_i::SMESH_Mesh_i( PortableServer::POA_ptr thePOA, - SMESH_Gen_i* gen_i, - CORBA::Long studyId ) + SMESH_Gen_i* gen_i, + CORBA::Long studyId ) : SALOME::GenericObj_i( thePOA ) { MESSAGE("SMESH_Mesh_i"); _impl = NULL; _gen_i = gen_i; - _id = myIdGenerator++; + _id = _idGenerator++; _studyId = studyId; + _preMeshInfo = NULL; } //============================================================================= @@ -111,19 +121,52 @@ SMESH_Mesh_i::SMESH_Mesh_i( PortableServer::POA_ptr thePOA, SMESH_Mesh_i::~SMESH_Mesh_i() { - INFOS("~SMESH_Mesh_i"); - map::iterator it; - for ( it = _mapGroups.begin(); it != _mapGroups.end(); it++ ) { - SMESH_GroupBase_i* aGroup = dynamic_cast( SMESH_Gen_i::GetServant( it->second ).in() ); - if ( aGroup ) { - // this method is colled from destructor of group (PAL6331) + MESSAGE("~SMESH_Mesh_i"); + +#ifdef WITHGENERICOBJ + // destroy groups + map::iterator itGr; + for (itGr = _mapGroups.begin(); itGr != _mapGroups.end(); itGr++) { + if ( CORBA::is_nil( itGr->second )) + continue; + SMESH_GroupBase_i* aGroup = dynamic_cast(SMESH_Gen_i::GetServant(itGr->second).in()); + if (aGroup) { + // this method is called from destructor of group (PAL6331) //_impl->RemoveGroup( aGroup->GetLocalID() ); - - aGroup->Destroy(); + aGroup->myMeshServant = 0; + aGroup->UnRegister(); } } _mapGroups.clear(); - delete _impl; + + // destroy submeshes + map::iterator itSM; + for ( itSM = _mapSubMeshIor.begin(); itSM != _mapSubMeshIor.end(); itSM++ ) { + if ( CORBA::is_nil( itSM->second )) + continue; + SMESH_subMesh_i* aSubMesh = dynamic_cast(SMESH_Gen_i::GetServant(itSM->second).in()); + if (aSubMesh) { + aSubMesh->UnRegister(); + } + } + _mapSubMeshIor.clear(); + + // destroy hypotheses + map::iterator itH; + for ( itH = _mapHypo.begin(); itH != _mapHypo.end(); itH++ ) { + if ( CORBA::is_nil( itH->second )) + continue; + SMESH_Hypothesis_i* aHypo = dynamic_cast(SMESH_Gen_i::GetServant(itH->second).in()); + if (aHypo) { + aHypo->UnRegister(); + } + } + _mapHypo.clear(); +#endif + + delete _impl; _impl = NULL; + + if ( _preMeshInfo ) delete _preMeshInfo; _preMeshInfo = NULL; } //============================================================================= @@ -146,6 +189,8 @@ void SMESH_Mesh_i::SetShape( GEOM::GEOM_Object_ptr theShapeObject ) catch(SALOME_Exception & S_ex) { THROW_SALOME_CORBA_EXCEPTION(S_ex.what(), SALOME::BAD_PARAM); } + // to track changes of GEOM groups + addGeomGroupData( theShapeObject, _this() ); } //================================================================================ @@ -189,6 +234,31 @@ GEOM::GEOM_Object_ptr SMESH_Mesh_i::GetShapeToMesh() return aShapeObj._retn(); } +//================================================================================ +/*! + * \brief Return false if the mesh is not yet fully loaded from the study file + */ +//================================================================================ + +CORBA::Boolean SMESH_Mesh_i::IsLoaded() throw (SALOME::SALOME_Exception) +{ + Unexpect aCatch(SALOME_SalomeException); + return !_preMeshInfo; +} + +//================================================================================ +/*! + * \brief Load full mesh data from the study file + */ +//================================================================================ + +void SMESH_Mesh_i::Load() throw (SALOME::SALOME_Exception) +{ + Unexpect aCatch(SALOME_SalomeException); + if ( _preMeshInfo ) + _preMeshInfo->FullLoadFromFile(); +} + //================================================================================ /*! * \brief Remove all nodes and elements @@ -198,8 +268,12 @@ GEOM::GEOM_Object_ptr SMESH_Mesh_i::GetShapeToMesh() void SMESH_Mesh_i::Clear() throw (SALOME::SALOME_Exception) { Unexpect aCatch(SALOME_SalomeException); + if ( _preMeshInfo ) + _preMeshInfo->ForgetAllData(); + try { _impl->Clear(); + CheckGeomGroupModif(); // issue 20145 } catch(SALOME_Exception & S_ex) { THROW_SALOME_CORBA_EXCEPTION(S_ex.what(), SALOME::BAD_PARAM); @@ -217,6 +291,9 @@ void SMESH_Mesh_i::ClearSubMesh(CORBA::Long ShapeID) throw (SALOME::SALOME_Exception) { Unexpect aCatch(SALOME_SalomeException); + if ( _preMeshInfo ) + _preMeshInfo->FullLoadFromFile(); + try { _impl->ClearSubMesh( ShapeID ); } @@ -280,9 +357,9 @@ SMESH_Mesh_i::ImportMEDFile( const char* theFileName, const char* theMeshName ) int major, minor, release; if( !MED::getMEDVersion( theFileName, major, minor, release ) ) major = minor = release = -1; - myFileInfo = new SALOME_MED::MedFileInfo(); - myFileInfo->fileName = theFileName; - myFileInfo->fileSize = 0; + _medFileInfo = new SALOME_MED::MedFileInfo(); + _medFileInfo->fileName = theFileName; + _medFileInfo->fileSize = 0; #ifdef WIN32 struct _stati64 d; if ( ::_stati64( theFileName, &d ) != -1 ) @@ -290,10 +367,38 @@ SMESH_Mesh_i::ImportMEDFile( const char* theFileName, const char* theMeshName ) struct stat64 d; if ( ::stat64( theFileName, &d ) != -1 ) #endif - myFileInfo->fileSize = d.st_size; - myFileInfo->major = major; - myFileInfo->minor = minor; - myFileInfo->release = release; + _medFileInfo->fileSize = d.st_size; + _medFileInfo->major = major; + _medFileInfo->minor = minor; + _medFileInfo->release = release; + + return ConvertDriverMEDReadStatus(status); +} + +//================================================================================ +/*! + * \brief Imports mesh data from the CGNS file + */ +//================================================================================ + +SMESH::DriverMED_ReadStatus SMESH_Mesh_i::ImportCGNSFile( const char* theFileName, + const int theMeshIndex, + std::string& theMeshName ) + throw ( SALOME::SALOME_Exception ) +{ + Unexpect aCatch(SALOME_SalomeException); + int status; + try { + status = _impl->CGNSToMesh( theFileName, theMeshIndex, theMeshName ); + } + catch( SALOME_Exception& S_ex ) { + THROW_SALOME_CORBA_EXCEPTION(S_ex.what(), SALOME::BAD_PARAM); + } + catch ( ... ) { + THROW_SALOME_CORBA_EXCEPTION("ImportCGNSFile(): unknown exception", SALOME::BAD_PARAM); + } + + CreateGroupServants(); return ConvertDriverMEDReadStatus(status); } @@ -306,7 +411,7 @@ SMESH_Mesh_i::ImportMEDFile( const char* theFileName, const char* theMeshName ) char* SMESH_Mesh_i::GetVersionString(SMESH::MED_VERSION version, CORBA::Short nbDigits) { - std::string ver = DriverMED_W_SMESHDS_Mesh::GetVersionString(MED::EVersion(version), + string ver = DriverMED_W_SMESHDS_Mesh::GetVersionString(MED::EVersion(version), nbDigits); return CORBA::string_dup( ver.c_str() ); } @@ -346,23 +451,6 @@ int SMESH_Mesh_i::ImportSTLFile( const char* theFileName ) return 1; } -//============================================================================= -/*! - * importMEDFile - * - * Imports mesh data from MED file - */ -//============================================================================= - -// int SMESH_Mesh_i::importMEDFile( const char* theFileName, const char* theMeshName ) -// { -// // Read mesh with name = and all its groups into SMESH_Mesh -// int status = _impl->MEDToMesh( theFileName, theMeshName ); -// CreateGroupServants(); - -// return status; -// } - //============================================================================= /*! * @@ -404,11 +492,14 @@ SMESH::Hypothesis_Status SMESH_Mesh_i::ConvertHypothesisStatus */ //============================================================================= -SMESH::Hypothesis_Status SMESH_Mesh_i::AddHypothesis(GEOM::GEOM_Object_ptr aSubShapeObject, +SMESH::Hypothesis_Status SMESH_Mesh_i::AddHypothesis(GEOM::GEOM_Object_ptr aSubShapeObject, SMESH::SMESH_Hypothesis_ptr anHyp) throw(SALOME::SALOME_Exception) { Unexpect aCatch(SALOME_SalomeException); + if ( _preMeshInfo ) + _preMeshInfo->ForgetOrLoad(); + SMESH_Hypothesis::Hypothesis_Status status = addHypothesis( aSubShapeObject, anHyp ); if ( !SMESH_Hypothesis::IsStatusFatal(status) ) @@ -442,7 +533,7 @@ SMESH_Hypothesis::Hypothesis_Status if(MYDEBUG) MESSAGE("addHypothesis"); if (CORBA::is_nil(aSubShapeObject) && HasShapeToMesh()) - THROW_SALOME_CORBA_EXCEPTION("bad subShape reference", + THROW_SALOME_CORBA_EXCEPTION("bad Sub-shape reference", SALOME::BAD_PARAM); SMESH::SMESH_Hypothesis_var myHyp = SMESH::SMESH_Hypothesis::_narrow(anHyp); @@ -464,6 +555,9 @@ SMESH_Hypothesis::Hypothesis_Status status = _impl->AddHypothesis(myLocSubShape, hypId); if ( !SMESH_Hypothesis::IsStatusFatal(status) ) { _mapHypo[hypId] = SMESH::SMESH_Hypothesis::_duplicate( myHyp ); +#ifdef WITHGENERICOBJ + _mapHypo[hypId]->Register(); +#endif // assure there is a corresponding submesh if ( !_impl->IsMainShape( myLocSubShape )) { int shapeId = _impl->GetMeshDS()->ShapeToIndex( myLocSubShape ); @@ -490,6 +584,9 @@ SMESH::Hypothesis_Status SMESH_Mesh_i::RemoveHypothesis(GEOM::GEOM_Object_ptr aS throw(SALOME::SALOME_Exception) { Unexpect aCatch(SALOME_SalomeException); + if ( _preMeshInfo ) + _preMeshInfo->ForgetOrLoad(); + SMESH_Hypothesis::Hypothesis_Status status = removeHypothesis( aSubShapeObject, anHyp ); if ( !SMESH_Hypothesis::IsStatusFatal(status) ) @@ -516,41 +613,40 @@ 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::SMESH_Hypothesis_ptr anHyp) +SMESH_Hypothesis::Hypothesis_Status +SMESH_Mesh_i::removeHypothesis(GEOM::GEOM_Object_ptr aSubShapeObject, + SMESH::SMESH_Hypothesis_ptr anHyp) { - if(MYDEBUG) MESSAGE("removeHypothesis()"); - // **** proposer liste de subShape (selection multiple) + if(MYDEBUG) MESSAGE("removeHypothesis()"); + // **** proposer liste de sub-shape (selection multiple) + + if (CORBA::is_nil(aSubShapeObject) && HasShapeToMesh()) + THROW_SALOME_CORBA_EXCEPTION("bad Sub-shape reference", SALOME::BAD_PARAM); - if (CORBA::is_nil(aSubShapeObject) && HasShapeToMesh()) - THROW_SALOME_CORBA_EXCEPTION("bad subShape reference", - SALOME::BAD_PARAM); + SMESH::SMESH_Hypothesis_var myHyp = SMESH::SMESH_Hypothesis::_narrow(anHyp); + if (CORBA::is_nil(myHyp)) + THROW_SALOME_CORBA_EXCEPTION("bad hypothesis reference", SALOME::BAD_PARAM); - SMESH::SMESH_Hypothesis_var myHyp = SMESH::SMESH_Hypothesis::_narrow(anHyp); - if (CORBA::is_nil(myHyp)) - THROW_SALOME_CORBA_EXCEPTION("bad hypothesis reference", - SALOME::BAD_PARAM); + SMESH_Hypothesis::Hypothesis_Status status = SMESH_Hypothesis::HYP_OK; + try + { + TopoDS_Shape myLocSubShape; + //use PseudoShape in case if mesh has no shape + if(HasShapeToMesh()) + myLocSubShape = _gen_i->GeomObjectToShape( aSubShapeObject); + else + myLocSubShape = _impl->GetShapeToMesh(); - SMESH_Hypothesis::Hypothesis_Status status = SMESH_Hypothesis::HYP_OK; - try - { - TopoDS_Shape myLocSubShape; - //use PseudoShape in case if mesh has no shape - if(HasShapeToMesh()) - myLocSubShape = _gen_i->GeomObjectToShape( aSubShapeObject); - else - myLocSubShape = _impl->GetShapeToMesh(); - - int hypId = myHyp->GetId(); - status = _impl->RemoveHypothesis(myLocSubShape, hypId); - if ( !SMESH_Hypothesis::IsStatusFatal(status) ) - _mapHypo.erase( hypId ); - } - catch(SALOME_Exception & S_ex) - { - THROW_SALOME_CORBA_EXCEPTION(S_ex.what(), SALOME::BAD_PARAM); - } - return status; + int hypId = myHyp->GetId(); + status = _impl->RemoveHypothesis(myLocSubShape, hypId); +// if ( !SMESH_Hypothesis::IsStatusFatal(status) ) EAP: hyp can be used on many sub-shapes +// _mapHypo.erase( hypId ); + } + catch(SALOME_Exception & S_ex) + { + THROW_SALOME_CORBA_EXCEPTION(S_ex.what(), SALOME::BAD_PARAM); + } + return status; } //============================================================================= @@ -560,19 +656,20 @@ SMESH_Hypothesis::Hypothesis_Status SMESH_Mesh_i::removeHypothesis(GEOM::GEOM_Ob //============================================================================= SMESH::ListOfHypothesis * - SMESH_Mesh_i::GetHypothesisList(GEOM::GEOM_Object_ptr aSubShapeObject) + SMESH_Mesh_i::GetHypothesisList(GEOM::GEOM_Object_ptr aSubShapeObject) throw(SALOME::SALOME_Exception) { Unexpect aCatch(SALOME_SalomeException); if (MYDEBUG) MESSAGE("GetHypothesisList"); - if (CORBA::is_nil(aSubShapeObject)) - THROW_SALOME_CORBA_EXCEPTION("bad subShape reference", - SALOME::BAD_PARAM); + if (_impl->HasShapeToMesh() && CORBA::is_nil(aSubShapeObject)) + 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); + if ( myLocSubShape.IsNull() && !_impl->HasShapeToMesh() ) + myLocSubShape = _impl->GetShapeToMesh(); const list& aLocalList = _impl->GetHypothesisList( myLocSubShape ); int i = 0, n = aLocalList.size(); aList->length( n ); @@ -580,7 +677,7 @@ throw(SALOME::SALOME_Exception) for ( list::const_iterator anIt = aLocalList.begin(); i < n && anIt != aLocalList.end(); anIt++ ) { SMESHDS_Hypothesis* aHyp = (SMESHDS_Hypothesis*)(*anIt); if ( _mapHypo.find( aHyp->GetID() ) != _mapHypo.end() ) - aList[i++] = SMESH::SMESH_Hypothesis::_narrow( _mapHypo[aHyp->GetID()] ); + aList[i++] = SMESH::SMESH_Hypothesis::_narrow( _mapHypo[aHyp->GetID()] ); } aList->length( i ); @@ -592,20 +689,56 @@ throw(SALOME::SALOME_Exception) return aList._retn(); } +SMESH::submesh_array* SMESH_Mesh_i::GetSubMeshes() throw (SALOME::SALOME_Exception) +{ + Unexpect aCatch(SALOME_SalomeException); + if (MYDEBUG) MESSAGE("GetSubMeshes"); + + SMESH::submesh_array_var aList = new SMESH::submesh_array(); + + // Python Dump + TPythonDump aPythonDump; + if ( !_mapSubMeshIor.empty() ) + aPythonDump << "[ "; + + try { + aList->length( _mapSubMeshIor.size() ); + int i = 0; + map::iterator it = _mapSubMeshIor.begin(); + for ( ; it != _mapSubMeshIor.end(); it++ ) { + if ( CORBA::is_nil( it->second )) continue; + aList[i++] = SMESH::SMESH_subMesh::_duplicate( it->second ); + // Python Dump + if (i > 1) aPythonDump << ", "; + aPythonDump << it->second; + } + aList->length( i ); + } + catch(SALOME_Exception & S_ex) { + THROW_SALOME_CORBA_EXCEPTION(S_ex.what(), SALOME::BAD_PARAM); + } + + // Update Python script + if ( !_mapSubMeshIor.empty() ) + aPythonDump << " ] = " << _this() << ".GetSubMeshes()"; + + return aList._retn(); +} + //============================================================================= /*! * */ //============================================================================= SMESH::SMESH_subMesh_ptr SMESH_Mesh_i::GetSubMesh(GEOM::GEOM_Object_ptr aSubShapeObject, - const char* theName ) + const char* theName ) throw(SALOME::SALOME_Exception) { Unexpect aCatch(SALOME_SalomeException); MESSAGE("SMESH_Mesh_i::GetSubMesh"); if (CORBA::is_nil(aSubShapeObject)) - THROW_SALOME_CORBA_EXCEPTION("bad subShape reference", - SALOME::BAD_PARAM); + THROW_SALOME_CORBA_EXCEPTION("bad Sub-shape reference", + SALOME::BAD_PARAM); SMESH::SMESH_subMesh_var subMesh; SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_narrow(_this()); @@ -615,12 +748,18 @@ SMESH::SMESH_subMesh_ptr SMESH_Mesh_i::GetSubMesh(GEOM::GEOM_Object_ptr aSubShap //Get or Create the SMESH_subMesh object implementation int subMeshId = _impl->GetMeshDS()->ShapeToIndex( myLocSubShape ); + + if ( !subMeshId && ! _impl->GetMeshDS()->IsGroupOfSubShapes( myLocSubShape )) + { + TopoDS_Iterator it( myLocSubShape ); + if ( it.More() ) + THROW_SALOME_CORBA_EXCEPTION("not sub-shape of the main shape", SALOME::BAD_PARAM); + } subMesh = getSubMesh( subMeshId ); // create a new subMesh object servant if there is none for the shape if ( subMesh->_is_nil() ) subMesh = createSubMesh( aSubShapeObject ); - if ( _gen_i->CanPublishInStudy( subMesh )) { SALOMEDS::SObject_var aSO = _gen_i->PublishSubMesh(_gen_i->GetCurrentStudy(), aMesh, @@ -660,7 +799,10 @@ void SMESH_Mesh_i::RemoveSubMesh( SMESH::SMESH_subMesh_ptr theSubMesh ) long aTag = SMESH_Gen_i::GetRefOnShapeTag(); SALOMEDS::SObject_var anObj, aRef; if ( anSO->FindSubObject( aTag, anObj ) && anObj->ReferencedObject( aRef ) ) - aSubShapeObject = GEOM::GEOM_Object::_narrow( aRef->GetObject() ); + aSubShapeObject = GEOM::GEOM_Object::_narrow( aRef->GetObject() ); + +// if ( aSubShapeObject->_is_nil() ) // not published shape (IPAL13617) +// aSubShapeObject = theSubMesh->GetSubShape(); aStudy->NewBuilder()->RemoveObjectWithChildren( anSO ); @@ -669,26 +811,9 @@ void SMESH_Mesh_i::RemoveSubMesh( SMESH::SMESH_subMesh_ptr theSubMesh ) } } - removeSubMesh( theSubMesh, aSubShapeObject.in() ); -} - -//============================================================================= -/*! - * ElementTypeString - */ -//============================================================================= -#define CASE2STRING(enum) case SMESH::enum: return "SMESH."#enum; -inline TCollection_AsciiString ElementTypeString (SMESH::ElementType theElemType) -{ - switch (theElemType) { - CASE2STRING( ALL ); - CASE2STRING( NODE ); - CASE2STRING( EDGE ); - CASE2STRING( FACE ); - CASE2STRING( VOLUME ); - default:; - } - return ""; + if ( removeSubMesh( theSubMesh, aSubShapeObject.in() )) + if ( _preMeshInfo ) + _preMeshInfo->ForgetOrLoad(); } //============================================================================= @@ -698,10 +823,13 @@ inline TCollection_AsciiString ElementTypeString (SMESH::ElementType theElemType //============================================================================= SMESH::SMESH_Group_ptr SMESH_Mesh_i::CreateGroup( SMESH::ElementType theElemType, - const char* theName ) + const char* theName ) throw(SALOME::SALOME_Exception) { Unexpect aCatch(SALOME_SalomeException); + if ( _preMeshInfo ) + _preMeshInfo->FullLoadFromFile(); + SMESH::SMESH_Group_var aNewGroup = SMESH::SMESH_Group::_narrow( createGroup( theElemType, theName )); @@ -712,7 +840,7 @@ SMESH::SMESH_Group_ptr SMESH_Mesh_i::CreateGroup( SMESH::ElementType theElemType if ( !aSO->_is_nil()) { // Update Python script TPythonDump() << aSO << " = " << _this() << ".CreateGroup( " - << ElementTypeString(theElemType) << ", '" << theName << "' )"; + << theElemType << ", '" << theName << "' )"; } } return aNewGroup._retn(); @@ -724,18 +852,24 @@ SMESH::SMESH_Group_ptr SMESH_Mesh_i::CreateGroup( SMESH::ElementType theElemType * */ //============================================================================= -SMESH::SMESH_GroupOnGeom_ptr SMESH_Mesh_i::CreateGroupFromGEOM (SMESH::ElementType theElemType, - const char* theName, - GEOM::GEOM_Object_ptr theGeomObj) +SMESH::SMESH_GroupOnGeom_ptr +SMESH_Mesh_i::CreateGroupFromGEOM (SMESH::ElementType theElemType, + const char* theName, + GEOM::GEOM_Object_ptr theGeomObj) throw(SALOME::SALOME_Exception) { Unexpect aCatch(SALOME_SalomeException); + if ( _preMeshInfo ) + _preMeshInfo->FullLoadFromFile(); + SMESH::SMESH_GroupOnGeom_var aNewGroup; TopoDS_Shape aShape = _gen_i->GeomObjectToShape( theGeomObj ); - if ( !aShape.IsNull() ) { + if ( !aShape.IsNull() ) + { aNewGroup = SMESH::SMESH_GroupOnGeom::_narrow ( createGroup( theElemType, theName, aShape )); + if ( _gen_i->CanPublishInStudy( aNewGroup ) ) { SALOMEDS::SObject_var aSO = _gen_i->PublishGroup(_gen_i->GetCurrentStudy(), _this(), @@ -743,8 +877,7 @@ SMESH::SMESH_GroupOnGeom_ptr SMESH_Mesh_i::CreateGroupFromGEOM (SMESH::ElementTy if ( !aSO->_is_nil()) { // Update Python script TPythonDump() << aSO << " = " << _this() << ".CreateGroupFromGEOM(" - << ElementTypeString(theElemType) << ", '" << theName << "', " - << theGeomObj << " )"; + << theElemType << ", '" << theName << "', " << theGeomObj << " )"; } } } @@ -752,6 +885,55 @@ SMESH::SMESH_GroupOnGeom_ptr SMESH_Mesh_i::CreateGroupFromGEOM (SMESH::ElementTy return aNewGroup._retn(); } +//================================================================================ +/*! + * \brief Creates a group whose contents is defined by filter + * \param theElemType - group type + * \param theName - group name + * \param theFilter - the filter + * \retval SMESH::SMESH_GroupOnFilter_ptr - group defined by filter + */ +//================================================================================ + +SMESH::SMESH_GroupOnFilter_ptr +SMESH_Mesh_i::CreateGroupFromFilter(SMESH::ElementType theElemType, + const char* theName, + SMESH::Filter_ptr theFilter ) + throw (SALOME::SALOME_Exception) +{ + Unexpect aCatch(SALOME_SalomeException); + if ( _preMeshInfo ) + _preMeshInfo->FullLoadFromFile(); + + if ( CORBA::is_nil( theFilter )) + THROW_SALOME_CORBA_EXCEPTION("NULL filter", SALOME::BAD_PARAM); + + SMESH_PredicatePtr predicate = SMESH_GroupOnFilter_i::GetPredicate( theFilter ); + if ( !predicate ) + THROW_SALOME_CORBA_EXCEPTION("Invalid filter", SALOME::BAD_PARAM); + + SMESH::SMESH_GroupOnFilter_var aNewGroup = SMESH::SMESH_GroupOnFilter::_narrow + ( createGroup( theElemType, theName, TopoDS_Shape(), predicate )); + + TPythonDump pd; + if ( !aNewGroup->_is_nil() ) + aNewGroup->SetFilter( theFilter ); + + if ( _gen_i->CanPublishInStudy( aNewGroup ) ) + { + SALOMEDS::SObject_var aSO = + _gen_i->PublishGroup(_gen_i->GetCurrentStudy(), _this(), aNewGroup, + GEOM::GEOM_Object::_nil(), theName); + if ( !aSO->_is_nil()) { + // Update Python script + pd << aSO << " = " << _this() << ".CreateGroupFromFilter(" + << theElemType << ", '" << theName << "', " << theFilter << " )"; + } + } + + return aNewGroup._retn(); +} + //============================================================================= /*! * @@ -787,13 +969,17 @@ void SMESH_Mesh_i::RemoveGroup( SMESH::SMESH_GroupBase_ptr theGroup ) } //============================================================================= -/*! RemoveGroupWithContents +/*! * Remove group with its contents */ //============================================================================= + void SMESH_Mesh_i::RemoveGroupWithContents( SMESH::SMESH_GroupBase_ptr theGroup ) throw (SALOME::SALOME_Exception) { + if ( _preMeshInfo ) + _preMeshInfo->FullLoadFromFile(); + if ( theGroup->_is_nil() ) return; @@ -805,8 +991,7 @@ void SMESH_Mesh_i::RemoveGroupWithContents( SMESH::SMESH_GroupBase_ptr theGroup SMESH::long_array_var anIds = aGroup->GetListOfID(); SMESH::SMESH_MeshEditor_var aMeshEditor = SMESH_Mesh_i::GetMeshEditor(); - // Update Python script - TPythonDump() << _this() << ".RemoveGroupWithContents( " << theGroup << " )"; + TPythonDump pyDump; // Supress dump from RemoveNodes/Elements() and RemoveGroup() // Remove contents if ( aGroup->GetType() == SMESH::NODE ) @@ -817,12 +1002,10 @@ void SMESH_Mesh_i::RemoveGroupWithContents( SMESH::SMESH_GroupBase_ptr theGroup // Remove group RemoveGroup( theGroup ); - // Clear python lines, created by RemoveNodes/Elements() and RemoveGroup() - _gen_i->RemoveLastFromPythonScript(_gen_i->GetCurrentStudy()->StudyId()); - _gen_i->RemoveLastFromPythonScript(_gen_i->GetCurrentStudy()->StudyId()); + // Update Python script + pyDump << _this() << ".RemoveGroupWithContents( " << theGroup << " )"; } - //================================================================================ /*! * \brief Get the list of groups existing in the mesh @@ -865,6 +1048,7 @@ SMESH::ListOfGroups * SMESH_Mesh_i::GetGroups() throw(SALOME::SALOME_Exception) return aList._retn(); } + //============================================================================= /*! * Get number of groups existing in the mesh @@ -888,6 +1072,9 @@ SMESH::SMESH_Group_ptr SMESH_Mesh_i::UnionGroups( SMESH::SMESH_GroupBase_ptr the const char* theName ) throw (SALOME::SALOME_Exception) { + if ( _preMeshInfo ) + _preMeshInfo->FullLoadFromFile(); + try { if ( theGroup1->_is_nil() || theGroup2->_is_nil() || @@ -951,12 +1138,15 @@ SMESH::SMESH_Group_ptr SMESH_Mesh_i::UnionListOfGroups(const SMESH::ListOfGroups const char* theName ) throw (SALOME::SALOME_Exception) { + if ( _preMeshInfo ) + _preMeshInfo->FullLoadFromFile(); + if ( !theName ) return SMESH::SMESH_Group::_nil(); try { - NCollection_Map< int > anIds; + vector< int > anIds; SMESH::ElementType aType = SMESH::ALL; for ( int g = 0, n = theGroups.length(); g < n; g++ ) { @@ -979,7 +1169,7 @@ throw (SALOME::SALOME_Exception) for ( int i = 0, n = aCurrIds->length(); i < n; i++ ) { int aCurrId = aCurrIds[ i ]; - anIds.Add( aCurrId ); + anIds.push_back( aCurrId ); } } @@ -990,12 +1180,12 @@ throw (SALOME::SALOME_Exception) // Create array of identifiers SMESH::long_array_var aResIds = new SMESH::long_array; - aResIds->length( anIds.Extent() ); + aResIds->length( anIds.size() ); - NCollection_Map< int >::Iterator anIter( anIds ); - for ( int i = 0; anIter.More(); anIter.Next(), i++ ) + //NCollection_Map< int >::Iterator anIter( anIds ); + for ( int i = 0; iAdd( aResIds ); @@ -1028,6 +1218,9 @@ SMESH::SMESH_Group_ptr SMESH_Mesh_i::IntersectGroups( SMESH::SMESH_GroupBase_ptr const char* theName ) throw (SALOME::SALOME_Exception) { + if ( _preMeshInfo ) + _preMeshInfo->FullLoadFromFile(); + if ( theGroup1->_is_nil() || theGroup2->_is_nil() || theGroup1->GetType() != theGroup2->GetType() ) return SMESH::SMESH_Group::_nil(); @@ -1080,10 +1273,14 @@ SMESH::SMESH_Group_ptr SMESH_Mesh_i::IntersectGroups( SMESH::SMESH_GroupBase_ptr \return pointer on the group */ //============================================================================= -SMESH::SMESH_Group_ptr SMESH_Mesh_i::IntersectListOfGroups( - const SMESH::ListOfGroups& theGroups, const char* theName ) -throw (SALOME::SALOME_Exception) +SMESH::SMESH_Group_ptr +SMESH_Mesh_i::IntersectListOfGroups(const SMESH::ListOfGroups& theGroups, + const char* theName ) + throw (SALOME::SALOME_Exception) { + if ( _preMeshInfo ) + _preMeshInfo->FullLoadFromFile(); + if ( !theName ) return SMESH::SMESH_Group::_nil(); @@ -1121,14 +1318,14 @@ throw (SALOME::SALOME_Exception) // create map of ids int nbGrp = theGroups.length(); - NCollection_Map< int > anIds; + vector< int > anIds; NCollection_DataMap< int, int >::Iterator anIter( anIdToCount ); for ( ; anIter.More(); anIter.Next() ) { int aCurrId = anIter.Key(); int aCurrNb = anIter.Value(); if ( aCurrNb == nbGrp ) - anIds.Add( aCurrId ); + anIds.push_back( aCurrId ); } // Create group @@ -1138,12 +1335,12 @@ throw (SALOME::SALOME_Exception) // Create array of identifiers SMESH::long_array_var aResIds = new SMESH::long_array; - aResIds->length( anIds.Extent() ); + aResIds->length( anIds.size() ); - NCollection_Map< int >::Iterator aListIter( anIds ); - for ( int i = 0; aListIter.More(); aListIter.Next(), i++ ) + //NCollection_Map< int >::Iterator aListIter( anIds ); + for ( int i = 0; iAdd( aResIds ); @@ -1173,9 +1370,12 @@ throw (SALOME::SALOME_Exception) //============================================================================= SMESH::SMESH_Group_ptr SMESH_Mesh_i::CutGroups( SMESH::SMESH_GroupBase_ptr theGroup1, SMESH::SMESH_GroupBase_ptr theGroup2, - const char* theName ) + const char* theName ) throw (SALOME::SALOME_Exception) { + if ( _preMeshInfo ) + _preMeshInfo->FullLoadFromFile(); + if ( theGroup1->_is_nil() || theGroup2->_is_nil() || theGroup1->GetType() != theGroup2->GetType() ) return SMESH::SMESH_Group::_nil(); @@ -1229,18 +1429,21 @@ SMESH::SMESH_Group_ptr SMESH_Mesh_i::CutGroups( SMESH::SMESH_GroupBase_ptr theGr \return pointer on the group */ //============================================================================= -SMESH::SMESH_Group_ptr SMESH_Mesh_i::CutListOfGroups( - const SMESH::ListOfGroups& theMainGroups, - const SMESH::ListOfGroups& theToolGroups, - const char* theName ) +SMESH::SMESH_Group_ptr +SMESH_Mesh_i::CutListOfGroups(const SMESH::ListOfGroups& theMainGroups, + const SMESH::ListOfGroups& theToolGroups, + const char* theName ) throw (SALOME::SALOME_Exception) { + if ( _preMeshInfo ) + _preMeshInfo->FullLoadFromFile(); + if ( !theName ) return SMESH::SMESH_Group::_nil(); try { - NCollection_Map< int > aToolIds; + set< int > aToolIds; SMESH::ElementType aType = SMESH::ALL; int g, n; // iterate through tool groups @@ -1265,11 +1468,11 @@ SMESH::SMESH_Group_ptr SMESH_Mesh_i::CutListOfGroups( for ( int i = 0, n = aCurrIds->length(); i < n; i++ ) { int aCurrId = aCurrIds[ i ]; - aToolIds.Add( aCurrId ); + aToolIds.insert( aCurrId ); } } - NCollection_Map< int > anIds; // result + vector< int > anIds; // result // Iterate through main group for ( g = 0, n = theMainGroups.length(); g < n; g++ ) @@ -1293,8 +1496,8 @@ SMESH::SMESH_Group_ptr SMESH_Mesh_i::CutListOfGroups( for ( int i = 0, n = aCurrIds->length(); i < n; i++ ) { int aCurrId = aCurrIds[ i ]; - if ( !aToolIds.Contains( aCurrId ) ) - anIds.Add( aCurrId ); + if ( !aToolIds.count( aCurrId ) ) + anIds.push_back( aCurrId ); } } @@ -1305,12 +1508,11 @@ SMESH::SMESH_Group_ptr SMESH_Mesh_i::CutListOfGroups( // Create array of identifiers SMESH::long_array_var aResIds = new SMESH::long_array; - aResIds->length( anIds.Extent() ); + aResIds->length( anIds.size() ); - NCollection_Map< int >::Iterator anIter( anIds ); - for ( int i = 0; anIter.More(); anIter.Next(), i++ ) + for (int i=0; iAdd( aResIds ); @@ -1345,12 +1547,15 @@ SMESH::SMESH_Group_ptr SMESH_Mesh_i::CutListOfGroups( \return pointer on new group */ //============================================================================= -SMESH::SMESH_Group_ptr SMESH_Mesh_i::CreateDimGroup( - const SMESH::ListOfGroups& theGroups, - SMESH::ElementType theElemType, - const char* theName ) +SMESH::SMESH_Group_ptr +SMESH_Mesh_i::CreateDimGroup(const SMESH::ListOfGroups& theGroups, + SMESH::ElementType theElemType, + const char* theName ) throw (SALOME::SALOME_Exception) { + if ( _preMeshInfo ) + _preMeshInfo->FullLoadFromFile(); + SMESHDS_Mesh* aMeshDS = _impl->GetMeshDS(); if ( !theName || !aMeshDS ) @@ -1362,7 +1567,7 @@ SMESH::SMESH_Group_ptr SMESH_Mesh_i::CreateDimGroup( { // Create map of nodes from all groups - NCollection_Map< int > aNodeMap; + set< int > aNodeMap; for ( int g = 0, n = theGroups.length(); g < n; g++ ) { @@ -1381,7 +1586,7 @@ SMESH::SMESH_Group_ptr SMESH_Mesh_i::CreateDimGroup( int aCurrId = aCurrIds[ i ]; const SMDS_MeshNode* aNode = aMeshDS->FindNode( aCurrId ); if ( aNode ) - aNodeMap.Add( aNode->GetID() ); + aNodeMap.insert( aNode->GetID() ); } } else @@ -1399,7 +1604,7 @@ SMESH::SMESH_Group_ptr SMESH_Mesh_i::CreateDimGroup( const SMDS_MeshNode* aNode = dynamic_cast( aNodeIter->next() ); if ( aNode ) - aNodeMap.Add( aNode->GetID() ); + aNodeMap.insert( aNode->GetID() ); } } } @@ -1407,22 +1612,25 @@ SMESH::SMESH_Group_ptr SMESH_Mesh_i::CreateDimGroup( // Get result identifiers - NCollection_Map< int > aResultIds; + vector< int > aResultIds; if ( theElemType == SMESH::NODE ) { - NCollection_Map< int >::Iterator aNodeIter( aNodeMap ); - for ( ; aNodeIter.More(); aNodeIter.Next() ) - aResultIds.Add( aNodeIter.Value() ); + //NCollection_Map< int >::Iterator aNodeIter( aNodeMap ); + set::iterator iter = aNodeMap.begin(); + for ( ; iter != aNodeMap.end(); iter++ ) + aResultIds.push_back( *iter); } else { // Create list of elements of given dimension constructed on the nodes - NCollection_Map< int > anElemList; - NCollection_Map< int >::Iterator aNodeIter( aNodeMap ); - for ( ; aNodeIter.More(); aNodeIter.Next() ) + vector< int > anElemList; + //NCollection_Map< int >::Iterator aNodeIter( aNodeMap ); + //for ( ; aNodeIter.More(); aNodeIter.Next() ) + set::iterator iter = aNodeMap.begin(); + for ( ; iter != aNodeMap.end(); iter++ ) { const SMDS_MeshElement* aNode = - dynamic_cast( aMeshDS->FindNode( aNodeIter.Value() ) ); + dynamic_cast( aMeshDS->FindNode( *iter ) ); if ( !aNode ) continue; @@ -1432,15 +1640,14 @@ SMESH::SMESH_Group_ptr SMESH_Mesh_i::CreateDimGroup( const SMDS_MeshElement* anElem = dynamic_cast( anElemIter->next() ); if ( anElem && anElem->GetType() == anElemType ) - anElemList.Add( anElem->GetID() ); + anElemList.push_back( anElem->GetID() ); } } // check whether all nodes of elements are present in nodes map - NCollection_Map< int >::Iterator anIter( anElemList ); - for ( ; anIter.More(); anIter.Next() ) + for (int i=0; i< anElemList.size(); i++) { - const SMDS_MeshElement* anElem = aMeshDS->FindElement( anIter.Value() ); + const SMDS_MeshElement* anElem = aMeshDS->FindElement( anElemList[i] ); if ( !anElem ) continue; @@ -1450,14 +1657,14 @@ SMESH::SMESH_Group_ptr SMESH_Mesh_i::CreateDimGroup( { const SMDS_MeshNode* aNode = dynamic_cast( aNodeIter->next() ); - if ( !aNode || !aNodeMap.Contains( aNode->GetID() ) ) + if ( !aNode || !aNodeMap.count( aNode->GetID() ) ) { isOk = false; break; } } if ( isOk ) - aResultIds.Add( anElem->GetID() ); + aResultIds.push_back( anElem->GetID() ); } } @@ -1469,11 +1676,10 @@ SMESH::SMESH_Group_ptr SMESH_Mesh_i::CreateDimGroup( // Create array of identifiers SMESH::long_array_var aResIds = new SMESH::long_array; - aResIds->length( aResultIds.Extent() ); + aResIds->length( aResultIds.size() ); - NCollection_Map< int >::Iterator aResIter( aResultIds ); - for ( int i = 0; aResIter.More(); aResIter.Next(), i++ ) - aResIds[ i ] = aResIter.Value(); + for (int i=0; i< aResultIds.size(); i++) + aResIds[ i ] = aResultIds[i]; aResGrp->Add( aResIds ); // Remove strings corresponding to group creation @@ -1496,61 +1702,128 @@ SMESH::SMESH_Group_ptr SMESH_Mesh_i::CreateDimGroup( //================================================================================ /*! - * \brief Return group items of a group present in a study + * \brief Remember GEOM group data */ //================================================================================ -static GEOM::GEOM_Object_ptr getGroupItemsFromStudy(CORBA::Object_ptr theMesh, - SMESH_Gen_i* theGen, - list & theItems) +void SMESH_Mesh_i::addGeomGroupData(GEOM::GEOM_Object_ptr theGeomObj, + CORBA::Object_ptr theSmeshObj) { - GEOM::GEOM_Object_var groupObj; - SALOMEDS::Study_var study = theGen->GetCurrentStudy(); - GEOM::GEOM_Gen_var geomGen = theGen->GetGeomEngine(); - if ( study->_is_nil() || geomGen->_is_nil() ) - return groupObj._retn(); - + if ( CORBA::is_nil( theGeomObj ) || theGeomObj->GetType() != GEOM_GROUP ) + return; + // group SO + SALOMEDS::Study_var study = _gen_i->GetCurrentStudy(); + SALOMEDS::SObject_var groupSO = _gen_i->ObjectToSObject( study, theGeomObj ); + if ( groupSO->_is_nil() ) + return; + // group indices + GEOM::GEOM_Gen_var geomGen = _gen_i->GetGeomEngine(); GEOM::GEOM_IGroupOperations_var groupOp = - geomGen->GetIGroupOperations( theGen->GetCurrentStudyID() ); - GEOM::GEOM_IShapesOperations_var shapeOp = - geomGen->GetIShapesOperations( theGen->GetCurrentStudyID() ); - - SALOMEDS::SObject_var meshOS = theGen->ObjectToSObject(study, theMesh); - if ( meshOS->_is_nil() || groupOp->_is_nil() || shapeOp->_is_nil() ) - return groupObj._retn(); - SALOMEDS::SObject_var fatherSO = meshOS->GetFather(); - if ( fatherSO->_is_nil() || fatherSO->Tag() != theGen->GetSubMeshOnCompoundTag() ) - return groupObj._retn(); // keep only submeshes on groups - - SALOMEDS::ChildIterator_var anIter = study->NewChildIterator(meshOS); - if ( anIter->_is_nil() ) return groupObj._retn(); - for ( ; anIter->More(); anIter->Next()) - { - SALOMEDS::SObject_var aSObject = anIter->Value(); - SALOMEDS::SObject_var aRefSO; - if ( !aSObject->_is_nil() && aSObject->ReferencedObject(aRefSO) ) - { - groupObj = GEOM::GEOM_Object::_narrow(aRefSO->GetObject()); - if ( groupObj->_is_nil() ) break; - GEOM::ListOfLong_var ids = groupOp->GetObjects( groupObj ); - GEOM::GEOM_Object_var mainShape = groupObj->GetMainShape(); - for ( int i = 0; i < ids->length(); ++i ) { - GEOM::GEOM_Object_var subShape = shapeOp->GetSubShape( mainShape, ids[i] ); - TopoDS_Shape S = theGen->GeomObjectToShape( subShape ); - if ( !S.IsNull() ) - theItems.push_back( S ); - } - break; + geomGen->GetIGroupOperations( _gen_i->GetCurrentStudyID() ); + GEOM::ListOfLong_var ids = groupOp->GetObjects( theGeomObj ); + + // store data + _geomGroupData.push_back( TGeomGroupData() ); + TGeomGroupData & groupData = _geomGroupData.back(); + // entry + CORBA::String_var entry = groupSO->GetID(); + groupData._groupEntry = entry.in(); + // indices + for ( int i = 0; i < ids->length(); ++i ) + groupData._indices.insert( ids[i] ); + // SMESH object + groupData._smeshObject = theSmeshObj; +} + +//================================================================================ +/*! + * Remove GEOM group data relating to removed smesh object + */ +//================================================================================ + +void SMESH_Mesh_i::removeGeomGroupData(CORBA::Object_ptr theSmeshObj) +{ + list::iterator + data = _geomGroupData.begin(), dataEnd = _geomGroupData.end(); + for ( ; data != dataEnd; ++data ) { + if ( theSmeshObj->_is_equivalent( data->_smeshObject )) { + _geomGroupData.erase( data ); + return; } } - return groupObj._retn(); } +//================================================================================ +/*! + * \brief Return new group contents if it has been changed and update group data + */ +//================================================================================ + +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_var groupSO = study->FindObjectID( groupData._groupEntry.c_str() ); + if ( !groupSO->_is_nil() ) + { + CORBA::Object_var groupObj = _gen_i->SObjectToObject( groupSO ); + if ( CORBA::is_nil( groupObj )) return newShape; + GEOM::GEOM_Object_var geomGroup = GEOM::GEOM_Object::_narrow( groupObj ); + + // get indices of group items + set curIndices; + GEOM::GEOM_Gen_var geomGen = _gen_i->GetGeomEngine(); + GEOM::GEOM_IGroupOperations_var groupOp = + geomGen->GetIGroupOperations( _gen_i->GetCurrentStudyID() ); + GEOM::ListOfLong_var ids = groupOp->GetObjects( geomGroup ); + for ( int i = 0; i < ids->length(); ++i ) + curIndices.insert( ids[i] ); + + if ( groupData._indices == curIndices ) + return newShape; // group not changed + + // update data + groupData._indices = curIndices; + + GEOM_Client* geomClient = _gen_i->GetShapeReader(); + if ( !geomClient ) return newShape; + TCollection_AsciiString groupIOR = geomGen->GetStringFromIOR( geomGroup ); + geomClient->RemoveShapeFromBuffer( groupIOR ); + newShape = _gen_i->GeomObjectToShape( geomGroup ); + } + + if ( newShape.IsNull() ) { + // geom group becomes empty - return empty compound + TopoDS_Compound compound; + BRep_Builder().MakeCompound(compound); + newShape = compound; + } + return newShape; +} + +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 Update hypotheses assigned to geom groups if the latter change + * \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 modifiy mesh computation + * issue 0020210: Update of a smesh group after modification of the associated geom group */ //============================================================================= @@ -1561,83 +1834,240 @@ void SMESH_Mesh_i::CheckGeomGroupModif() SALOMEDS::Study_var study = _gen_i->GetCurrentStudy(); if ( study->_is_nil() ) return; - // check if items of groups changed - map::iterator i_sm = _mapSubMesh.begin(); - for ( ; i_sm != _mapSubMesh.end(); ++i_sm ) - { - const TopoDS_Shape & oldGroupShape = i_sm->second->GetSubShape(); - SMESHDS_SubMesh * oldDS = i_sm->second->GetSubMeshDS(); - if ( !oldDS /*|| !oldDS->IsComplexSubmesh()*/ ) - continue; - int oldID = i_sm->first; - map::iterator i_smIor = _mapSubMeshIor.find( oldID ); - if ( i_smIor == _mapSubMeshIor.end() ) - continue; - list< TopoDS_Shape> newItems; - GEOM::GEOM_Object_var groupObj = getGroupItemsFromStudy ( i_smIor->second, _gen_i, newItems ); - if ( groupObj->_is_nil() ) - continue; + CORBA::Long nbEntities = NbNodes() + NbElements(); - int nbOldItems = oldDS->IsComplexSubmesh() ? oldDS->NbSubMeshes() : 1; - int nbNewItems = newItems.size(); - bool groupChanged = ( nbOldItems != nbNewItems); - if ( !groupChanged ) { - if ( !oldDS->IsComplexSubmesh() ) { // old group has one item - groupChanged = ( oldGroupShape != newItems.front() ); - } - else { - list::iterator item = newItems.begin(); - for ( ; item != newItems.end() && !groupChanged; ++item ) - { - SMESHDS_SubMesh * itemDS = _impl->GetMeshDS()->MeshElements( *item ); - groupChanged = ( !itemDS || !oldDS->ContainsSubMesh( itemDS )); - } - } + // Check if group contents changed + + typedef map< string, TopoDS_Shape > TEntry2Geom; + TEntry2Geom newGroupContents; + + list::iterator + data = _geomGroupData.begin(), dataEnd = _geomGroupData.end(); + for ( ; data != dataEnd; ++data ) + { + pair< TEntry2Geom::iterator, bool > it_new = + newGroupContents.insert( make_pair( data->_groupEntry, TopoDS_Shape() )); + bool processedGroup = !it_new.second; + TopoDS_Shape& newShape = it_new.first->second; + if ( !processedGroup ) + newShape = newGroupShape( *data ); + if ( newShape.IsNull() ) + continue; // no changes + + if ( _preMeshInfo ) + _preMeshInfo->ForgetOrLoad(); + + if ( processedGroup ) { // update group indices + list::iterator data2 = data; + for ( --data2; data2->_groupEntry != data->_groupEntry; --data2) {} + data->_indices = data2->_indices; } - // update hypotheses and submeshes if necessary - if ( groupChanged ) + + // Update SMESH objects according to new GEOM group contents + + SMESH::SMESH_subMesh_var submesh = SMESH::SMESH_subMesh::_narrow( data->_smeshObject ); + if ( !submesh->_is_nil() ) // -------------- Sub mesh --------------------- { - // get a new group shape - GEOM_Client* geomClient = _gen_i->GetShapeReader(); - if ( !geomClient ) continue; - TCollection_AsciiString groupIOR = _gen_i->GetGeomEngine()->GetStringFromIOR( groupObj ); - geomClient->RemoveShapeFromBuffer( groupIOR ); - TopoDS_Shape newGroupShape = _gen_i->GeomObjectToShape( groupObj ); + int oldID = submesh->GetId(); + if ( _mapSubMeshIor.find( oldID ) == _mapSubMeshIor.end() ) + continue; + TopoDS_Shape oldShape = _mapSubMesh[oldID]->GetSubShape(); + // update hypotheses - list hyps = _impl->GetHypothesisList(oldGroupShape); + list hyps = _impl->GetHypothesisList(oldShape); list ::iterator hypIt; for ( hypIt = hyps.begin(); hypIt != hyps.end(); ++hypIt ) { - _impl->RemoveHypothesis( oldGroupShape, (*hypIt)->GetID()); - _impl->AddHypothesis ( newGroupShape, (*hypIt)->GetID()); + _impl->RemoveHypothesis( oldShape, (*hypIt)->GetID()); + _impl->AddHypothesis ( newShape, (*hypIt)->GetID()); } // care of submeshes - SMESH_subMesh* newSubmesh = _impl->GetSubMesh( newGroupShape ); + SMESH_subMesh* newSubmesh = _impl->GetSubMesh( newShape ); int newID = newSubmesh->GetId(); if ( newID != oldID ) { _mapSubMesh [ newID ] = newSubmesh; _mapSubMesh_i [ newID ] = _mapSubMesh_i [ oldID ]; _mapSubMeshIor[ newID ] = _mapSubMeshIor[ oldID ]; - _mapSubMesh.erase (oldID); - _mapSubMesh_i.erase (oldID); + _mapSubMesh. erase(oldID); + _mapSubMesh_i. erase(oldID); _mapSubMeshIor.erase(oldID); _mapSubMesh_i [ newID ]->changeLocalId( newID ); } + continue; } - } -} -//============================================================================= -/*! - * \brief Create standalone group instead if group on geometry - * - */ -//============================================================================= + SMESH::SMESH_GroupOnGeom_var smeshGroup = + SMESH::SMESH_GroupOnGeom::_narrow( data->_smeshObject ); + if ( !smeshGroup->_is_nil() ) // ------------ GROUP ----------------------- + { + SMESH_GroupOnGeom_i* group_i = SMESH::DownCast( smeshGroup ); + if ( group_i ) { + ::SMESH_Group* group = _impl->GetGroup( group_i->GetLocalID() ); + SMESHDS_GroupOnGeom* ds = static_cast( group->GetGroupDS() ); + ds->SetShape( newShape ); + } + continue; + } -SMESH::SMESH_Group_ptr SMESH_Mesh_i::ConvertToStandalone( SMESH::SMESH_GroupOnGeom_ptr theGroup ) -{ - SMESH::SMESH_Group_var aGroup; - if ( theGroup->_is_nil() ) + SMESH::SMESH_Mesh_var mesh = SMESH::SMESH_Mesh::_narrow( data->_smeshObject ); + if ( !mesh->_is_nil() ) // -------------- MESH ---------------------------- + { + // Remove groups and submeshes basing on removed sub-shapes + + TopTools_MapOfShape newShapeMap; + TopoDS_Iterator shapeIt( newShape ); + for ( ; shapeIt.More(); shapeIt.Next() ) + newShapeMap.Add( shapeIt.Value() ); + + SMESHDS_Mesh* meshDS = _impl->GetMeshDS(); + for ( shapeIt.Initialize( meshDS->ShapeToMesh() ); shapeIt.More(); shapeIt.Next() ) + { + if ( newShapeMap.Contains( shapeIt.Value() )) + continue; + TopTools_IndexedMapOfShape oldShapeMap; + TopExp::MapShapes( shapeIt.Value(), oldShapeMap ); + for ( int i = 1; i <= oldShapeMap.Extent(); ++i ) + { + const TopoDS_Shape& oldShape = oldShapeMap(i); + int oldInd = meshDS->ShapeToIndex( oldShape ); + // -- submeshes -- + map::iterator i_smIor = _mapSubMeshIor.find( oldInd ); + if ( i_smIor != _mapSubMeshIor.end() ) { + RemoveSubMesh( i_smIor->second ); // one submesh per shape index + } + // --- groups --- + map::iterator i_grp = _mapGroups.begin(); + for ( ; i_grp != _mapGroups.end(); ++i_grp ) + { + // check if a group bases on oldInd shape + SMESHDS_GroupOnGeom* grpOnGeom = 0; + if ( ::SMESH_Group* g = _impl->GetGroup( i_grp->first )) + grpOnGeom = dynamic_cast( g->GetGroupDS() ); + if ( grpOnGeom && oldShape.IsSame( grpOnGeom->GetShape() )) + { // remove + RemoveGroup( i_grp->second ); // several groups can base on same shape + i_grp = _mapGroups.begin(); // _mapGroups changed - restart iteration + } + } + } + } + // Reassign hypotheses and update groups after setting the new shape to mesh + + // collect anassigned hypotheses + typedef list< pair< TIndexedShape, list > > TShapeHypList; + list ::const_iterator hypIt; + TShapeHypList assignedHyps; + for ( int i = 1; i <= meshDS->MaxShapeIndex(); ++i ) + { + const TopoDS_Shape& oldShape = meshDS->IndexToShape(i); + list hyps = meshDS->GetHypothesis( oldShape );// copy + if ( !hyps.empty() ) { + assignedHyps.push_back( make_pair( TIndexedShape(i,oldShape), hyps )); + for ( hypIt = hyps.begin(); hypIt != hyps.end(); ++hypIt ) + _impl->RemoveHypothesis( oldShape, (*hypIt)->GetID()); + } + } + // collect shapes supporting groups + typedef list < pair< TIndexedShape, SMDSAbs_ElementType > > TShapeTypeList; + TShapeTypeList groupData; + const set& groups = meshDS->GetGroups(); + set::const_iterator grIt = groups.begin(); + for ( ; grIt != groups.end(); ++grIt ) + { + if ( SMESHDS_GroupOnGeom* gog = dynamic_cast( *grIt )) + 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 + _impl->ShapeToMesh( newShape ); + + // reassign hypotheses + TShapeHypList::iterator indS_hyps = assignedHyps.begin(); + for ( ; indS_hyps != assignedHyps.end(); ++indS_hyps ) + { + TIndexedShape& geom = indS_hyps->first; + list& hyps = indS_hyps->second; + int oldID = geom._index; + int newID = meshDS->ShapeToIndex( geom._shape ); + if ( !newID ) + continue; + if ( oldID == 1 ) { // main shape + newID = 1; + geom._shape = newShape; + } + for ( hypIt = hyps.begin(); hypIt != hyps.end(); ++hypIt ) + _impl->AddHypothesis( geom._shape, (*hypIt)->GetID()); + // care of submeshes + SMESH_subMesh* newSubmesh = _impl->GetSubMesh( geom._shape ); + if ( newID != oldID ) { + _mapSubMesh [ newID ] = newSubmesh; + _mapSubMesh_i [ newID ] = _mapSubMesh_i [ oldID ]; + _mapSubMeshIor[ newID ] = _mapSubMeshIor[ oldID ]; + _mapSubMesh. erase(oldID); + _mapSubMesh_i. erase(oldID); + _mapSubMeshIor.erase(oldID); + _mapSubMesh_i [ newID ]->changeLocalId( newID ); + } + } + // recreate groups + TShapeTypeList::iterator geomType = groupData.begin(); + for ( ; geomType != groupData.end(); ++geomType ) + { + const TIndexedShape& geom = geomType->first; + int oldID = geom._index; + if ( _mapGroups.find( oldID ) == _mapGroups.end() ) + continue; + // get group name + SALOMEDS::SObject_var groupSO = _gen_i->ObjectToSObject( study,_mapGroups[oldID] ); + CORBA::String_var name = groupSO->GetName(); + // update + SMESH_GroupBase_i* group_i = SMESH::DownCast(_mapGroups[oldID] ); + int newID; + if ( group_i && _impl->AddGroup( geomType->second, name.in(), newID, geom._shape )) + group_i->changeLocalId( newID ); + } + + break; // everything has been updated + + } // update mesh + } // loop on group data + + // Update icons + + CORBA::Long newNbEntities = NbNodes() + NbElements(); + list< SALOMEDS::SObject_var > soToUpdateIcons; + if ( newNbEntities != nbEntities ) + { + // Add all SObjects with icons to soToUpdateIcons + soToUpdateIcons.push_back( _gen_i->ObjectToSObject( study, _this() )); // mesh + + for (map::iterator i_sm = _mapSubMeshIor.begin(); + i_sm != _mapSubMeshIor.end(); ++i_sm ) // submeshes + soToUpdateIcons.push_back( _gen_i->ObjectToSObject( study, i_sm->second )); + + for ( map::iterator i_gr = _mapGroups.begin(); + i_gr != _mapGroups.end(); ++i_gr ) // groups + soToUpdateIcons.push_back( _gen_i->ObjectToSObject( study, i_gr->second )); + } + + list< SALOMEDS::SObject_var >::iterator so = soToUpdateIcons.begin(); + for ( ; so != soToUpdateIcons.end(); ++so ) + _gen_i->SetPixMap( *so, "ICON_SMESH_TREE_MESH_WARN" ); +} + +//============================================================================= +/*! + * \brief Create standalone group from a group on geometry or filter + */ +//============================================================================= + +SMESH::SMESH_Group_ptr SMESH_Mesh_i::ConvertToStandalone( SMESH::SMESH_GroupBase_ptr theGroup ) +{ + if ( _preMeshInfo ) + _preMeshInfo->FullLoadFromFile(); + + SMESH::SMESH_Group_var aGroup; + if ( theGroup->_is_nil() ) return aGroup._retn(); Unexpect aCatch(SALOME_SalomeException); @@ -1647,13 +2077,14 @@ SMESH::SMESH_Group_ptr SMESH_Mesh_i::ConvertToStandalone( SMESH::SMESH_GroupOnGe if ( !aGroupToRem ) return aGroup._retn(); + const bool isOnFilter = ( SMESH::DownCast< SMESH_GroupOnFilter_i* > ( theGroup )); + int anId = aGroupToRem->GetLocalID(); if ( !_impl->ConvertToStandalone( anId ) ) return aGroup._retn(); + removeGeomGroupData( theGroup ); - SMESH_GroupBase_i* aGroupImpl; - aGroupImpl = new SMESH_Group_i( SMESH_Gen_i::GetPOA(), this, anId ); - + SMESH_GroupBase_i* aGroupImpl = new SMESH_Group_i( SMESH_Gen_i::GetPOA(), this, anId ); // remove old instance of group from own map _mapGroups.erase( anId ); @@ -1666,15 +2097,29 @@ SMESH::SMESH_Group_ptr SMESH_Mesh_i::ConvertToStandalone( SMESH::SMESH_GroupOnGe aGroupSO = _gen_i->ObjectToSObject( aStudy, theGroup ); if ( !aGroupSO->_is_nil() ) { - // remove reference to geometry - SALOMEDS::ChildIterator_var chItr = aStudy->NewChildIterator(aGroupSO); - for ( ; chItr->More(); chItr->Next() ) - // Remove group's child SObject - builder->RemoveObject( chItr->Value() ); + // remove reference to geometry + SALOMEDS::ChildIterator_var chItr = aStudy->NewChildIterator(aGroupSO); + for ( ; chItr->More(); chItr->Next() ) + // Remove group's child SObject + builder->RemoveObject( chItr->Value() ); // Update Python script TPythonDump() << aGroupSO << " = " << _this() << ".ConvertToStandalone( " << aGroupSO << " )"; + + // change icon of Group on Filter + if ( isOnFilter ) + { + SMESH::array_of_ElementType_var elemTypes = aGroupImpl->GetTypes(); + const int isEmpty = ( elemTypes->length() == 0 ); + if ( !isEmpty ) + { + SALOMEDS::GenericAttribute_var anAttr = + builder->FindOrCreateAttribute( aGroupSO, "AttributePixMap" ); + SALOMEDS::AttributePixMap_var pm = SALOMEDS::AttributePixMap::_narrow( anAttr ); + pm->SetPixMap( "ICON_SMESH_TREE_GROUP" ); + } + } } } @@ -1688,8 +2133,8 @@ SMESH::SMESH_Group_ptr SMESH_Mesh_i::ConvertToStandalone( SMESH::SMESH_GroupOnGe _mapGroups[anId] = SMESH::SMESH_GroupBase::_duplicate( aGroup ); // register CORBA object for persistence - //int nextId = _gen_i->RegisterObject( aGroup ); - //if(MYDEBUG) MESSAGE( "Add group to map with id = "<< nextId); + /*int nextId =*/ _gen_i->RegisterObject( aGroup ); + builder->SetIOR( aGroupSO, _gen_i->GetORB()->object_to_string( aGroup ) ); return aGroup._retn(); @@ -1720,6 +2165,9 @@ SMESH::SMESH_subMesh_ptr SMESH_Mesh_i::createSubMesh( GEOM::GEOM_Object_ptr theS int nextId = _gen_i->RegisterObject( subMesh ); if(MYDEBUG) MESSAGE( "Add submesh to map with id = "<< nextId); + // to track changes of GEOM groups + addGeomGroupData( theSubShapeObject, subMesh ); + return subMesh._retn(); } @@ -1744,29 +2192,50 @@ SMESH::SMESH_subMesh_ptr SMESH_Mesh_i::getSubMesh(int shapeID) */ //============================================================================= -void SMESH_Mesh_i::removeSubMesh (SMESH::SMESH_subMesh_ptr theSubMesh, +bool SMESH_Mesh_i::removeSubMesh (SMESH::SMESH_subMesh_ptr theSubMesh, GEOM::GEOM_Object_ptr theSubShapeObject ) { - MESSAGE("SMESH_Mesh_i::removeSubMesh()"); - if ( theSubMesh->_is_nil() || theSubShapeObject->_is_nil() ) - return; + bool isHypChanged = false; + if ( theSubMesh->_is_nil() /*|| theSubShapeObject->_is_nil()*/ ) + return isHypChanged; - try { - SMESH::ListOfHypothesis_var aHypList = GetHypothesisList( theSubShapeObject ); - for ( int i = 0, n = aHypList->length(); i < n; i++ ) { - removeHypothesis( theSubShapeObject, aHypList[i] ); + if ( theSubShapeObject->_is_nil() ) // not published shape (IPAL13617) + { + CORBA::Long shapeId = theSubMesh->GetId(); + if ( _mapSubMesh.find( shapeId ) != _mapSubMesh.end()) + { + TopoDS_Shape S = _mapSubMesh[ shapeId ]->GetSubShape(); + if ( !S.IsNull() ) + { + list hyps = _impl->GetHypothesisList( S ); + isHypChanged = !hyps.empty(); + list::const_iterator hyp = hyps.begin(); + for ( ; hyp != hyps.end(); ++hyp ) + _impl->RemoveHypothesis(S, (*hyp)->GetID()); + } } } - catch( const SALOME::SALOME_Exception& ) { - INFOS("SMESH_Mesh_i::removeSubMesh(): exception caught!"); + else + { + try { + SMESH::ListOfHypothesis_var aHypList = GetHypothesisList( theSubShapeObject ); + isHypChanged = ( aHypList->length() > 0 ); + for ( int i = 0, n = aHypList->length(); i < n; i++ ) { + removeHypothesis( theSubShapeObject, aHypList[i] ); + } + } + catch( const SALOME::SALOME_Exception& ) { + INFOS("SMESH_Mesh_i::removeSubMesh(): exception caught!"); + } + removeGeomGroupData( theSubShapeObject ); } - int subMeshId = theSubMesh->GetId(); _mapSubMesh.erase(subMeshId); _mapSubMesh_i.erase(subMeshId); _mapSubMeshIor.erase(subMeshId); - if(MYDEBUG) MESSAGE("SMESH_Mesh_i::removeSubMesh() completed"); + + return isHypChanged; } //============================================================================= @@ -1775,16 +2244,32 @@ void SMESH_Mesh_i::removeSubMesh (SMESH::SMESH_subMesh_ptr theSubMesh, */ //============================================================================= -SMESH::SMESH_GroupBase_ptr SMESH_Mesh_i::createGroup (SMESH::ElementType theElemType, - const char* theName, - const TopoDS_Shape& theShape ) +SMESH::SMESH_GroupBase_ptr SMESH_Mesh_i::createGroup (SMESH::ElementType theElemType, + const char* theName, + const TopoDS_Shape& theShape, + const SMESH_PredicatePtr& thePredicate ) { + std::string newName; + if ( !theName || strlen( theName ) == 0 ) + { + std::set< std::string > presentNames; + std::map::const_iterator i_gr = _mapGroups.begin(); + for ( ; i_gr != _mapGroups.end(); ++i_gr ) + presentNames.insert( i_gr->second->GetName() ); + do { + newName = "noname_Group_" + SMESH_Comment( presentNames.size() + 1 ); + } while ( !presentNames.insert( newName ).second ); + theName = newName.c_str(); + } int anId; SMESH::SMESH_GroupBase_var aGroup; - if ( _impl->AddGroup( (SMDSAbs_ElementType)theElemType, theName, anId, theShape )) { + if ( _impl->AddGroup( (SMDSAbs_ElementType)theElemType, theName, anId, theShape, thePredicate )) + { SMESH_GroupBase_i* aGroupImpl; if ( !theShape.IsNull() ) aGroupImpl = new SMESH_GroupOnGeom_i( SMESH_Gen_i::GetPOA(), this, anId ); + else if ( thePredicate ) + aGroupImpl = new SMESH_GroupOnFilter_i( SMESH_Gen_i::GetPOA(), this, anId ); else aGroupImpl = new SMESH_Group_i( SMESH_Gen_i::GetPOA(), this, anId ); @@ -1799,6 +2284,12 @@ SMESH::SMESH_GroupBase_ptr SMESH_Mesh_i::createGroup (SMESH::ElementType theElem // register CORBA object for persistence int nextId = _gen_i->RegisterObject( aGroup ); if(MYDEBUG) MESSAGE( "Add group to map with id = "<< nextId); + + // to track changes of GEOM groups + if ( !theShape.IsNull() ) { + GEOM::GEOM_Object_var geom = _gen_i->ShapeToGeomObject( theShape ); + addGeomGroupData( geom, aGroup ); + } } return aGroup._retn(); } @@ -1815,12 +2306,17 @@ void SMESH_Mesh_i::removeGroup( const int theId ) { if(MYDEBUG) MESSAGE("SMESH_Mesh_i::removeGroup()" ); if ( _mapGroups.find( theId ) != _mapGroups.end() ) { + SMESH::SMESH_GroupBase_ptr group = _mapGroups[theId]; _mapGroups.erase( theId ); - _impl->RemoveGroup( theId ); + removeGeomGroupData( group ); + if (! _impl->RemoveGroup( theId )) + { + // it seems to be a call up from _impl caused by hyp modification (issue 0020918) + RemoveGroup( group ); + } } } - //============================================================================= /*! * @@ -1830,7 +2326,8 @@ void SMESH_Mesh_i::removeGroup( const int theId ) SMESH::log_array * SMESH_Mesh_i::GetLog(CORBA::Boolean clearAfterGet) throw(SALOME::SALOME_Exception) { - if(MYDEBUG) MESSAGE("SMESH_Mesh_i::GetLog"); + if ( _preMeshInfo ) + _preMeshInfo->FullLoadFromFile(); SMESH::log_array_var aLog; try{ @@ -1860,14 +2357,14 @@ throw(SALOME::SALOME_Exception) aLog[indexLog].coords.length(rnum); aLog[indexLog].indexes.length(inum); for(int i = 0; i < rnum; i++){ - aLog[indexLog].coords[i] = *ir; - //MESSAGE(" "<ClearLog(); } //============================================================================= @@ -1917,6 +2414,34 @@ CORBA::Long SMESH_Mesh_i::GetStudyId()throw(SALOME::SALOME_Exception) return _studyId; } +//============================================================================= +namespace +{ + //!< implementation of struct used to call methods of SMESH_Mesh_i from SMESH_Mesh + // issue 0020918: groups removal is caused by hyp modification + // issue 0021208: to forget not loaded mesh data at hyp modification + struct TCallUp_i : public SMESH_Mesh::TCallUp + { + SMESH_Mesh_i* _mesh; + TCallUp_i(SMESH_Mesh_i* mesh):_mesh(mesh) {} + virtual void RemoveGroup (const int theGroupID) { _mesh->removeGroup( theGroupID ); } + virtual void HypothesisModified () { _mesh->onHypothesisModified(); } + virtual void Load () { _mesh->Load(); } + }; +} + +//================================================================================ +/*! + * \brief callback from _impl to forget not loaded mesh data (issue 0021208) + */ +//================================================================================ + +void SMESH_Mesh_i::onHypothesisModified() +{ + if ( _preMeshInfo ) + _preMeshInfo->ForgetOrLoad(); +} + //============================================================================= /*! * @@ -1927,6 +2452,8 @@ void SMESH_Mesh_i::SetImpl(::SMESH_Mesh * impl) { if(MYDEBUG) MESSAGE("SMESH_Mesh_i::SetImpl"); _impl = impl; + if ( _impl ) + _impl->SetCallUp( new TCallUp_i(this)); } //============================================================================= @@ -1949,6 +2476,9 @@ void SMESH_Mesh_i::SetImpl(::SMESH_Mesh * impl) SMESH::SMESH_MeshEditor_ptr SMESH_Mesh_i::GetMeshEditor() { + if ( _preMeshInfo ) + _preMeshInfo->FullLoadFromFile(); + // Create MeshEditor SMESH_MeshEditor_i *aMeshEditor = new SMESH_MeshEditor_i( this, false ); SMESH::SMESH_MeshEditor_var aMesh = aMeshEditor->_this(); @@ -1967,37 +2497,102 @@ SMESH::SMESH_MeshEditor_ptr SMESH_Mesh_i::GetMeshEditor() SMESH::SMESH_MeshEditor_ptr SMESH_Mesh_i::GetMeshEditPreviewer() { + if ( _preMeshInfo ) + _preMeshInfo->FullLoadFromFile(); + SMESH_MeshEditor_i *aMeshEditor = new SMESH_MeshEditor_i( this, true ); SMESH::SMESH_MeshEditor_var aMesh = aMeshEditor->_this(); return aMesh._retn(); } +//================================================================================ +/*! + * \brief Return true if the mesh has been edited since a last total re-compute + * and those modifications may prevent successful partial re-compute + */ +//================================================================================ + +CORBA::Boolean SMESH_Mesh_i::HasModificationsToDiscard() throw(SALOME::SALOME_Exception) +{ + Unexpect aCatch(SALOME_SalomeException); + return _impl->HasModificationsToDiscard(); +} + +//================================================================================ +/*! + * \brief Returns a random unique color + */ +//================================================================================ + +static SALOMEDS::Color getUniqueColor( const std::list& theReservedColors ) +{ + const int MAX_ATTEMPTS = 100; + int cnt = 0; + double tolerance = 0.5; + SALOMEDS::Color col; + + bool ok = false; + while ( !ok ) { + // generate random color + double red = (double)rand() / RAND_MAX; + double green = (double)rand() / RAND_MAX; + double blue = (double)rand() / RAND_MAX; + // check existence in the list of the existing colors + bool matched = false; + std::list::const_iterator it; + for ( it = theReservedColors.begin(); it != theReservedColors.end() && !matched; ++it ) { + SALOMEDS::Color color = *it; + double tol = fabs( color.R - red ) + fabs( color.G - green ) + fabs( color.B - blue ); + matched = tol < tolerance; + } + if ( (cnt+1) % 20 == 0 ) tolerance = tolerance/2; + ok = ( ++cnt == MAX_ATTEMPTS ) || !matched; + col.R = red; + col.G = green; + col.B = blue; + } + return col; +} + //============================================================================= /*! - * + * Sets auto-color mode. If it is on, groups get unique random colors */ //============================================================================= + void SMESH_Mesh_i::SetAutoColor(CORBA::Boolean theAutoColor) throw(SALOME::SALOME_Exception) { Unexpect aCatch(SALOME_SalomeException); _impl->SetAutoColor(theAutoColor); + + TPythonDump pyDump; // not to dump group->SetColor() from below code + pyDump<<_this()<<".SetAutoColor( "< aReservedColors; + map::iterator it = _mapGroups.begin(); + for ( ; it != _mapGroups.end(); it++ ) { + if ( CORBA::is_nil( it->second )) continue; + SALOMEDS::Color aColor = getUniqueColor( aReservedColors ); + it->second->SetColor( aColor ); + aReservedColors.push_back( aColor ); + } } //============================================================================= /*! - * + * Returns true if auto-color mode is on */ //============================================================================= + CORBA::Boolean SMESH_Mesh_i::GetAutoColor() throw(SALOME::SALOME_Exception) { Unexpect aCatch(SALOME_SalomeException); return _impl->GetAutoColor(); } - //============================================================================= /*! - * Export in different formats + * Checks if there are groups with equal names */ //============================================================================= @@ -2006,7 +2601,13 @@ CORBA::Boolean SMESH_Mesh_i::HasDuplicatedGroupNamesMED() return _impl->HasDuplicatedGroupNamesMED(); } -void SMESH_Mesh_i::PrepareForWriting (const char* file) +//================================================================================ +/*! + * \brief Care of a file before exporting mesh into it + */ +//================================================================================ + +void SMESH_Mesh_i::PrepareForWriting (const char* file, bool overwrite) { TCollection_AsciiString aFullName ((char*)file); OSD_Path aPath (aFullName); @@ -2015,8 +2616,10 @@ void SMESH_Mesh_i::PrepareForWriting (const char* file) // existing filesystem node if (aFile.KindOfFile() == OSD_FILE) { if (aFile.IsWriteable()) { - aFile.Reset(); - aFile.Remove(); + if (overwrite) { + aFile.Reset(); + aFile.Remove(); + } if (aFile.Failed()) { TCollection_AsciiString msg ("File "); msg += aFullName + " cannot be replaced."; @@ -2047,98 +2650,188 @@ void SMESH_Mesh_i::PrepareForWriting (const char* file) } } -void SMESH_Mesh_i::ExportToMED (const char* file, - CORBA::Boolean auto_groups, - SMESH::MED_VERSION theVersion) - throw(SALOME::SALOME_Exception) -{ - Unexpect aCatch(SALOME_SalomeException); +//================================================================================ +/*! + * \brief Prepares a file for export and pass names of mesh groups from study to mesh DS + * \param file - file name + * \param overwrite - to erase the file or not + * \retval string - mesh name + */ +//================================================================================ +string SMESH_Mesh_i::prepareMeshNameAndGroups(const char* file, + CORBA::Boolean overwrite) +{ // Perform Export - PrepareForWriting(file); - const char* aMeshName = "Mesh"; + PrepareForWriting(file, overwrite); + string aMeshName = "Mesh"; SALOMEDS::Study_ptr aStudy = _gen_i->GetCurrentStudy(); if ( !aStudy->_is_nil() ) { SALOMEDS::SObject_var aMeshSO = _gen_i->ObjectToSObject( aStudy, _this() ); if ( !aMeshSO->_is_nil() ) { - aMeshName = aMeshSO->GetName(); + CORBA::String_var name = aMeshSO->GetName(); + aMeshName = name; // asv : 27.10.04 : fix of 6903: check for StudyLocked before adding attributes if ( !aStudy->GetProperties()->IsLocked() ) - { - SALOMEDS::GenericAttribute_var anAttr; - SALOMEDS::StudyBuilder_var aStudyBuilder = aStudy->NewBuilder(); - SALOMEDS::AttributeExternalFileDef_var aFileName; - anAttr=aStudyBuilder->FindOrCreateAttribute(aMeshSO, "AttributeExternalFileDef"); - aFileName = SALOMEDS::AttributeExternalFileDef::_narrow(anAttr); - ASSERT(!aFileName->_is_nil()); + { + SALOMEDS::GenericAttribute_var anAttr; + SALOMEDS::StudyBuilder_var aStudyBuilder = aStudy->NewBuilder(); + SALOMEDS::AttributeExternalFileDef_var aFileName; + anAttr=aStudyBuilder->FindOrCreateAttribute(aMeshSO, "AttributeExternalFileDef"); + aFileName = SALOMEDS::AttributeExternalFileDef::_narrow(anAttr); + ASSERT(!aFileName->_is_nil()); aFileName->SetValue(file); SALOMEDS::AttributeFileType_var aFileType; anAttr=aStudyBuilder->FindOrCreateAttribute(aMeshSO, "AttributeFileType"); aFileType = SALOMEDS::AttributeFileType::_narrow(anAttr); ASSERT(!aFileType->_is_nil()); aFileType->SetValue("FICHIERMED"); - } + } } } // Update Python script // set name of mesh before export - TPythonDump() << _gen_i << ".SetName(" << _this() << ", '" << aMeshName << "')"; - + TPythonDump() << _gen_i << ".SetName(" << _this() << ", '" << aMeshName.c_str() << "')"; + // check names of groups checkGroupNames(); - TPythonDump() << _this() << ".ExportToMED( '" - << file << "', " << auto_groups << ", " << theVersion << " )"; + return aMeshName; +} + +//================================================================================ +/*! + * \brief Export to med file + */ +//================================================================================ + +void SMESH_Mesh_i::ExportToMEDX (const char* file, + CORBA::Boolean auto_groups, + SMESH::MED_VERSION theVersion, + CORBA::Boolean overwrite) + throw(SALOME::SALOME_Exception) +{ + Unexpect aCatch(SALOME_SalomeException); + if ( _preMeshInfo ) + _preMeshInfo->FullLoadFromFile(); + + string aMeshName = prepareMeshNameAndGroups(file, overwrite); + TPythonDump() << _this() << ".ExportToMEDX( r'" + << file << "', " << auto_groups << ", " << theVersion << ", " << overwrite << " )"; + + _impl->ExportMED( file, aMeshName.c_str(), auto_groups, theVersion ); +} + +//================================================================================ +/*! + * \brief Export a mesh to a med file + */ +//================================================================================ - _impl->ExportMED( file, aMeshName, auto_groups, theVersion ); +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) + 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 + */ +//================================================================================ + +void SMESH_Mesh_i::ExportSAUV (const char* file, + CORBA::Boolean auto_groups) throw(SALOME::SALOME_Exception) { - ExportToMED(file,auto_groups,SMESH::MED_V2_1); + Unexpect aCatch(SALOME_SalomeException); + if ( _preMeshInfo ) + _preMeshInfo->FullLoadFromFile(); + + string aMeshName = prepareMeshNameAndGroups(file, true); + TPythonDump() << _this() << ".ExportSAUV( r'" << file << "', " << auto_groups << " )"; + _impl->ExportSAUV(file, aMeshName.c_str(), auto_groups); } + +//================================================================================ +/*! + * \brief Export a mesh to a DAT file + */ +//================================================================================ + void SMESH_Mesh_i::ExportDAT (const char *file) throw(SALOME::SALOME_Exception) { Unexpect aCatch(SALOME_SalomeException); + if ( _preMeshInfo ) + _preMeshInfo->FullLoadFromFile(); // Update Python script // check names of groups checkGroupNames(); - TPythonDump() << _this() << ".ExportDAT( '" << file << "' )"; + TPythonDump() << _this() << ".ExportDAT( r'" << file << "' )"; // Perform Export PrepareForWriting(file); _impl->ExportDAT(file); } +//================================================================================ +/*! + * \brief Export a mesh to an UNV file + */ +//================================================================================ + void SMESH_Mesh_i::ExportUNV (const char *file) throw(SALOME::SALOME_Exception) { Unexpect aCatch(SALOME_SalomeException); + if ( _preMeshInfo ) + _preMeshInfo->FullLoadFromFile(); // Update Python script // check names of groups checkGroupNames(); - TPythonDump() << _this() << ".ExportUNV( '" << file << "' )"; + TPythonDump() << _this() << ".ExportUNV( r'" << file << "' )"; // Perform Export PrepareForWriting(file); _impl->ExportUNV(file); } +//================================================================================ +/*! + * \brief Export a mesh to an STL file + */ +//================================================================================ + void SMESH_Mesh_i::ExportSTL (const char *file, const bool isascii) throw(SALOME::SALOME_Exception) { Unexpect aCatch(SALOME_SalomeException); + if ( _preMeshInfo ) + _preMeshInfo->FullLoadFromFile(); // Update Python script // check names of groups checkGroupNames(); - TPythonDump() << _this() << ".ExportSTL( '" << file << "', " << isascii << " )"; + TPythonDump() << _this() << ".ExportSTL( r'" << file << "', " << isascii << " )"; // Perform Export PrepareForWriting(file); @@ -2147,84 +2840,282 @@ void SMESH_Mesh_i::ExportSTL (const char *file, const bool isascii) //============================================================================= /*! - * + * \brief Class providing SMESHDS_Mesh API to SMESH_IDSource. + * It is used to export a part of mesh as a whole mesh. */ -//============================================================================= - -SALOME_MED::MESH_ptr SMESH_Mesh_i::GetMEDMesh()throw(SALOME::SALOME_Exception) +class SMESH_MeshPartDS : public SMESHDS_Mesh { - Unexpect aCatch(SALOME_SalomeException); - SMESH_MEDMesh_i *aMedMesh = new SMESH_MEDMesh_i(this); - SALOME_MED::MESH_var aMesh = aMedMesh->_this(); - return aMesh._retn(); -} +public: + SMESH_MeshPartDS(SMESH::SMESH_IDSource_ptr meshPart); + + virtual SMDS_NodeIteratorPtr nodesIterator (bool idInceasingOrder=false) const; + virtual SMDS_EdgeIteratorPtr edgesIterator (bool idInceasingOrder=false) const; + virtual SMDS_FaceIteratorPtr facesIterator (bool idInceasingOrder=false) const; + virtual SMDS_VolumeIteratorPtr volumesIterator (bool idInceasingOrder=false) const; + + virtual SMDS_ElemIteratorPtr elementsIterator(SMDSAbs_ElementType type=SMDSAbs_All) const; + virtual SMDS_ElemIteratorPtr elementGeomIterator(SMDSAbs_GeometryType type) const; + virtual SMDS_ElemIteratorPtr elementEntityIterator(SMDSAbs_EntityType type) const; + +private: + TIDSortedElemSet _elements[ SMDSAbs_NbElementTypes ]; + SMESHDS_Mesh* _meshDS; + /*! + * \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 Export a part of mesh to a med file */ -//============================================================================= -CORBA::Long SMESH_Mesh_i::NbNodes()throw(SALOME::SALOME_Exception) +//================================================================================ + +void SMESH_Mesh_i::ExportPartToMED(::SMESH::SMESH_IDSource_ptr meshPart, + const char* file, + CORBA::Boolean auto_groups, + ::SMESH::MED_VERSION version, + ::CORBA::Boolean overwrite) + throw (SALOME::SALOME_Exception) { Unexpect aCatch(SALOME_SalomeException); - return _impl->NbNodes(); + if ( _preMeshInfo ) + _preMeshInfo->FullLoadFromFile(); + + PrepareForWriting(file, overwrite); + + string aMeshName = "Mesh"; + SALOMEDS::Study_ptr aStudy = _gen_i->GetCurrentStudy(); + if ( !aStudy->_is_nil() ) { + SALOMEDS::SObject_var SO = _gen_i->ObjectToSObject( aStudy, meshPart ); + if ( !SO->_is_nil() ) { + CORBA::String_var name = SO->GetName(); + aMeshName = name; + } + } + SMESH_MeshPartDS partDS( meshPart ); + _impl->ExportMED( file, aMeshName.c_str(), auto_groups, version, &partDS ); + + TPythonDump() << _this() << ".ExportPartToMED( " << meshPart << ", r'" << file << "', " + << auto_groups << ", " << version << ", " << overwrite << " )"; } -//============================================================================= +//================================================================================ /*! - * + * \brief Export a part of mesh to a DAT file */ -//============================================================================= -CORBA::Long SMESH_Mesh_i::NbElements()throw (SALOME::SALOME_Exception) +//================================================================================ + +void SMESH_Mesh_i::ExportPartToDAT(::SMESH::SMESH_IDSource_ptr meshPart, + const char* file) + throw (SALOME::SALOME_Exception) { Unexpect aCatch(SALOME_SalomeException); - return NbEdges() + NbFaces() + NbVolumes(); -} + if ( _preMeshInfo ) + _preMeshInfo->FullLoadFromFile(); -//============================================================================= + PrepareForWriting(file); + + SMESH_MeshPartDS partDS( meshPart ); + _impl->ExportDAT(file,&partDS); + + TPythonDump() << _this() << ".ExportPartToDAT( " << meshPart << ", r'" << file << "' )"; +} +//================================================================================ /*! - * + * \brief Export a part of mesh to an UNV file */ -//============================================================================= -CORBA::Long SMESH_Mesh_i::NbEdges()throw(SALOME::SALOME_Exception) +//================================================================================ + +void SMESH_Mesh_i::ExportPartToUNV(::SMESH::SMESH_IDSource_ptr meshPart, + const char* file) + throw (SALOME::SALOME_Exception) { Unexpect aCatch(SALOME_SalomeException); - return _impl->NbEdges(); + if ( _preMeshInfo ) + _preMeshInfo->FullLoadFromFile(); + + PrepareForWriting(file); + + SMESH_MeshPartDS partDS( meshPart ); + _impl->ExportUNV(file, &partDS); + + TPythonDump() << _this() << ".ExportPartToUNV( " << meshPart<< ", r'" << file << "' )"; } +//================================================================================ +/*! + * \brief Export a part of mesh to an STL file + */ +//================================================================================ -CORBA::Long SMESH_Mesh_i::NbEdgesOfOrder(SMESH::ElementOrder order) - throw(SALOME::SALOME_Exception) +void SMESH_Mesh_i::ExportPartToSTL(::SMESH::SMESH_IDSource_ptr meshPart, + const char* file, + ::CORBA::Boolean isascii) + throw (SALOME::SALOME_Exception) { Unexpect aCatch(SALOME_SalomeException); - return _impl->NbEdges( (SMDSAbs_ElementOrder) order); + if ( _preMeshInfo ) + _preMeshInfo->FullLoadFromFile(); + + PrepareForWriting(file); + + SMESH_MeshPartDS partDS( meshPart ); + _impl->ExportSTL(file, isascii, &partDS); + + TPythonDump() << _this() << ".ExportPartToSTL( " + << meshPart<< ", r'" << file << "', " << isascii << ")"; } -//============================================================================= +//================================================================================ /*! - * + * \brief Export a part of mesh to an STL file + */ +//================================================================================ + +void SMESH_Mesh_i::ExportCGNS(::SMESH::SMESH_IDSource_ptr meshPart, + const char* file, + CORBA::Boolean overwrite) + throw (SALOME::SALOME_Exception) +{ +#ifdef WITH_CGNS + Unexpect aCatch(SALOME_SalomeException); + if ( _preMeshInfo ) + _preMeshInfo->FullLoadFromFile(); + + PrepareForWriting(file,overwrite); + + SMESH_MeshPartDS partDS( meshPart ); + _impl->ExportCGNS(file, &partDS); + + TPythonDump() << _this() << ".ExportCGNS( " + << meshPart<< ", r'" << file << "', " << overwrite << ")"; +#else + THROW_SALOME_CORBA_EXCEPTION("CGNS library is unavailable", SALOME::INTERNAL_ERROR); +#endif +} + +//============================================================================= +/*! + * Return implementation of SALOME_MED::MESH interfaces */ //============================================================================= + +SALOME_MED::MESH_ptr SMESH_Mesh_i::GetMEDMesh()throw(SALOME::SALOME_Exception) +{ + Unexpect aCatch(SALOME_SalomeException); + if ( _preMeshInfo ) + _preMeshInfo->FullLoadFromFile(); + + SMESH_MEDMesh_i *aMedMesh = new SMESH_MEDMesh_i(this); + SALOME_MED::MESH_var aMesh = aMedMesh->_this(); + return aMesh._retn(); +} + +//============================================================================= + +CORBA::Long SMESH_Mesh_i::NbNodes()throw(SALOME::SALOME_Exception) +{ + Unexpect aCatch(SALOME_SalomeException); + if ( _preMeshInfo ) + return _preMeshInfo->NbNodes(); + + return _impl->NbNodes(); +} + +CORBA::Long SMESH_Mesh_i::NbElements()throw (SALOME::SALOME_Exception) +{ + Unexpect aCatch(SALOME_SalomeException); + if ( _preMeshInfo ) + return _preMeshInfo->NbElements(); + + return Nb0DElements() + NbEdges() + NbFaces() + NbVolumes() + NbBalls(); +} + +CORBA::Long SMESH_Mesh_i::Nb0DElements()throw (SALOME::SALOME_Exception) +{ + Unexpect aCatch(SALOME_SalomeException); + if ( _preMeshInfo ) + return _preMeshInfo->Nb0DElements(); + + return _impl->Nb0DElements(); +} + +CORBA::Long SMESH_Mesh_i::NbBalls() throw (SALOME::SALOME_Exception) +{ + Unexpect aCatch(SALOME_SalomeException); + if ( _preMeshInfo ) + return _preMeshInfo->NbBalls(); + + return _impl->NbBalls(); +} + +CORBA::Long SMESH_Mesh_i::NbEdges()throw(SALOME::SALOME_Exception) +{ + Unexpect aCatch(SALOME_SalomeException); + if ( _preMeshInfo ) + return _preMeshInfo->NbEdges(); + + return _impl->NbEdges(); +} + +CORBA::Long SMESH_Mesh_i::NbEdgesOfOrder(SMESH::ElementOrder order) + throw(SALOME::SALOME_Exception) +{ + Unexpect aCatch(SALOME_SalomeException); + if ( _preMeshInfo ) + return _preMeshInfo->NbEdges( (SMDSAbs_ElementOrder) order ); + + return _impl->NbEdges( (SMDSAbs_ElementOrder) order); +} + +//============================================================================= + CORBA::Long SMESH_Mesh_i::NbFaces()throw(SALOME::SALOME_Exception) { Unexpect aCatch(SALOME_SalomeException); + if ( _preMeshInfo ) + return _preMeshInfo->NbFaces(); + return _impl->NbFaces(); } CORBA::Long SMESH_Mesh_i::NbTriangles()throw(SALOME::SALOME_Exception) { Unexpect aCatch(SALOME_SalomeException); + if ( _preMeshInfo ) + return _preMeshInfo->NbTriangles(); + return _impl->NbTriangles(); } CORBA::Long SMESH_Mesh_i::NbQuadrangles()throw(SALOME::SALOME_Exception) { Unexpect aCatch(SALOME_SalomeException); + if ( _preMeshInfo ) + return _preMeshInfo->NbQuadrangles(); + return _impl->NbQuadrangles(); } +CORBA::Long SMESH_Mesh_i::NbBiQuadQuadrangles()throw(SALOME::SALOME_Exception) +{ + Unexpect aCatch(SALOME_SalomeException); + if ( _preMeshInfo ) + return _preMeshInfo->NbBiQuadQuadrangles(); + + return _impl->NbBiQuadQuadrangles(); +} + CORBA::Long SMESH_Mesh_i::NbPolygons()throw(SALOME::SALOME_Exception) { Unexpect aCatch(SALOME_SalomeException); + if ( _preMeshInfo ) + return _preMeshInfo->NbPolygons(); + return _impl->NbPolygons(); } @@ -2232,6 +3123,9 @@ CORBA::Long SMESH_Mesh_i::NbFacesOfOrder(SMESH::ElementOrder order) throw(SALOME::SALOME_Exception) { Unexpect aCatch(SALOME_SalomeException); + if ( _preMeshInfo ) + return _preMeshInfo->NbFaces( (SMDSAbs_ElementOrder) order ); + return _impl->NbFaces( (SMDSAbs_ElementOrder) order); } @@ -2239,6 +3133,9 @@ CORBA::Long SMESH_Mesh_i::NbTrianglesOfOrder(SMESH::ElementOrder order) throw(SALOME::SALOME_Exception) { Unexpect aCatch(SALOME_SalomeException); + if ( _preMeshInfo ) + return _preMeshInfo->NbTriangles( (SMDSAbs_ElementOrder) order ); + return _impl->NbTriangles( (SMDSAbs_ElementOrder) order); } @@ -2246,47 +3143,83 @@ CORBA::Long SMESH_Mesh_i::NbQuadranglesOfOrder(SMESH::ElementOrder order) throw(SALOME::SALOME_Exception) { Unexpect aCatch(SALOME_SalomeException); + if ( _preMeshInfo ) + return _preMeshInfo->NbQuadrangles( (SMDSAbs_ElementOrder) order ); + return _impl->NbQuadrangles( (SMDSAbs_ElementOrder) order); } //============================================================================= -/*! - * - */ -//============================================================================= + CORBA::Long SMESH_Mesh_i::NbVolumes()throw(SALOME::SALOME_Exception) { Unexpect aCatch(SALOME_SalomeException); + if ( _preMeshInfo ) + return _preMeshInfo->NbVolumes(); + return _impl->NbVolumes(); } CORBA::Long SMESH_Mesh_i::NbTetras()throw(SALOME::SALOME_Exception) { Unexpect aCatch(SALOME_SalomeException); + if ( _preMeshInfo ) + return _preMeshInfo->NbTetras(); + return _impl->NbTetras(); } CORBA::Long SMESH_Mesh_i::NbHexas()throw(SALOME::SALOME_Exception) { Unexpect aCatch(SALOME_SalomeException); + if ( _preMeshInfo ) + return _preMeshInfo->NbHexas(); + return _impl->NbHexas(); } +CORBA::Long SMESH_Mesh_i::NbTriQuadraticHexas()throw(SALOME::SALOME_Exception) +{ + Unexpect aCatch(SALOME_SalomeException); + if ( _preMeshInfo ) + return _preMeshInfo->NbTriQuadHexas(); + + return _impl->NbTriQuadraticHexas(); +} + CORBA::Long SMESH_Mesh_i::NbPyramids()throw(SALOME::SALOME_Exception) { Unexpect aCatch(SALOME_SalomeException); + if ( _preMeshInfo ) + return _preMeshInfo->NbPyramids(); + return _impl->NbPyramids(); } CORBA::Long SMESH_Mesh_i::NbPrisms()throw(SALOME::SALOME_Exception) { Unexpect aCatch(SALOME_SalomeException); + if ( _preMeshInfo ) + return _preMeshInfo->NbPrisms(); + return _impl->NbPrisms(); } +CORBA::Long SMESH_Mesh_i::NbHexagonalPrisms()throw(SALOME::SALOME_Exception) +{ + Unexpect aCatch(SALOME_SalomeException); + if ( _preMeshInfo ) + return _preMeshInfo->NbHexPrisms(); + + return _impl->NbHexagonalPrisms(); +} + CORBA::Long SMESH_Mesh_i::NbPolyhedrons()throw(SALOME::SALOME_Exception) { Unexpect aCatch(SALOME_SalomeException); + if ( _preMeshInfo ) + return _preMeshInfo->NbPolyhedrons(); + return _impl->NbPolyhedrons(); } @@ -2294,6 +3227,9 @@ CORBA::Long SMESH_Mesh_i::NbVolumesOfOrder(SMESH::ElementOrder order) throw(SALOME::SALOME_Exception) { Unexpect aCatch(SALOME_SalomeException); + if ( _preMeshInfo ) + return _preMeshInfo->NbVolumes( (SMDSAbs_ElementOrder) order ); + return _impl->NbVolumes( (SMDSAbs_ElementOrder) order); } @@ -2301,6 +3237,9 @@ CORBA::Long SMESH_Mesh_i::NbTetrasOfOrder(SMESH::ElementOrder order) throw(SALOME::SALOME_Exception) { Unexpect aCatch(SALOME_SalomeException); + if ( _preMeshInfo ) + return _preMeshInfo->NbTetras( (SMDSAbs_ElementOrder) order); + return _impl->NbTetras( (SMDSAbs_ElementOrder) order); } @@ -2308,6 +3247,9 @@ CORBA::Long SMESH_Mesh_i::NbHexasOfOrder(SMESH::ElementOrder order) throw(SALOME::SALOME_Exception) { Unexpect aCatch(SALOME_SalomeException); + if ( _preMeshInfo ) + return _preMeshInfo->NbHexas( (SMDSAbs_ElementOrder) order); + return _impl->NbHexas( (SMDSAbs_ElementOrder) order); } @@ -2315,6 +3257,9 @@ CORBA::Long SMESH_Mesh_i::NbPyramidsOfOrder(SMESH::ElementOrder order) throw(SALOME::SALOME_Exception) { Unexpect aCatch(SALOME_SalomeException); + if ( _preMeshInfo ) + return _preMeshInfo->NbPyramids( (SMDSAbs_ElementOrder) order); + return _impl->NbPyramids( (SMDSAbs_ElementOrder) order); } @@ -2322,14 +3267,18 @@ CORBA::Long SMESH_Mesh_i::NbPrismsOfOrder(SMESH::ElementOrder order) throw(SALOME::SALOME_Exception) { Unexpect aCatch(SALOME_SalomeException); + if ( _preMeshInfo ) + return _preMeshInfo->NbPrisms( (SMDSAbs_ElementOrder) order); + return _impl->NbPrisms( (SMDSAbs_ElementOrder) order); } //============================================================================= /*! - * + * Returns nb of published sub-meshes */ //============================================================================= + CORBA::Long SMESH_Mesh_i::NbSubMesh()throw(SALOME::SALOME_Exception) { Unexpect aCatch(SALOME_SalomeException); @@ -2338,41 +3287,31 @@ CORBA::Long SMESH_Mesh_i::NbSubMesh()throw(SALOME::SALOME_Exception) //============================================================================= /*! - * + * Dumps mesh into a string */ //============================================================================= + char* SMESH_Mesh_i::Dump() { - std::ostringstream os; + ostringstream os; _impl->Dump( os ); return CORBA::string_dup( os.str().c_str() ); } //============================================================================= /*! - * + * Method of SMESH_IDSource interface */ //============================================================================= + SMESH::long_array* SMESH_Mesh_i::GetIDs() { -// SMESH::long_array_var aResult = new SMESH::long_array(); -// SMESHDS_Mesh* aSMESHDS_Mesh = _impl->GetMeshDS(); -// int aMinId = aSMESHDS_Mesh->MinElementID(); -// int aMaxId = aSMESHDS_Mesh->MaxElementID(); - -// aResult->length(aMaxId - aMinId + 1); - -// for (int i = 0, id = aMinId; id <= aMaxId; id++ ) -// aResult[i++] = id; - -// return aResult._retn(); - // PAL12398 return GetElementsId(); } //============================================================================= /*! - * + * Returns ids of all elements */ //============================================================================= @@ -2380,7 +3319,9 @@ SMESH::long_array* SMESH_Mesh_i::GetElementsId() throw (SALOME::SALOME_Exception) { Unexpect aCatch(SALOME_SalomeException); - MESSAGE("SMESH_Mesh_i::GetElementsId"); + if ( _preMeshInfo ) + _preMeshInfo->FullLoadFromFile(); + SMESH::long_array_var aResult = new SMESH::long_array(); SMESHDS_Mesh* aSMESHDS_Mesh = _impl->GetMeshDS(); @@ -2399,7 +3340,7 @@ SMESH::long_array* SMESH_Mesh_i::GetElementsId() //============================================================================= /*! - * + * Returns ids of all elements of given type */ //============================================================================= @@ -2407,7 +3348,9 @@ SMESH::long_array* SMESH_Mesh_i::GetElementsByType( SMESH::ElementType theElemTy throw (SALOME::SALOME_Exception) { Unexpect aCatch(SALOME_SalomeException); - MESSAGE("SMESH_subMesh_i::GetElementsByType"); + if ( _preMeshInfo ) + _preMeshInfo->FullLoadFromFile(); + SMESH::long_array_var aResult = new SMESH::long_array(); SMESHDS_Mesh* aSMESHDS_Mesh = _impl->GetMeshDS(); @@ -2419,7 +3362,7 @@ SMESH::long_array* SMESH_Mesh_i::GetElementsByType( SMESH::ElementType theElemTy // No sense in returning ids of elements along with ids of nodes: // when theElemType == SMESH::ALL, return node ids only if // there are no elements - if ( theElemType == SMESH::NODE || theElemType == SMESH::ALL && nbElements == 0 ) + if ( theElemType == SMESH::NODE || (theElemType == SMESH::ALL && nbElements == 0) ) return GetNodesId(); aResult->length( nbElements ); @@ -2440,7 +3383,7 @@ SMESH::long_array* SMESH_Mesh_i::GetElementsByType( SMESH::ElementType theElemTy //============================================================================= /*! - * + * Returns ids of all nodes */ //============================================================================= @@ -2448,7 +3391,9 @@ SMESH::long_array* SMESH_Mesh_i::GetNodesId() throw (SALOME::SALOME_Exception) { Unexpect aCatch(SALOME_SalomeException); - MESSAGE("SMESH_subMesh_i::GetNodesId"); + if ( _preMeshInfo ) + _preMeshInfo->FullLoadFromFile(); + SMESH::long_array_var aResult = new SMESH::long_array(); SMESHDS_Mesh* aSMESHDS_Mesh = _impl->GetMeshDS(); @@ -2457,7 +3402,7 @@ SMESH::long_array* SMESH_Mesh_i::GetNodesId() long nbNodes = NbNodes(); aResult->length( nbNodes ); - SMDS_NodeIteratorPtr anIt = aSMESHDS_Mesh->nodesIterator(); + SMDS_NodeIteratorPtr anIt = aSMESHDS_Mesh->nodesIterator(/*idInceasingOrder=*/true); for ( int i = 0, n = nbNodes; i < n && anIt->more(); i++ ) aResult[i] = anIt->next()->GetID(); @@ -2473,9 +3418,30 @@ SMESH::long_array* SMESH_Mesh_i::GetNodesId() SMESH::ElementType SMESH_Mesh_i::GetElementType( const CORBA::Long id, const bool iselem ) throw (SALOME::SALOME_Exception) { + if ( _preMeshInfo ) + _preMeshInfo->FullLoadFromFile(); + return ( SMESH::ElementType )_impl->GetElementType( id, iselem ); } +//============================================================================= +/*! + * + */ +//============================================================================= + +SMESH::EntityType SMESH_Mesh_i::GetElementGeomType( const CORBA::Long id ) + throw (SALOME::SALOME_Exception) +{ + if ( _preMeshInfo ) + _preMeshInfo->FullLoadFromFile(); + + const SMDS_MeshElement* e = _impl->GetMeshDS()->FindElement(id); + if ( !e ) + THROW_SALOME_CORBA_EXCEPTION( "invalid element id", SALOME::BAD_PARAM ); + + return ( SMESH::EntityType ) e->GetEntityType(); +} //============================================================================= /*! @@ -2485,6 +3451,9 @@ SMESH::ElementType SMESH_Mesh_i::GetElementType( const CORBA::Long id, const boo SMESH::long_array* SMESH_Mesh_i::GetSubMeshElementsId(const CORBA::Long ShapeID) throw (SALOME::SALOME_Exception) { + if ( _preMeshInfo ) + _preMeshInfo->FullLoadFromFile(); + SMESH::long_array_var aResult = new SMESH::long_array(); SMESH_subMesh* SM = _impl->GetSubMeshContaining(ShapeID); @@ -2512,9 +3481,13 @@ SMESH::long_array* SMESH_Mesh_i::GetSubMeshElementsId(const CORBA::Long ShapeID) * returns only nodes on shapes. */ //============================================================================= -SMESH::long_array* SMESH_Mesh_i::GetSubMeshNodesId(const CORBA::Long ShapeID, CORBA::Boolean all) - throw (SALOME::SALOME_Exception) +SMESH::long_array* SMESH_Mesh_i::GetSubMeshNodesId(const CORBA::Long ShapeID, + CORBA::Boolean all) + throw (SALOME::SALOME_Exception) { + if ( _preMeshInfo ) + _preMeshInfo->FullLoadFromFile(); + SMESH::long_array_var aResult = new SMESH::long_array(); SMESH_subMesh* SM = _impl->GetSubMeshContaining(ShapeID); @@ -2552,15 +3525,18 @@ SMESH::long_array* SMESH_Mesh_i::GetSubMeshNodesId(const CORBA::Long ShapeID, CO return aResult._retn(); } - //============================================================================= /*! * Returns type of elements for given submesh */ //============================================================================= + SMESH::ElementType SMESH_Mesh_i::GetSubMeshElementType(const CORBA::Long ShapeID) - throw (SALOME::SALOME_Exception) + throw (SALOME::SALOME_Exception) { + if ( _preMeshInfo ) + _preMeshInfo->FullLoadFromFile(); + SMESH_subMesh* SM = _impl->GetSubMeshContaining(ShapeID); if(!SM) return SMESH::ALL; @@ -2578,12 +3554,15 @@ SMESH::ElementType SMESH_Mesh_i::GetSubMeshElementType(const CORBA::Long ShapeID //============================================================================= /*! - * + * Returns pointer to _impl as an integer value. Is called from constructor of SMESH_Client */ //============================================================================= CORBA::LongLong SMESH_Mesh_i::GetMeshPtr() { + if ( _preMeshInfo ) + _preMeshInfo->FullLoadFromFile(); + CORBA::LongLong pointeur = CORBA::LongLong(_impl); if ( MYDEBUG ) MESSAGE("CORBA::LongLong SMESH_Mesh_i::GetMeshPtr() "<FullLoadFromFile(); + SMESH::double_array_var aResult = new SMESH::double_array(); SMESHDS_Mesh* aSMESHDS_Mesh = _impl->GetMeshDS(); if ( aSMESHDS_Mesh == NULL ) @@ -2628,6 +3610,9 @@ SMESH::double_array* SMESH_Mesh_i::GetNodeXYZ(const CORBA::Long id) SMESH::long_array* SMESH_Mesh_i::GetNodeInverseElements(const CORBA::Long id) { + if ( _preMeshInfo ) + _preMeshInfo->FullLoadFromFile(); + SMESH::long_array_var aResult = new SMESH::long_array(); SMESHDS_Mesh* aSMESHDS_Mesh = _impl->GetMeshDS(); if ( aSMESHDS_Mesh == NULL ) @@ -2663,6 +3648,9 @@ SMESH::long_array* SMESH_Mesh_i::GetNodeInverseElements(const CORBA::Long id) SMESH::NodePosition* SMESH_Mesh_i::GetNodePosition(CORBA::Long NodeID) { + if ( _preMeshInfo ) + _preMeshInfo->FullLoadFromFile(); + SMESH::NodePosition* aNodePosition = new SMESH::NodePosition(); aNodePosition->shapeID = 0; aNodePosition->shapeType = GEOM::SHAPE; @@ -2674,21 +3662,21 @@ SMESH::NodePosition* SMESH_Mesh_i::GetNodePosition(CORBA::Long NodeID) { if ( SMDS_PositionPtr pos = aNode->GetPosition() ) { - aNodePosition->shapeID = pos->GetShapeId(); + aNodePosition->shapeID = aNode->getshapeId(); switch ( pos->GetTypeOfPosition() ) { case SMDS_TOP_EDGE: aNodePosition->shapeType = GEOM::EDGE; aNodePosition->params.length(1); aNodePosition->params[0] = - static_cast( pos.get() )->GetUParameter(); + static_cast( pos )->GetUParameter(); break; case SMDS_TOP_FACE: aNodePosition->shapeType = GEOM::FACE; aNodePosition->params.length(2); aNodePosition->params[0] = - static_cast( pos.get() )->GetUParameter(); + static_cast( pos )->GetUParameter(); aNodePosition->params[1] = - static_cast( pos.get() )->GetVParameter(); + static_cast( pos )->GetVParameter(); break; case SMDS_TOP_VERTEX: aNodePosition->shapeType = GEOM::VERTEX; @@ -2715,6 +3703,9 @@ SMESH::NodePosition* SMESH_Mesh_i::GetNodePosition(CORBA::Long NodeID) CORBA::Long SMESH_Mesh_i::GetShapeID(const CORBA::Long id) { + if ( _preMeshInfo ) + _preMeshInfo->FullLoadFromFile(); + SMESHDS_Mesh* aSMESHDS_Mesh = _impl->GetMeshDS(); if ( aSMESHDS_Mesh == NULL ) return -1; @@ -2722,11 +3713,7 @@ CORBA::Long SMESH_Mesh_i::GetShapeID(const CORBA::Long id) // try to find node const SMDS_MeshNode* aNode = aSMESHDS_Mesh->FindNode(id); if(aNode) { - SMDS_PositionPtr pos = aNode->GetPosition(); - if(!pos) - return -1; - else - return pos->GetShapeId(); + return aNode->getshapeId(); } return -1; @@ -2743,6 +3730,9 @@ CORBA::Long SMESH_Mesh_i::GetShapeID(const CORBA::Long id) CORBA::Long SMESH_Mesh_i::GetShapeIDForElem(const CORBA::Long id) { + if ( _preMeshInfo ) + _preMeshInfo->FullLoadFromFile(); + SMESHDS_Mesh* aSMESHDS_Mesh = _impl->GetMeshDS(); if ( aSMESHDS_Mesh == NULL ) return -1; @@ -2771,6 +3761,9 @@ CORBA::Long SMESH_Mesh_i::GetShapeIDForElem(const CORBA::Long id) 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; // try to find element @@ -2790,6 +3783,9 @@ CORBA::Long SMESH_Mesh_i::GetElemNbNodes(const CORBA::Long id) CORBA::Long SMESH_Mesh_i::GetElemNode(const CORBA::Long id, const CORBA::Long index) { + if ( _preMeshInfo ) + _preMeshInfo->FullLoadFromFile(); + SMESHDS_Mesh* aSMESHDS_Mesh = _impl->GetMeshDS(); if ( aSMESHDS_Mesh == NULL ) return -1; const SMDS_MeshElement* elem = aSMESHDS_Mesh->FindElement(id); @@ -2806,6 +3802,9 @@ CORBA::Long SMESH_Mesh_i::GetElemNode(const CORBA::Long id, const CORBA::Long in SMESH::long_array* SMESH_Mesh_i::GetElemNodes(const CORBA::Long id) { + if ( _preMeshInfo ) + _preMeshInfo->FullLoadFromFile(); + SMESH::long_array_var aResult = new SMESH::long_array(); if ( SMESHDS_Mesh* aSMESHDS_Mesh = _impl->GetMeshDS() ) { @@ -2828,6 +3827,9 @@ SMESH::long_array* SMESH_Mesh_i::GetElemNodes(const CORBA::Long id) CORBA::Boolean SMESH_Mesh_i::IsMediumNode(const CORBA::Long ide, const CORBA::Long idn) { + if ( _preMeshInfo ) + _preMeshInfo->FullLoadFromFile(); + SMESHDS_Mesh* aSMESHDS_Mesh = _impl->GetMeshDS(); if ( aSMESHDS_Mesh == NULL ) return false; // try to find node @@ -2851,6 +3853,9 @@ CORBA::Boolean SMESH_Mesh_i::IsMediumNode(const CORBA::Long ide, const CORBA::Lo CORBA::Boolean SMESH_Mesh_i::IsMediumNodeOfAnyElem(const CORBA::Long idn, SMESH::ElementType theElemType) { + if ( _preMeshInfo ) + _preMeshInfo->FullLoadFromFile(); + SMESHDS_Mesh* aSMESHDS_Mesh = _impl->GetMeshDS(); if ( aSMESHDS_Mesh == NULL ) return false; @@ -2878,6 +3883,9 @@ CORBA::Boolean SMESH_Mesh_i::IsMediumNodeOfAnyElem(const CORBA::Long idn, 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); @@ -2894,6 +3902,9 @@ CORBA::Long SMESH_Mesh_i::ElemNbEdges(const CORBA::Long id) 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); @@ -2901,6 +3912,63 @@ CORBA::Long SMESH_Mesh_i::ElemNbFaces(const CORBA::Long id) return elem->NbFaces(); } +//======================================================================= +//function : GetElemFaceNodes +//purpose : Returns nodes of given face (counted from zero) for given element. +//======================================================================= + +SMESH::long_array* SMESH_Mesh_i::GetElemFaceNodes(CORBA::Long elemId, + CORBA::Short faceIndex) +{ + if ( _preMeshInfo ) + _preMeshInfo->FullLoadFromFile(); + + SMESH::long_array_var aResult = new SMESH::long_array(); + if ( SMESHDS_Mesh* aSMESHDS_Mesh = _impl->GetMeshDS() ) + { + if ( const SMDS_MeshElement* elem = aSMESHDS_Mesh->FindElement(elemId) ) + { + SMDS_VolumeTool vtool( elem ); + if ( faceIndex < vtool.NbFaces() ) + { + aResult->length( vtool.NbFaceNodes( faceIndex )); + const SMDS_MeshNode** nn = vtool.GetFaceNodes( faceIndex ); + for ( int i = 0; i < aResult->length(); ++i ) + aResult[ i ] = nn[ i ]->GetID(); + } + } + } + return aResult._retn(); +} + +//======================================================================= +//function : FindElementByNodes +//purpose : Returns an element based on all given nodes. +//======================================================================= + +CORBA::Long SMESH_Mesh_i::FindElementByNodes(const SMESH::long_array& nodes) +{ + if ( _preMeshInfo ) + _preMeshInfo->FullLoadFromFile(); + + CORBA::Long elemID(0); + if ( SMESHDS_Mesh* mesh = _impl->GetMeshDS() ) + { + vector< const SMDS_MeshNode * > nn( nodes.length() ); + for ( int i = 0; i < nodes.length(); ++i ) + if ( !( nn[i] = mesh->FindNode( nodes[i] ))) + return elemID; + + const SMDS_MeshElement* elem = mesh->FindElement( nn ); + if ( !elem && ( _impl->NbEdges ( ORDER_QUADRATIC ) || + _impl->NbFaces ( ORDER_QUADRATIC ) || + _impl->NbVolumes( ORDER_QUADRATIC ))) + elem = mesh->FindElement( nn, SMDSAbs_All, /*noMedium=*/true ); + + if ( elem ) elemID = CORBA::Long( elem->GetID() ); + } + return elemID; +} //============================================================================= /*! @@ -2910,6 +3978,9 @@ CORBA::Long SMESH_Mesh_i::ElemNbFaces(const CORBA::Long id) 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); @@ -2926,6 +3997,9 @@ CORBA::Boolean SMESH_Mesh_i::IsPoly(const CORBA::Long id) 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); @@ -2933,6 +4007,23 @@ CORBA::Boolean SMESH_Mesh_i::IsQuadratic(const CORBA::Long id) return elem->IsQuadratic(); } +//============================================================================= +/*! + * Returns diameter of ball discrete element or zero in case of an invalid \a id + */ +//============================================================================= + +CORBA::Double SMESH_Mesh_i::GetBallDiameter(CORBA::Long id) +{ + if ( _preMeshInfo ) + _preMeshInfo->FullLoadFromFile(); + + if ( const SMDS_BallElement* ball = + dynamic_cast( _impl->GetMeshDS()->FindElement( id ))) + return ball->GetDiameter(); + + return 0; +} //============================================================================= /*! @@ -2942,6 +4033,9 @@ CORBA::Boolean SMESH_Mesh_i::IsQuadratic(const CORBA::Long id) SMESH::double_array* SMESH_Mesh_i::BaryCenter(const CORBA::Long id) { + if ( _preMeshInfo ) + _preMeshInfo->FullLoadFromFile(); + SMESH::double_array_var aResult = new SMESH::double_array(); SMESHDS_Mesh* aSMESHDS_Mesh = _impl->GetMeshDS(); if ( aSMESHDS_Mesh == NULL ) @@ -2993,6 +4087,7 @@ void SMESH_Mesh_i::CreateGroupServants() { SALOMEDS::Study_ptr aStudy = _gen_i->GetCurrentStudy(); + set addedIDs; ::SMESH_Mesh::GroupIteratorPtr groupIt = _impl->GetGroups(); while ( groupIt->more() ) { @@ -3002,6 +4097,7 @@ void SMESH_Mesh_i::CreateGroupServants() map::iterator it = _mapGroups.find(anId); if ( it != _mapGroups.end() && !CORBA::is_nil( it->second )) continue; + addedIDs.insert( anId ); SMESH_GroupBase_i* aGroupImpl; TopoDS_Shape shape; @@ -3027,12 +4123,23 @@ void SMESH_Mesh_i::CreateGroupServants() int nextId = _gen_i->RegisterObject( groupVar ); if(MYDEBUG) MESSAGE( "Add group to map with id = "<< nextId); - // publishing of the groups in the study + // publishing the groups in the study if ( !aStudy->_is_nil() ) { GEOM::GEOM_Object_var shapeVar = _gen_i->ShapeToGeomObject( shape ); _gen_i->PublishGroup( aStudy, _this(), groupVar, shapeVar, groupVar->GetName()); } } + if ( !addedIDs.empty() ) + { + // python dump + set::iterator id = addedIDs.begin(); + for ( ; id != addedIDs.end(); ++id ) + { + map::iterator it = _mapGroups.find(*id); + int i = std::distance( _mapGroups.begin(), it ); + TPythonDump() << it->second << " = " << _this() << ".GetGroups()[ "<< i << " ]"; + } + } } //============================================================================= @@ -3066,7 +4173,7 @@ SMESH::ListOfGroups* SMESH_Mesh_i::GetGroups(const list& groupIDs) const SALOME_MED::MedFileInfo* SMESH_Mesh_i::GetMEDFileInfo() { - SALOME_MED::MedFileInfo_var res( myFileInfo ); + SALOME_MED::MedFileInfo_var res( _medFileInfo ); if ( !res.operator->() ) { res = new SALOME_MED::MedFileInfo; res->fileName = ""; @@ -3077,7 +4184,7 @@ SALOME_MED::MedFileInfo* SMESH_Mesh_i::GetMEDFileInfo() //============================================================================= /*! - * \brief Check and correct names of mesh groups + * \brief Pass names of mesh groups from study to mesh DS */ //============================================================================= @@ -3120,8 +4227,9 @@ void SMESH_Mesh_i::checkGroupNames() //============================================================================= void SMESH_Mesh_i::SetParameters(const char* theParameters) { - SMESH_Gen_i::GetSMESHGen()->UpdateParameters(SMESH::SMESH_Mesh::_narrow(_this()), - CORBA::string_dup(theParameters)); + // SMESH_Gen_i::GetSMESHGen()->UpdateParameters(SMESH::SMESH_Mesh::_narrow(_this()), + // CORBA::string_dup(theParameters)); + SMESH_Gen_i::GetSMESHGen()->UpdateParameters(theParameters); } //============================================================================= @@ -3159,3 +4267,653 @@ SMESH::string_array* SMESH_Mesh_i::GetLastParameters() } return aResult._retn(); } + +//======================================================================= +//function : GetTypes +//purpose : Returns types of elements it contains +//======================================================================= + +SMESH::array_of_ElementType* SMESH_Mesh_i::GetTypes() +{ + if ( _preMeshInfo ) + return _preMeshInfo->GetTypes(); + + SMESH::array_of_ElementType_var types = new SMESH::array_of_ElementType; + + types->length( 5 ); + int nbTypes = 0; + if (_impl->NbEdges()) types[nbTypes++] = SMESH::EDGE; + if (_impl->NbFaces()) types[nbTypes++] = SMESH::FACE; + if (_impl->NbVolumes()) types[nbTypes++] = SMESH::VOLUME; + if (_impl->Nb0DElements()) types[nbTypes++] = SMESH::ELEM0D; + if (_impl->NbBalls()) types[nbTypes++] = SMESH::BALL; + types->length( nbTypes ); + + return types._retn(); +} + +//======================================================================= +//function : GetMesh +//purpose : Returns self +//======================================================================= + +SMESH::SMESH_Mesh_ptr SMESH_Mesh_i::GetMesh() +{ + return SMESH::SMESH_Mesh::_duplicate( _this() ); +} + +//======================================================================= +//function : IsMeshInfoCorrect +//purpose : * Returns false if GetMeshInfo() returns incorrect information that may +// * happen if mesh data is not yet fully loaded from the file of study. +//======================================================================= + +bool SMESH_Mesh_i::IsMeshInfoCorrect() +{ + return _preMeshInfo ? _preMeshInfo->IsMeshInfoCorrect() : true; +} + +//============================================================================= +/*! + * \brief Returns statistic of mesh elements + */ +//============================================================================= + +SMESH::long_array* SMESH_Mesh_i::GetMeshInfo() +{ + if ( _preMeshInfo ) + return _preMeshInfo->GetMeshInfo(); + + SMESH::long_array_var aRes = new SMESH::long_array(); + aRes->length(SMESH::Entity_Last); + for (int i = SMESH::Entity_Node; i < SMESH::Entity_Last; i++) + aRes[i] = 0; + SMESHDS_Mesh* aMeshDS = _impl->GetMeshDS(); + if (!aMeshDS) + return aRes._retn(); + const SMDS_MeshInfo& aMeshInfo = aMeshDS->GetMeshInfo(); + for (int i = SMESH::Entity_Node; i < SMESH::Entity_Last; i++) + aRes[i] = aMeshInfo.NbEntities((SMDSAbs_EntityType)i); + return aRes._retn(); +} + +//============================================================================= +/*! + * \brief Collect statistic of mesh elements given by iterator + */ +//============================================================================= + +void SMESH_Mesh_i::CollectMeshInfo(const SMDS_ElemIteratorPtr theItr, + SMESH::long_array& theInfo) +{ + if (!theItr) return; + while (theItr->more()) + theInfo[ theItr->next()->GetEntityType() ]++; +} + +//============================================================================= +/*! + * \brief mapping of mesh dimension into shape type + */ +//============================================================================= + +static TopAbs_ShapeEnum shapeTypeByDim(const int theDim) +{ + TopAbs_ShapeEnum aType = TopAbs_SOLID; + switch ( theDim ) { + case 0: aType = TopAbs_VERTEX; break; + case 1: aType = TopAbs_EDGE; break; + case 2: aType = TopAbs_FACE; break; + case 3: + default:aType = TopAbs_SOLID; break; + } + return aType; +} + +//============================================================================= +/*! + * \brief Internal structure used to find concurent submeshes + * + * It represents a pair < submesh, concurent dimension >, where + * 'concurrent dimension' is dimension of shape where the submesh can concurent + * with another submesh. In other words, it is dimension of a hypothesis assigned + * to submesh. + */ +//============================================================================= + +class SMESH_DimHyp +{ + public: + //! fileds + int _dim; //!< a dimension the algo can build (concurrent dimension) + int _ownDim; //!< dimension of shape of _subMesh (>=_dim) + TopTools_MapOfShape _shapeMap; + SMESH_subMesh* _subMesh; + list _hypothesises; //!< algo is first, then its parameters + + //! Constructors + SMESH_DimHyp(const SMESH_subMesh* theSubMesh, + const int theDim, + const TopoDS_Shape& theShape) + { + _subMesh = (SMESH_subMesh*)theSubMesh; + SetShape( theDim, theShape ); + } + + //! set shape + void SetShape(const int theDim, + const TopoDS_Shape& theShape) + { + _dim = theDim; + _ownDim = (int)SMESH_Gen::GetShapeDim(theShape); + if (_dim >= _ownDim) + _shapeMap.Add( theShape ); + else { + TopExp_Explorer anExp( theShape, shapeTypeByDim(theDim) ); + for( ; anExp.More(); anExp.Next() ) + _shapeMap.Add( anExp.Current() ); + } + } + + //! Check sharing of sub-shapes + static bool isShareSubShapes(const TopTools_MapOfShape& theToCheck, + const TopTools_MapOfShape& theToFind, + const TopAbs_ShapeEnum theType) + { + bool isShared = false; + TopTools_MapIteratorOfMapOfShape anItr( theToCheck ); + for (; !isShared && anItr.More(); anItr.Next() ) + { + const TopoDS_Shape aSubSh = anItr.Key(); + // check for case when concurrent dimensions are same + isShared = theToFind.Contains( aSubSh ); + // check for sub-shape with concurrent dimension + TopExp_Explorer anExp( aSubSh, theType ); + for ( ; !isShared && anExp.More(); anExp.Next() ) + isShared = theToFind.Contains( anExp.Current() ); + } + return isShared; + } + + //! check algorithms + static bool checkAlgo(const SMESHDS_Hypothesis* theA1, + const SMESHDS_Hypothesis* theA2) + { + if ( theA1->GetType() == SMESHDS_Hypothesis::PARAM_ALGO || + theA2->GetType() == SMESHDS_Hypothesis::PARAM_ALGO ) + return false; // one of the hypothesis is not algorithm + // check algorithm names (should be equal) + return strcmp( theA1->GetName(), theA2->GetName() ) == 0; + } + + + //! Check if sub-shape hypotheses are concurrent + bool IsConcurrent(const SMESH_DimHyp* theOther) const + { + if ( _subMesh == theOther->_subMesh ) + return false; // same sub-shape - should not be + + // if ( == && + // any of the two submeshes is not on COMPOUND shape ) + // -> no concurrency + bool meIsCompound = (_subMesh->GetSubMeshDS() && _subMesh->GetSubMeshDS()->IsComplexSubmesh()); + bool otherIsCompound = (theOther->_subMesh->GetSubMeshDS() && theOther->_subMesh->GetSubMeshDS()->IsComplexSubmesh()); + if ( (_ownDim == _dim || theOther->_ownDim == _dim ) && (!meIsCompound || !otherIsCompound)) + return false; + +// bool checkSubShape = ( _dim >= theOther->_dim ) +// ? isShareSubShapes( _shapeMap, theOther->_shapeMap, shapeTypeByDim(theOther->_dim) ) +// : isShareSubShapes( theOther->_shapeMap, _shapeMap, shapeTypeByDim(_dim) ) ; + bool checkSubShape = isShareSubShapes( _shapeMap, theOther->_shapeMap, shapeTypeByDim(_dim)); + if ( !checkSubShape ) + return false; + + // check algorithms to be same + if (!checkAlgo( _hypothesises.front(), theOther->_hypothesises.front() )) + return true; // different algorithms + + // check hypothesises for concurrence (skip first as algorithm) + int nbSame = 0; + // pointers should be same, becase it is referenes from mesh hypothesis partition + list ::const_iterator hypIt = _hypothesises.begin(); + list ::const_iterator otheEndIt = theOther->_hypothesises.end(); + for ( hypIt++ /*skip first as algo*/; hypIt != _hypothesises.end(); hypIt++ ) + if ( find( theOther->_hypothesises.begin(), otheEndIt, *hypIt ) != otheEndIt ) + nbSame++; + // the submeshes are concurrent if their algorithms has different parameters + return nbSame != theOther->_hypothesises.size() - 1; + } + +}; // end of SMESH_DimHyp + +typedef list TDimHypList; + +static void addDimHypInstance(const int theDim, + const TopoDS_Shape& theShape, + const SMESH_Algo* theAlgo, + const SMESH_subMesh* theSubMesh, + const list & theHypList, + TDimHypList* theDimHypListArr ) +{ + TDimHypList& listOfdimHyp = theDimHypListArr[theDim]; + if ( listOfdimHyp.empty() || listOfdimHyp.back()->_subMesh != theSubMesh ) { + SMESH_DimHyp* dimHyp = new SMESH_DimHyp( theSubMesh, theDim, theShape ); + listOfdimHyp.push_back( dimHyp ); + } + + SMESH_DimHyp* dimHyp = listOfdimHyp.back(); + dimHyp->_hypothesises.push_front(theAlgo); + list ::const_iterator hypIt = theHypList.begin(); + for( ; hypIt != theHypList.end(); hypIt++ ) + dimHyp->_hypothesises.push_back( *hypIt ); +} + +static void findConcurrents(const SMESH_DimHyp* theDimHyp, + const TDimHypList& theListOfDimHyp, + TListOfInt& theListOfConcurr ) +{ + TDimHypList::const_reverse_iterator rIt = theListOfDimHyp.rbegin(); + for ( ; rIt != theListOfDimHyp.rend(); rIt++ ) { + const SMESH_DimHyp* curDimHyp = *rIt; + if ( curDimHyp == theDimHyp ) + break; // meet own dimHyp pointer in same dimension + else if ( theDimHyp->IsConcurrent( curDimHyp ) ) + if ( find( theListOfConcurr.begin(), + theListOfConcurr.end(), + curDimHyp->_subMesh->GetId() ) == theListOfConcurr.end() ) + theListOfConcurr.push_back( curDimHyp->_subMesh->GetId() ); + } +} + +static void unionLists(TListOfInt& theListOfId, + TListOfListOfInt& theListOfListOfId, + const int theIndx ) +{ + TListOfListOfInt::iterator it = theListOfListOfId.begin(); + for ( int i = 0; it != theListOfListOfId.end(); it++, i++ ) { + if ( i < theIndx ) + continue; //skip already treated lists + // check if other list has any same submesh object + TListOfInt& otherListOfId = *it; + if ( find_first_of( theListOfId.begin(), theListOfId.end(), + otherListOfId.begin(), otherListOfId.end() ) == theListOfId.end() ) + continue; + + // union two lists (from source into target) + TListOfInt::iterator it2 = otherListOfId.begin(); + for ( ; it2 != otherListOfId.end(); it2++ ) { + if ( find( theListOfId.begin(), theListOfId.end(), (*it2) ) == theListOfId.end() ) + theListOfId.push_back(*it2); + } + // clear source list + otherListOfId.clear(); + } +} + +//! free memory allocated for dimension-hypothesis objects +static void removeDimHyps( TDimHypList* theArrOfList ) +{ + for (int i = 0; i < 4; i++ ) { + TDimHypList& listOfdimHyp = theArrOfList[i]; + TDimHypList::const_iterator it = listOfdimHyp.begin(); + for ( ; it != listOfdimHyp.end(); it++ ) + delete (*it); + } +} + +//============================================================================= +/*! + * \brief Return submesh objects list in meshing order + */ +//============================================================================= + +SMESH::submesh_array_array* SMESH_Mesh_i::GetMeshOrder() +{ + SMESH::submesh_array_array_var aResult = new SMESH::submesh_array_array(); + + SMESHDS_Mesh* aMeshDS = _impl->GetMeshDS(); + if ( !aMeshDS ) + return aResult._retn(); + + ::SMESH_Mesh& mesh = GetImpl(); + TListOfListOfInt anOrder = mesh.GetMeshOrder(); // is there already defined order? + if ( !anOrder.size() ) { + + // collect submeshes detecting concurrent algorithms and hypothesises + TDimHypList dimHypListArr[4]; // dimHyp list for each shape dimension + + map::iterator i_sm = _mapSubMesh.begin(); + for ( ; i_sm != _mapSubMesh.end(); i_sm++ ) { + ::SMESH_subMesh* sm = (*i_sm).second; + // shape of submesh + const TopoDS_Shape& aSubMeshShape = sm->GetSubShape(); + + // list of assigned hypothesises + const list & hypList = mesh.GetHypothesisList(aSubMeshShape); + // Find out dimensions where the submesh can be concurrent. + // We define the dimensions by algo of each of hypotheses in hypList + list ::const_iterator hypIt = hypList.begin(); + for( ; hypIt != hypList.end(); hypIt++ ) { + SMESH_Algo* anAlgo = 0; + const SMESH_Hypothesis* hyp = dynamic_cast(*hypIt); + if ( hyp->GetType() != SMESHDS_Hypothesis::PARAM_ALGO ) + // hyp it-self is algo + anAlgo = (SMESH_Algo*)dynamic_cast(hyp); + else { + // try to find algorithm with help of sub-shapes + TopExp_Explorer anExp( aSubMeshShape, shapeTypeByDim(hyp->GetDim()) ); + for ( ; !anAlgo && anExp.More(); anExp.Next() ) + anAlgo = mesh.GetGen()->GetAlgo( mesh, anExp.Current() ); + } + if (!anAlgo) + continue; // no assigned algorithm to current submesh + + int dim = anAlgo->GetDim(); // top concurrent dimension (see comment to SMESH_DimHyp) + // the submesh can concurrent at (or lower dims if !anAlgo->NeedDiscreteBoundary()) + + // create instance of dimension-hypothesis for found concurrent dimension(s) and algorithm + for ( int j = anAlgo->NeedDiscreteBoundary() ? dim : 1, jn = dim; j <= jn; j++ ) + addDimHypInstance( j, aSubMeshShape, anAlgo, sm, hypList, dimHypListArr ); + } + } // end iterations on submesh + + // iterate on created dimension-hypotheses and check for concurrents + for ( int i = 0; i < 4; i++ ) { + const list& listOfDimHyp = dimHypListArr[i]; + // check for concurrents in own and other dimensions (step-by-step) + TDimHypList::const_iterator dhIt = listOfDimHyp.begin(); + for ( ; dhIt != listOfDimHyp.end(); dhIt++ ) { + const SMESH_DimHyp* dimHyp = *dhIt; + TListOfInt listOfConcurr; + // looking for concurrents and collect into own list + for ( int j = i; j < 4; j++ ) + findConcurrents( dimHyp, dimHypListArr[j], listOfConcurr ); + // check if any concurrents found + if ( listOfConcurr.size() > 0 ) { + // add own submesh to list of concurrent + listOfConcurr.push_front( dimHyp->_subMesh->GetId() ); + anOrder.push_back( listOfConcurr ); + } + } + } + + removeDimHyps(dimHypListArr); + + // now, minimise 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 + int listIndx = 0; + TListOfListOfInt::iterator listIt = anOrder.begin(); + for(; listIt != anOrder.end(); listIt++, listIndx++ ) + unionLists( *listIt, anOrder, listIndx + 1 ); + } + // convert submesh ids into interface instances + // and dump command into python + convertMeshOrder( anOrder, aResult, false ); + + return aResult._retn(); +} + +//============================================================================= +/*! + * \brief find common submeshes with given submesh + * \param theSubMeshList list of already collected submesh to check + * \param theSubMesh given submesh to intersect with other + * \param theCommonSubMeshes collected common submeshes + */ +//============================================================================= + +static void findCommonSubMesh (list& theSubMeshList, + const SMESH_subMesh* theSubMesh, + set& theCommon ) +{ + if ( !theSubMesh ) + return; + list::const_iterator it = theSubMeshList.begin(); + for ( ; it != theSubMeshList.end(); it++ ) + theSubMesh->FindIntersection( *it, theCommon ); + theSubMeshList.push_back( theSubMesh ); + //theCommon.insert( theSubMesh ); +} + +//============================================================================= +/*! + * \brief Set submesh object order + * \param theSubMeshArray submesh array order + */ +//============================================================================= + +::CORBA::Boolean SMESH_Mesh_i::SetMeshOrder(const SMESH::submesh_array_array& theSubMeshArray) +{ + if ( _preMeshInfo ) + _preMeshInfo->ForgetOrLoad(); + + bool res = false; + ::SMESH_Mesh& mesh = GetImpl(); + + TPythonDump aPythonDump; // prevent dump of called methods + aPythonDump << "isDone = " << _this() << ".SetMeshOrder( [ "; + + TListOfListOfInt subMeshOrder; + for ( int i = 0, n = theSubMeshArray.length(); i < n; i++ ) + { + const SMESH::submesh_array& aSMArray = theSubMeshArray[i]; + TListOfInt subMeshIds; + aPythonDump << "[ "; + // Collect subMeshes which should be clear + // do it list-by-list, because modification of submesh order + // take effect between concurrent submeshes only + set subMeshToClear; + list subMeshList; + for ( int j = 0, jn = aSMArray.length(); j < jn; j++ ) + { + const SMESH::SMESH_subMesh_var subMesh = SMESH::SMESH_subMesh::_duplicate(aSMArray[j]); + if ( j > 0 ) + aPythonDump << ", "; + aPythonDump << subMesh; + subMeshIds.push_back( subMesh->GetId() ); + // detect common parts of submeshes + if ( _mapSubMesh.find(subMesh->GetId()) != _mapSubMesh.end() ) + findCommonSubMesh( subMeshList, _mapSubMesh[ subMesh->GetId() ], subMeshToClear ); + } + aPythonDump << " ]"; + subMeshOrder.push_back( subMeshIds ); + + // clear collected submeshes + set::iterator clrIt = subMeshToClear.begin(); + for ( ; clrIt != subMeshToClear.end(); clrIt++ ) + if ( SMESH_subMesh* sm = (SMESH_subMesh*)*clrIt ) + sm->ComputeStateEngine( SMESH_subMesh::CLEAN ); + } + aPythonDump << " ])"; + + mesh.SetMeshOrder( subMeshOrder ); + res = true; + + return res; +} + +//============================================================================= +/*! + * \brief Convert submesh ids into submesh interfaces + */ +//============================================================================= + +void SMESH_Mesh_i::convertMeshOrder (const TListOfListOfInt& theIdsOrder, + SMESH::submesh_array_array& theResOrder, + const bool theIsDump) +{ + int nbSet = theIdsOrder.size(); + TPythonDump aPythonDump; // prevent dump of called methods + if ( theIsDump ) + aPythonDump << "[ "; + theResOrder.length(nbSet); + TListOfListOfInt::const_iterator it = theIdsOrder.begin(); + int listIndx = 0; + for( ; it != theIdsOrder.end(); it++ ) { + // translate submesh identificators into submesh objects + // takeing into account real number of concurrent lists + const TListOfInt& aSubOrder = (*it); + if (!aSubOrder.size()) + continue; + if ( theIsDump ) + aPythonDump << "[ "; + // convert shape indeces into interfaces + SMESH::submesh_array_var aResSubSet = new SMESH::submesh_array(); + aResSubSet->length(aSubOrder.size()); + TListOfInt::const_iterator subIt = aSubOrder.begin(); + for( int j = 0; subIt != aSubOrder.end(); subIt++ ) { + if ( _mapSubMeshIor.find(*subIt) == _mapSubMeshIor.end() ) + continue; + SMESH::SMESH_subMesh_var subMesh = + SMESH::SMESH_subMesh::_duplicate( _mapSubMeshIor[*subIt] ); + if ( theIsDump ) { + if ( j > 0 ) + aPythonDump << ", "; + aPythonDump << subMesh; + } + aResSubSet[ j++ ] = subMesh; + } + if ( theIsDump ) + aPythonDump << " ]"; + theResOrder[ listIndx++ ] = aResSubSet; + } + // correct number of lists + theResOrder.length( listIndx ); + + if ( theIsDump ) { + // finilise python dump + aPythonDump << " ]"; + aPythonDump << " = " << _this() << ".GetMeshOrder()"; + } +} + +//================================================================================ +// +// Implementation of SMESH_MeshPartDS +// +SMESH_MeshPartDS::SMESH_MeshPartDS(SMESH::SMESH_IDSource_ptr meshPart): + SMESHDS_Mesh( /*meshID=*/-1, /*isEmbeddedMode=*/true) +{ + SMESH::SMESH_Mesh_var mesh = meshPart->GetMesh(); + SMESH_Mesh_i* mesh_i = SMESH::DownCast( mesh ); + + _meshDS = mesh_i->GetImpl().GetMeshDS(); + + SetPersistentId( _meshDS->GetPersistentId() ); + + if ( mesh_i == SMESH::DownCast( meshPart )) + { + // is the whole mesh + myInfo = _meshDS->GetMeshInfo(); // copy mesh info; + // copy groups + set& myGroupSet = const_cast&>( GetGroups() ); + myGroupSet = _meshDS->GetGroups(); + } + else + { + TMeshInfo tmpInfo; + SMESH::long_array_var anIDs = meshPart->GetIDs(); + 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])) + if ( _elements[ SMDSAbs_Node ].insert( n ).second ) + tmpInfo.Add( n ); + } + else + { + for (int i=0; i < anIDs->length(); i++) + if ( const SMDS_MeshElement * e = _meshDS->FindElement(anIDs[i])) + if ( _elements[ e->GetType() ].insert( e ).second ) + { + tmpInfo.Add( e ); + SMDS_ElemIteratorPtr nIt = e->nodesIterator(); + while ( nIt->more() ) + { + const SMDS_MeshNode * n = (const SMDS_MeshNode*) nIt->next(); + if ( _elements[ SMDSAbs_Node ].insert( n ).second ) + tmpInfo.Add( n ); + } + } + } + myInfo = tmpInfo; + + _meshDS = 0; // to enforce iteration on _elements and _nodes + } +} +// ------------------------------------------------------------------------------------- +SMDS_ElemIteratorPtr SMESH_MeshPartDS::elementGeomIterator(SMDSAbs_GeometryType geomType) const +{ + if ( _meshDS ) return _meshDS->elementGeomIterator( geomType ); + + typedef SMDS_SetIterator + , + SMDS_MeshElement::GeomFilter + > TIter; + + SMDSAbs_ElementType type = SMDS_MeshCell::toSmdsType( geomType ); + + return SMDS_ElemIteratorPtr( new TIter( _elements[type].begin(), + _elements[type].end(), + SMDS_MeshElement::GeomFilter( geomType ))); +} +// ------------------------------------------------------------------------------------- +SMDS_ElemIteratorPtr SMESH_MeshPartDS::elementEntityIterator(SMDSAbs_EntityType entity) const +{ + if ( _meshDS ) return _meshDS->elementEntityIterator( entity ); + + typedef SMDS_SetIterator + , + SMDS_MeshElement::EntityFilter + > TIter; + + SMDSAbs_ElementType type = SMDS_MeshCell::toSmdsType( entity ); + + return SMDS_ElemIteratorPtr( new TIter( _elements[type].begin(), + _elements[type].end(), + SMDS_MeshElement::EntityFilter( entity ))); +} +// ------------------------------------------------------------------------------------- +SMDS_ElemIteratorPtr SMESH_MeshPartDS::elementsIterator(SMDSAbs_ElementType type) const +{ + typedef SMDS_SetIterator TIter; + if ( type == SMDSAbs_All && !_meshDS ) + { + typedef vector< SMDS_ElemIteratorPtr > TIterVec; + TIterVec iterVec; + for ( int i = 0; i < SMDSAbs_NbElementTypes; ++i ) + if ( !_elements[i].empty() && i != SMDSAbs_Node ) + iterVec.push_back + ( SMDS_ElemIteratorPtr( new TIter( _elements[i].begin(), _elements[i].end() ))); + + typedef SMDS_IteratorOnIterators TIterOnIters; + return SMDS_ElemIteratorPtr( new TIterOnIters( iterVec )); + } + return _meshDS ? _meshDS->elementsIterator(type) : SMDS_ElemIteratorPtr + ( new TIter( _elements[type].begin(), _elements[type].end() )); +} +// ------------------------------------------------------------------------------------- +#define _GET_ITER_DEFINE( iterType, methName, elem, elemType) \ + iterType SMESH_MeshPartDS::methName( bool idInceasingOrder) const \ + { \ + typedef SMDS_SetIterator TIter; \ + return _meshDS ? _meshDS->methName(idInceasingOrder) : iterType \ + ( new TIter( _elements[elemType].begin(), _elements[elemType].end() )); \ + } +// ------------------------------------------------------------------------------------- +_GET_ITER_DEFINE( SMDS_NodeIteratorPtr, nodesIterator, SMDS_MeshNode, SMDSAbs_Node ) +_GET_ITER_DEFINE( SMDS_EdgeIteratorPtr, edgesIterator, SMDS_MeshEdge, SMDSAbs_Edge ) +_GET_ITER_DEFINE( SMDS_FaceIteratorPtr, facesIterator, SMDS_MeshFace, SMDSAbs_Face ) +_GET_ITER_DEFINE( SMDS_VolumeIteratorPtr, volumesIterator, SMDS_MeshVolume, SMDSAbs_Volume) +#undef _GET_ITER_DEFINE +// +// END Implementation of SMESH_MeshPartDS +// +//================================================================================