X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FSMESH_I%2FSMESH_Mesh_i.cxx;h=721476f831d6885c5f88a1913dd897958c9966d9;hb=252161f517834e1f54ac1c589928e101e0e61c22;hp=07d8f2eddabeedfb9eee10ca8626f3e41191bbf7;hpb=5d42bfdbec5234a2b569e500cc3d8d9a11574278;p=modules%2Fsmesh.git diff --git a/src/SMESH_I/SMESH_Mesh_i.cxx b/src/SMESH_I/SMESH_Mesh_i.cxx index 07d8f2edd..721476f83 100644 --- a/src/SMESH_I/SMESH_Mesh_i.cxx +++ b/src/SMESH_I/SMESH_Mesh_i.cxx @@ -1,4 +1,4 @@ -// Copyright (C) 2007-2011 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 @@ -43,7 +43,9 @@ #include "SMESH_MEDMesh_i.hxx" #include "SMESH_MeshEditor.hxx" #include "SMESH_MeshEditor_i.hxx" +#include "SMESH_MeshPartDS.hxx" #include "SMESH_MesherHelper.hxx" +#include "SMESH_PreMeshInfo.hxx" #include "SMESH_PythonDump.hxx" #include "SMESH_subMesh_i.hxx" @@ -61,15 +63,16 @@ #include #include #include +#include #include #include #include #include #include #include -#include -#include #include +#include +#include // STL Includes #include @@ -87,7 +90,7 @@ 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 @@ -107,8 +110,9 @@ SMESH_Mesh_i::SMESH_Mesh_i( PortableServer::POA_ptr thePOA, MESSAGE("SMESH_Mesh_i"); _impl = NULL; _gen_i = gen_i; - _id = myIdGenerator++; + _id = _idGenerator++; _studyId = studyId; + _preMeshInfo = NULL; } //============================================================================= @@ -162,7 +166,9 @@ SMESH_Mesh_i::~SMESH_Mesh_i() _mapHypo.clear(); #endif - delete _impl; + delete _impl; _impl = NULL; + + if ( _preMeshInfo ) delete _preMeshInfo; _preMeshInfo = NULL; } //============================================================================= @@ -230,6 +236,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 @@ -239,6 +270,9 @@ 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 @@ -259,6 +293,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 ); } @@ -269,7 +306,7 @@ void SMESH_Mesh_i::ClearSubMesh(CORBA::Long ShapeID) //============================================================================= /*! - * + * Convert enum Driver_Mesh::Status to SMESH::DriverMED_ReadStatus */ //============================================================================= @@ -293,6 +330,30 @@ static SMESH::DriverMED_ReadStatus ConvertDriverMEDReadStatus (int theStatus) return res; } +//============================================================================= +/*! + * Convert ::SMESH_ComputeError to SMESH::ComputeError + */ +//============================================================================= + +static SMESH::ComputeError* ConvertComputeError( SMESH_ComputeErrorPtr errorPtr ) +{ + SMESH::ComputeError_var errVar = new SMESH::ComputeError(); + errVar->subShapeID = -1; + errVar->hasBadMesh = false; + + if ( !errorPtr || errorPtr->IsOK() ) + { + errVar->code = SMESH::COMPERR_OK; + } + else + { + errVar->code = ConvertDriverMEDReadStatus( errorPtr->myName ); + errVar->comment = errorPtr->myComment.c_str(); + } + return errVar._retn(); +} + //============================================================================= /*! * ImportMEDFile @@ -322,9 +383,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 ) @@ -332,10 +393,10 @@ 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); } @@ -416,22 +477,44 @@ int SMESH_Mesh_i::ImportSTLFile( const char* theFileName ) return 1; } -//============================================================================= +//================================================================================ /*! - * importMEDFile - * - * Imports mesh data from MED file + * \brief Imports data from a GMF file and returns an error description */ -//============================================================================= +//================================================================================ -// 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(); +SMESH::ComputeError* SMESH_Mesh_i::ImportGMFFile( const char* theFileName ) + throw (SALOME::SALOME_Exception) +{ + SMESH_ComputeErrorPtr error; + try { + error = _impl->GMFToMesh( theFileName ); + } + catch ( std::bad_alloc& exc ) { + error = SMESH_ComputeError::New( Driver_Mesh::DRS_FAIL, "std::bad_alloc raised" ); + } + catch ( Standard_OutOfMemory& exc ) { + error = SMESH_ComputeError::New( Driver_Mesh::DRS_FAIL, "Standard_OutOfMemory raised" ); + } + catch (Standard_Failure& ex) { + error = SMESH_ComputeError::New( Driver_Mesh::DRS_FAIL, ex.DynamicType()->Name() ); + if ( ex.GetMessageString() && strlen( ex.GetMessageString() )) + error->myComment += string(": ") + ex.GetMessageString(); + } + catch ( SALOME_Exception& S_ex ) { + error = SMESH_ComputeError::New( Driver_Mesh::DRS_FAIL, S_ex.what() ); + } + catch ( std::exception& exc ) { + error = SMESH_ComputeError::New( Driver_Mesh::DRS_FAIL, exc.what() ); + } + catch (...) { + error = SMESH_ComputeError::New( Driver_Mesh::DRS_FAIL, "Unknown exception" ); + } -// return status; -// } + CreateGroupServants(); + + return ConvertComputeError( error ); +} //============================================================================= /*! @@ -474,11 +557,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) ) @@ -512,7 +598,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); @@ -563,6 +649,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) ) @@ -594,10 +683,10 @@ SMESH_Mesh_i::removeHypothesis(GEOM::GEOM_Object_ptr aSubShapeObject, SMESH::SMESH_Hypothesis_ptr anHyp) { if(MYDEBUG) MESSAGE("removeHypothesis()"); - // **** proposer liste de subShape (selection multiple) + // **** proposer liste de sub-shape (selection multiple) if (CORBA::is_nil(aSubShapeObject) && HasShapeToMesh()) - THROW_SALOME_CORBA_EXCEPTION("bad subShape reference", SALOME::BAD_PARAM); + THROW_SALOME_CORBA_EXCEPTION("bad Sub-shape reference", SALOME::BAD_PARAM); SMESH::SMESH_Hypothesis_var myHyp = SMESH::SMESH_Hypothesis::_narrow(anHyp); if (CORBA::is_nil(myHyp)) @@ -615,7 +704,7 @@ SMESH_Mesh_i::removeHypothesis(GEOM::GEOM_Object_ptr aSubShapeObject, int hypId = myHyp->GetId(); status = _impl->RemoveHypothesis(myLocSubShape, hypId); -// if ( !SMESH_Hypothesis::IsStatusFatal(status) ) EAP: hyp can be used on many subshapes +// if ( !SMESH_Hypothesis::IsStatusFatal(status) ) EAP: hyp can be used on many sub-shapes // _mapHypo.erase( hypId ); } catch(SALOME_Exception & S_ex) @@ -638,7 +727,7 @@ throw(SALOME::SALOME_Exception) Unexpect aCatch(SALOME_SalomeException); if (MYDEBUG) MESSAGE("GetHypothesisList"); if (_impl->HasShapeToMesh() && 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::ListOfHypothesis_var aList = new SMESH::ListOfHypothesis(); @@ -713,7 +802,7 @@ SMESH::SMESH_subMesh_ptr SMESH_Mesh_i::GetSubMesh(GEOM::GEOM_Object_ptr aSubShap Unexpect aCatch(SALOME_SalomeException); MESSAGE("SMESH_Mesh_i::GetSubMesh"); if (CORBA::is_nil(aSubShapeObject)) - THROW_SALOME_CORBA_EXCEPTION("bad subShape reference", + THROW_SALOME_CORBA_EXCEPTION("bad Sub-shape reference", SALOME::BAD_PARAM); SMESH::SMESH_subMesh_var subMesh; @@ -787,7 +876,9 @@ void SMESH_Mesh_i::RemoveSubMesh( SMESH::SMESH_subMesh_ptr theSubMesh ) } } - removeSubMesh( theSubMesh, aSubShapeObject.in() ); + if ( removeSubMesh( theSubMesh, aSubShapeObject.in() )) + if ( _preMeshInfo ) + _preMeshInfo->ForgetOrLoad(); } //============================================================================= @@ -797,10 +888,13 @@ void SMESH_Mesh_i::RemoveSubMesh( SMESH::SMESH_subMesh_ptr theSubMesh ) //============================================================================= 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 )); @@ -830,6 +924,9 @@ SMESH_Mesh_i::CreateGroupFromGEOM (SMESH::ElementType theElemType, throw(SALOME::SALOME_Exception) { Unexpect aCatch(SALOME_SalomeException); + if ( _preMeshInfo ) + _preMeshInfo->FullLoadFromFile(); + SMESH::SMESH_GroupOnGeom_var aNewGroup; TopoDS_Shape aShape = _gen_i->GeomObjectToShape( theGeomObj ); @@ -870,6 +967,8 @@ SMESH_Mesh_i::CreateGroupFromFilter(SMESH::ElementType theElemType, 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); @@ -935,13 +1034,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; @@ -1034,6 +1137,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() || @@ -1097,6 +1203,9 @@ 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(); @@ -1174,6 +1283,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(); @@ -1226,10 +1338,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(); @@ -1319,9 +1435,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(); @@ -1375,12 +1494,15 @@ 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(); @@ -1490,12 +1612,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 ) @@ -1585,8 +1710,6 @@ SMESH::SMESH_Group_ptr SMESH_Mesh_i::CreateDimGroup( } // 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( anElemList[i] ); @@ -1620,8 +1743,6 @@ SMESH::SMESH_Group_ptr SMESH_Mesh_i::CreateDimGroup( SMESH::long_array_var aResIds = new SMESH::long_array; aResIds->length( aResultIds.size() ); - //NCollection_Map< int >::Iterator aResIter( aResultIds ); - //for ( int i = 0; aResIter.More(); aResIter.Next(), i++ ) for (int i=0; i< aResultIds.size(); i++) aResIds[ i ] = aResultIds[i]; aResGrp->Add( aResIds ); @@ -1748,13 +1869,15 @@ TopoDS_Shape SMESH_Mesh_i::newGroupShape( TGeomGroupData & groupData) return newShape; } -namespace { +namespace +{ //============================================================================= /*! * \brief Storage of shape and index used in CheckGeomGroupModif() */ //============================================================================= - struct TIndexedShape { + struct TIndexedShape + { int _index; TopoDS_Shape _shape; TIndexedShape( int i, const TopoDS_Shape& s ):_index(i), _shape(s) {} @@ -1796,6 +1919,9 @@ void SMESH_Mesh_i::CheckGeomGroupModif() 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) {} @@ -1977,7 +2103,7 @@ void SMESH_Mesh_i::CheckGeomGroupModif() list< SALOMEDS::SObject_var > soToUpdateIcons; if ( newNbEntities != nbEntities ) { - // Add all SObjects with icons + // Add all SObjects with icons to soToUpdateIcons soToUpdateIcons.push_back( _gen_i->ObjectToSObject( study, _this() )); // mesh for (map::iterator i_sm = _mapSubMeshIor.begin(); @@ -2002,6 +2128,9 @@ void SMESH_Mesh_i::CheckGeomGroupModif() 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(); @@ -2128,12 +2257,12 @@ 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()"); + bool isHypChanged = false; if ( theSubMesh->_is_nil() /*|| theSubShapeObject->_is_nil()*/ ) - return; + return isHypChanged; if ( theSubShapeObject->_is_nil() ) // not published shape (IPAL13617) { @@ -2144,6 +2273,7 @@ void SMESH_Mesh_i::removeSubMesh (SMESH::SMESH_subMesh_ptr theSubMesh, 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()); @@ -2154,6 +2284,7 @@ void SMESH_Mesh_i::removeSubMesh (SMESH::SMESH_subMesh_ptr theSubMesh, { 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] ); } @@ -2168,7 +2299,8 @@ void SMESH_Mesh_i::removeSubMesh (SMESH::SMESH_subMesh_ptr theSubMesh, _mapSubMesh.erase(subMeshId); _mapSubMesh_i.erase(subMeshId); _mapSubMeshIor.erase(subMeshId); - if(MYDEBUG) MESSAGE("SMESH_Mesh_i::removeSubMesh() completed"); + + return isHypChanged; } //============================================================================= @@ -2259,7 +2391,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{ @@ -2349,16 +2482,31 @@ CORBA::Long SMESH_Mesh_i::GetStudyId()throw(SALOME::SALOME_Exception) //============================================================================= namespace { - //!< implementation of struct used to call SMESH_Mesh_i::removeGroup() from - // SMESH_Mesh::RemoveGroup() (issue 0020918) - struct TRmGroupCallUp_i : public SMESH_Mesh::TRmGroupCallUp + //!< 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; - TRmGroupCallUp_i(SMESH_Mesh_i* mesh):_mesh(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(); +} + //============================================================================= /*! * @@ -2370,7 +2518,7 @@ void SMESH_Mesh_i::SetImpl(::SMESH_Mesh * impl) if(MYDEBUG) MESSAGE("SMESH_Mesh_i::SetImpl"); _impl = impl; if ( _impl ) - _impl->SetRemoveGroupCallUp( new TRmGroupCallUp_i(this)); + _impl->SetCallUp( new TCallUp_i(this)); } //============================================================================= @@ -2393,6 +2541,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(); @@ -2411,6 +2562,9 @@ 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(); @@ -2429,6 +2583,12 @@ CORBA::Boolean SMESH_Mesh_i::HasModificationsToDiscard() throw(SALOME::SALOME_Ex return _impl->HasModificationsToDiscard(); } +//================================================================================ +/*! + * \brief Returns a random unique color + */ +//================================================================================ + static SALOMEDS::Color getUniqueColor( const std::list& theReservedColors ) { const int MAX_ATTEMPTS = 100; @@ -2461,9 +2621,10 @@ static SALOMEDS::Color getUniqueColor( const std::list& theRese //============================================================================= /*! - * + * 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); @@ -2484,19 +2645,19 @@ void SMESH_Mesh_i::SetAutoColor(CORBA::Boolean theAutoColor) throw(SALOME::SALOM //============================================================================= /*! - * + * 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 */ //============================================================================= @@ -2505,6 +2666,12 @@ CORBA::Boolean SMESH_Mesh_i::HasDuplicatedGroupNamesMED() return _impl->HasDuplicatedGroupNamesMED(); } +//================================================================================ +/*! + * \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); @@ -2548,14 +2715,18 @@ void SMESH_Mesh_i::PrepareForWriting (const char* file, bool overwrite) } } -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); +//================================================================================ +/*! + * \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, overwrite); string aMeshName = "Mesh"; @@ -2590,6 +2761,26 @@ void SMESH_Mesh_i::ExportToMEDX (const char* file, // check names of groups checkGroupNames(); + 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 << " )"; @@ -2602,8 +2793,8 @@ void SMESH_Mesh_i::ExportToMEDX (const char* file, */ //================================================================================ -void SMESH_Mesh_i::ExportToMED (const char* file, - CORBA::Boolean auto_groups, +void SMESH_Mesh_i::ExportToMED (const char* file, + CORBA::Boolean auto_groups, SMESH::MED_VERSION theVersion) throw(SALOME::SALOME_Exception) { @@ -2623,6 +2814,26 @@ void SMESH_Mesh_i::ExportMED (const char* file, 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) +{ + 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 @@ -2633,6 +2844,8 @@ 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 @@ -2654,6 +2867,8 @@ 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 @@ -2675,6 +2890,8 @@ 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 @@ -2686,36 +2903,6 @@ void SMESH_Mesh_i::ExportSTL (const char *file, const bool isascii) _impl->ExportSTL(file, isascii); } -//============================================================================= -/*! - * \brief Class providing SMESHDS_Mesh API to SMESH_IDSource. - * It is used to export a part of mesh as a whole mesh. - */ -class SMESH_MeshPartDS : public SMESHDS_Mesh -{ -public: - SMESH_MeshPartDS(SMESH::SMESH_IDSource_ptr meshPart); - - virtual SMDS_NodeIteratorPtr nodesIterator (bool idInceasingOrder=false) const; - virtual SMDS_0DElementIteratorPtr elements0dIterator(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; - -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 @@ -2730,6 +2917,8 @@ void SMESH_Mesh_i::ExportPartToMED(::SMESH::SMESH_IDSource_ptr meshPart, throw (SALOME::SALOME_Exception) { Unexpect aCatch(SALOME_SalomeException); + if ( _preMeshInfo ) + _preMeshInfo->FullLoadFromFile(); PrepareForWriting(file, overwrite); @@ -2760,6 +2949,8 @@ void SMESH_Mesh_i::ExportPartToDAT(::SMESH::SMESH_IDSource_ptr meshPart, throw (SALOME::SALOME_Exception) { Unexpect aCatch(SALOME_SalomeException); + if ( _preMeshInfo ) + _preMeshInfo->FullLoadFromFile(); PrepareForWriting(file); @@ -2779,6 +2970,8 @@ void SMESH_Mesh_i::ExportPartToUNV(::SMESH::SMESH_IDSource_ptr meshPart, throw (SALOME::SALOME_Exception) { Unexpect aCatch(SALOME_SalomeException); + if ( _preMeshInfo ) + _preMeshInfo->FullLoadFromFile(); PrepareForWriting(file); @@ -2799,6 +2992,8 @@ void SMESH_Mesh_i::ExportPartToSTL(::SMESH::SMESH_IDSource_ptr meshPart, throw (SALOME::SALOME_Exception) { Unexpect aCatch(SALOME_SalomeException); + if ( _preMeshInfo ) + _preMeshInfo->FullLoadFromFile(); PrepareForWriting(file); @@ -2822,6 +3017,8 @@ void SMESH_Mesh_i::ExportCGNS(::SMESH::SMESH_IDSource_ptr meshPart, { #ifdef WITH_CGNS Unexpect aCatch(SALOME_SalomeException); + if ( _preMeshInfo ) + _preMeshInfo->FullLoadFromFile(); PrepareForWriting(file,overwrite); @@ -2835,61 +3032,89 @@ void SMESH_Mesh_i::ExportCGNS(::SMESH::SMESH_IDSource_ptr meshPart, #endif } +//================================================================================ +/*! + * \brief Export a part of mesh to a GMF file + */ +//================================================================================ + +void SMESH_Mesh_i::ExportGMF(::SMESH::SMESH_IDSource_ptr meshPart, + const char* file) + throw (SALOME::SALOME_Exception) +{ + Unexpect aCatch(SALOME_SalomeException); + if ( _preMeshInfo ) + _preMeshInfo->FullLoadFromFile(); + + PrepareForWriting(file,/*overwrite=*/true); + + SMESH_MeshPartDS partDS( meshPart ); + _impl->ExportGMF(file, &partDS); + + TPythonDump() << _this() << ".ExportGMF( " << meshPart<< ", r'" << file << "')"; +} + //============================================================================= /*! - * + * 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); - return Nb0DElements() + NbEdges() + NbFaces() + NbVolumes(); + 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(); } @@ -2897,35 +3122,56 @@ 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(); } @@ -2933,6 +3179,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); } @@ -2940,6 +3189,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); } @@ -2947,47 +3199,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(); } @@ -2995,6 +3283,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); } @@ -3002,6 +3293,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); } @@ -3009,6 +3303,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); } @@ -3016,6 +3313,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); } @@ -3023,14 +3323,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); @@ -3039,9 +3343,10 @@ CORBA::Long SMESH_Mesh_i::NbSubMesh()throw(SALOME::SALOME_Exception) //============================================================================= /*! - * + * Dumps mesh into a string */ //============================================================================= + char* SMESH_Mesh_i::Dump() { ostringstream os; @@ -3051,29 +3356,18 @@ char* SMESH_Mesh_i::Dump() //============================================================================= /*! - * + * 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 */ //============================================================================= @@ -3081,7 +3375,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(); @@ -3100,7 +3396,7 @@ SMESH::long_array* SMESH_Mesh_i::GetElementsId() //============================================================================= /*! - * + * Returns ids of all elements of given type */ //============================================================================= @@ -3108,7 +3404,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(); @@ -3141,7 +3439,7 @@ SMESH::long_array* SMESH_Mesh_i::GetElementsByType( SMESH::ElementType theElemTy //============================================================================= /*! - * + * Returns ids of all nodes */ //============================================================================= @@ -3149,7 +3447,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(); @@ -3174,6 +3474,9 @@ 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 ); } @@ -3186,6 +3489,9 @@ SMESH::ElementType SMESH_Mesh_i::GetElementType( const CORBA::Long id, const boo 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 ); @@ -3201,6 +3507,9 @@ SMESH::EntityType SMESH_Mesh_i::GetElementGeomType( const CORBA::Long id ) 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); @@ -3228,9 +3537,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); @@ -3268,15 +3581,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; @@ -3294,12 +3610,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 ) @@ -3344,6 +3666,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 ) @@ -3379,6 +3704,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; @@ -3431,6 +3759,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; @@ -3455,6 +3786,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; @@ -3483,6 +3817,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 @@ -3502,6 +3839,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); @@ -3518,6 +3858,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() ) { @@ -3540,6 +3883,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 @@ -3563,6 +3909,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; @@ -3590,6 +3939,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); @@ -3606,6 +3958,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); @@ -3621,6 +3976,9 @@ CORBA::Long SMESH_Mesh_i::ElemNbFaces(const CORBA::Long id) 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() ) { @@ -3646,6 +4004,9 @@ SMESH::long_array* SMESH_Mesh_i::GetElemFaceNodes(CORBA::Long elemId, 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() ) { @@ -3655,8 +4016,8 @@ CORBA::Long SMESH_Mesh_i::FindElementByNodes(const SMESH::long_array& nodes) return elemID; const SMDS_MeshElement* elem = mesh->FindElement( nn ); - if ( !elem && ( _impl->NbEdges( ORDER_QUADRATIC ) || - _impl->NbFaces( ORDER_QUADRATIC ) || + if ( !elem && ( _impl->NbEdges ( ORDER_QUADRATIC ) || + _impl->NbFaces ( ORDER_QUADRATIC ) || _impl->NbVolumes( ORDER_QUADRATIC ))) elem = mesh->FindElement( nn, SMDSAbs_All, /*noMedium=*/true ); @@ -3673,6 +4034,9 @@ CORBA::Long SMESH_Mesh_i::FindElementByNodes(const SMESH::long_array& nodes) 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); @@ -3689,6 +4053,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); @@ -3696,6 +4063,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; +} //============================================================================= /*! @@ -3705,6 +4089,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 ) @@ -3752,7 +4139,7 @@ SMESH::double_array* SMESH_Mesh_i::BaryCenter(const CORBA::Long id) */ //============================================================================= -void SMESH_Mesh_i::CreateGroupServants() +void SMESH_Mesh_i::CreateGroupServants() { SALOMEDS::Study_ptr aStudy = _gen_i->GetCurrentStudy(); @@ -3842,7 +4229,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 = ""; @@ -3853,7 +4240,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 */ //============================================================================= @@ -3896,8 +4283,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); } //============================================================================= @@ -3943,18 +4331,18 @@ SMESH::string_array* SMESH_Mesh_i::GetLastParameters() 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( 4 ); + 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->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(); @@ -3970,13 +4358,28 @@ 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++) @@ -3995,6 +4398,7 @@ SMESH::long_array* SMESH_Mesh_i::GetMeshInfo() * \brief Collect statistic of mesh elements given by iterator */ //============================================================================= + void SMESH_Mesh_i::CollectMeshInfo(const SMDS_ElemIteratorPtr theItr, SMESH::long_array& theInfo) { @@ -4004,11 +4408,14 @@ void SMESH_Mesh_i::CollectMeshInfo(const SMDS_ElemIteratorPtr theItr, } //============================================================================= +namespace // Finding concurrent hypotheses +//============================================================================= +{ + /*! * \brief mapping of mesh dimension into shape type */ -//============================================================================= -static TopAbs_ShapeEnum shapeTypeByDim(const int theDim) +TopAbs_ShapeEnum shapeTypeByDim(const int theDim) { TopAbs_ShapeEnum aType = TopAbs_SOLID; switch ( theDim ) { @@ -4021,7 +4428,7 @@ static TopAbs_ShapeEnum shapeTypeByDim(const int theDim) return aType; } -//============================================================================= +//----------------------------------------------------------------------------- /*! * \brief Internal structure used to find concurent submeshes * @@ -4030,8 +4437,6 @@ static TopAbs_ShapeEnum shapeTypeByDim(const int theDim) * with another submesh. In other words, it is dimension of a hypothesis assigned * to submesh. */ -//============================================================================= - class SMESH_DimHyp { public: @@ -4040,8 +4445,14 @@ class SMESH_DimHyp int _ownDim; //!< dimension of shape of _subMesh (>=_dim) TopTools_MapOfShape _shapeMap; SMESH_subMesh* _subMesh; - list _hypothesises; //!< algo is first, then its parameters + list _hypotheses; //!< algo is first, then its parameters + + //----------------------------------------------------------------------------- + // Return the algorithm + const SMESH_Algo* GetAlgo() const + { return _hypotheses.empty() ? 0 : dynamic_cast( _hypotheses.front() ); } + //----------------------------------------------------------------------------- //! Constructors SMESH_DimHyp(const SMESH_subMesh* theSubMesh, const int theDim, @@ -4051,8 +4462,9 @@ class SMESH_DimHyp SetShape( theDim, theShape ); } + //----------------------------------------------------------------------------- //! set shape - void SetShape(const int theDim, + void SetShape(const int theDim, const TopoDS_Shape& theShape) { _dim = theDim; @@ -4066,18 +4478,20 @@ class SMESH_DimHyp } } - //! Check sharing of sub shapes + //----------------------------------------------------------------------------- + //! 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() ) { + 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 subshape with concurrent dimension + // check for sub-shape with concurrent dimension TopExp_Explorer anExp( aSubSh, theType ); for ( ; !isShared && anExp.More(); anExp.Next() ) isShared = theToFind.Contains( anExp.Current() ); @@ -4085,11 +4499,13 @@ class SMESH_DimHyp return isShared; } + //----------------------------------------------------------------------------- //! check algorithms static bool checkAlgo(const SMESHDS_Hypothesis* theA1, const SMESHDS_Hypothesis* theA2) { - if ( theA1->GetType() == SMESHDS_Hypothesis::PARAM_ALGO || + if ( !theA1 || !theA2 || + 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) @@ -4097,17 +4513,20 @@ class SMESH_DimHyp } - //! Check if subshape hypotheses are concurrent + //----------------------------------------------------------------------------- + //! Check if sub-shape hypotheses are concurrent bool IsConcurrent(const SMESH_DimHyp* theOther) const { if ( _subMesh == theOther->_subMesh ) - return false; // same subshape - should not be + 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()); + 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; @@ -4119,65 +4538,102 @@ class SMESH_DimHyp return false; // check algorithms to be same - if (!checkAlgo( _hypothesises.front(), theOther->_hypothesises.front() )) - return true; // different algorithms - + if ( !checkAlgo( this->GetAlgo(), theOther->GetAlgo() )) + return true; // different algorithms -> concurrency ! + // 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 ) + // pointers should be same, because it is referened from mesh hypothesis partition + list ::const_iterator hypIt = _hypotheses.begin(); + list ::const_iterator otheEndIt = theOther->_hypotheses.end(); + for ( hypIt++ /*skip first as algo*/; hypIt != _hypotheses.end(); hypIt++ ) + if ( find( theOther->_hypotheses.begin(), otheEndIt, *hypIt ) != otheEndIt ) nbSame++; // the submeshes are concurrent if their algorithms has different parameters - return nbSame != theOther->_hypothesises.size() - 1; + return nbSame != theOther->_hypotheses.size() - 1; + } + + // Return true if algorithm of this SMESH_DimHyp is used if no + // sub-mesh order is imposed by the user + bool IsHigherPriorityThan( const SMESH_DimHyp* theOther ) const + { + // NeedDiscreteBoundary() algo has a higher priority + if ( this ->GetAlgo()->NeedDiscreteBoundary() != + theOther->GetAlgo()->NeedDiscreteBoundary() ) + return !this->GetAlgo()->NeedDiscreteBoundary(); + + return ( this->_subMesh->GetId() < theOther->_subMesh->GetId() ); } }; // end of SMESH_DimHyp +//----------------------------------------------------------------------------- -typedef list TDimHypList; +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 ) +//----------------------------------------------------------------------------- + +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 ); + dimHyp->_hypotheses.push_front(theAlgo); 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 ); + SMESH_DimHyp* dimHyp = const_cast( listOfdimHyp.back() ); + dimHyp->_hypotheses.insert( dimHyp->_hypotheses.end(), + theHypList.begin(), theHypList.end() ); +} + +//----------------------------------------------------------------------------- +void addInOrderOfPriority( const SMESH_DimHyp* theDimHyp, + TDimHypList& theListOfConcurr) +{ + if ( theListOfConcurr.empty() ) + { + theListOfConcurr.push_back( theDimHyp ); + } + else + { + TDimHypList::iterator hypIt = theListOfConcurr.begin(); + while ( hypIt != theListOfConcurr.end() && + !theDimHyp->IsHigherPriorityThan( *hypIt )) + ++hypIt; + theListOfConcurr.insert( hypIt, theDimHyp ); + } } -static void findConcurrents(const SMESH_DimHyp* theDimHyp, - const TDimHypList& theListOfDimHyp, - TListOfInt& theListOfConcurr ) +//----------------------------------------------------------------------------- +void findConcurrents(const SMESH_DimHyp* theDimHyp, + const TDimHypList& theListOfDimHyp, + TDimHypList& theListOfConcurrHyp, + set& theSetOfConcurrId ) { TDimHypList::const_reverse_iterator rIt = theListOfDimHyp.rbegin(); - for ( ; rIt != theListOfDimHyp.rend(); rIt++ ) { + 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() ); + + if ( theDimHyp->IsConcurrent( curDimHyp ) && + theSetOfConcurrId.insert( curDimHyp->_subMesh->GetId() ).second ) + { + addInOrderOfPriority( curDimHyp, theListOfConcurrHyp ); + } } } -static void unionLists(TListOfInt& theListOfId, - TListOfListOfInt& theListOfListOfId, - const int theIndx ) +//----------------------------------------------------------------------------- +void unionLists(TListOfInt& theListOfId, + TListOfListOfInt& theListOfListOfId, + const int theIndx ) { TListOfListOfInt::iterator it = theListOfListOfId.begin(); for ( int i = 0; it != theListOfListOfId.end(); it++, i++ ) { @@ -4199,9 +4655,10 @@ static void unionLists(TListOfInt& theListOfId, otherListOfId.clear(); } } +//----------------------------------------------------------------------------- //! free memory allocated for dimension-hypothesis objects -static void removeDimHyps( TDimHypList* theArrOfList ) +void removeDimHyps( TDimHypList* theArrOfList ) { for (int i = 0; i < 4; i++ ) { TDimHypList& listOfdimHyp = theArrOfList[i]; @@ -4211,6 +4668,28 @@ static void removeDimHyps( TDimHypList* theArrOfList ) } } +//----------------------------------------------------------------------------- +/*! + * \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 + */ +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 ); +} + +} // namespace + //============================================================================= /*! * \brief Return submesh objects list in meshing order @@ -4229,7 +4708,7 @@ SMESH::submesh_array_array* SMESH_Mesh_i::GetMeshOrder() TListOfListOfInt anOrder = mesh.GetMeshOrder(); // is there already defined order? if ( !anOrder.size() ) { - // collect submeshes detecting concurrent algorithms and hypothesises + // collect submeshes and detect concurrent algorithms and hypothesises TDimHypList dimHypListArr[4]; // dimHyp list for each shape dimension map::iterator i_sm = _mapSubMesh.begin(); @@ -4237,7 +4716,7 @@ SMESH::submesh_array_array* SMESH_Mesh_i::GetMeshOrder() ::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. @@ -4250,39 +4729,44 @@ SMESH::submesh_array_array* SMESH_Mesh_i::GetMeshOrder() // hyp it-self is algo anAlgo = (SMESH_Algo*)dynamic_cast(hyp); else { - // try to find algorithm with help of subshapes + // 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 + continue; // no algorithm assigned to a current submesh int dim = anAlgo->GetDim(); // top concurrent dimension (see comment to SMESH_DimHyp) - // the submesh can concurrent at (or lower dims if !anAlgo->NeedDescretBoundary()) + // 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->NeedDescretBoundary() ? dim : 1, jn = dim; j <= jn; j++ ) + 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]; + const TDimHypList& 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; + TDimHypList listOfConcurr; + set setOfConcurrIds; // looking for concurrents and collect into own list for ( int j = i; j < 4; j++ ) - findConcurrents( dimHyp, dimHypListArr[j], listOfConcurr ); + findConcurrents( dimHyp, dimHypListArr[j], listOfConcurr, setOfConcurrIds ); // 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 ); + addInOrderOfPriority( dimHyp, listOfConcurr ); + list listOfConcurrIds; + TDimHypList::iterator hypIt = listOfConcurr.begin(); + for ( ; hypIt != listOfConcurr.end(); ++hypIt ) + listOfConcurrIds.push_back( (*hypIt)->_subMesh->GetId() ); + anOrder.push_back( listOfConcurrIds ); } } } @@ -4290,9 +4774,9 @@ SMESH::submesh_array_array* SMESH_Mesh_i::GetMeshOrder() removeDimHyps(dimHypListArr); // now, minimise the number of concurrent groups - // Here we assume that lists of submhes can has same submesh + // Here we assume that lists of submeshes can have same submesh // in case of multi-dimension algorithms, as result - // list with common submesh have to be union into one list + // 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++ ) @@ -4300,33 +4784,11 @@ SMESH::submesh_array_array* SMESH_Mesh_i::GetMeshOrder() } // convert submesh ids into interface instances // and dump command into python - convertMeshOrder( anOrder, aResult, true ); + 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 @@ -4336,6 +4798,9 @@ static void findCommonSubMesh (list& theSubMeshList, ::CORBA::Boolean SMESH_Mesh_i::SetMeshOrder(const SMESH::submesh_array_array& theSubMeshArray) { + if ( _preMeshInfo ) + _preMeshInfo->ForgetOrLoad(); + bool res = false; ::SMESH_Mesh& mesh = GetImpl(); @@ -4369,12 +4834,9 @@ static void findCommonSubMesh (list& theSubMeshList, // clear collected submeshes set::iterator clrIt = subMeshToClear.begin(); - for ( ; clrIt != subMeshToClear.end(); clrIt++ ) { - SMESH_subMesh* sm = (SMESH_subMesh*)*clrIt; - if ( sm ) - sm->ComputeStateEngine( SMESH_subMesh::CLEAN ); - // ClearSubMesh( *clrIt ); - } + for ( ; clrIt != subMeshToClear.end(); clrIt++ ) + if ( SMESH_subMesh* sm = (SMESH_subMesh*)*clrIt ) + sm->ComputeStateEngine( SMESH_subMesh::CLEAN ); } aPythonDump << " ])"; @@ -4444,7 +4906,7 @@ void SMESH_Mesh_i::convertMeshOrder (const TListOfListOfInt& theIdsOrder, // Implementation of SMESH_MeshPartDS // SMESH_MeshPartDS::SMESH_MeshPartDS(SMESH::SMESH_IDSource_ptr meshPart): - SMESHDS_Mesh( /*theMeshID=*/-1, /*theIsEmbeddedMode=*/true) + SMESHDS_Mesh( /*meshID=*/-1, /*isEmbeddedMode=*/true) { SMESH::SMESH_Mesh_var mesh = meshPart->GetMesh(); SMESH_Mesh_i* mesh_i = SMESH::DownCast( mesh ); @@ -4494,6 +4956,64 @@ SMESH_MeshPartDS::SMESH_MeshPartDS(SMESH::SMESH_IDSource_ptr meshPart): _meshDS = 0; // to enforce iteration on _elements and _nodes } } +// ------------------------------------------------------------------------------------- +SMESH_MeshPartDS::SMESH_MeshPartDS(const std::list< const SMDS_MeshElement* > & meshPart): + SMESHDS_Mesh( /*meshID=*/-1, /*isEmbeddedMode=*/true), _meshDS(0) +{ + TMeshInfo tmpInfo; + list< const SMDS_MeshElement* >::const_iterator partIt = meshPart.begin(); + for ( ; partIt != meshPart.end(); ++partIt ) + if ( const SMDS_MeshElement * e = *partIt ) + 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; +} +// ------------------------------------------------------------------------------------- +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; @@ -4512,6 +5032,7 @@ SMDS_ElemIteratorPtr SMESH_MeshPartDS::elementsIterator(SMDSAbs_ElementType type 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 \ { \ @@ -4519,8 +5040,8 @@ SMDS_ElemIteratorPtr SMESH_MeshPartDS::elementsIterator(SMDSAbs_ElementType type 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_0DElementIteratorPtr, elements0dIterator, SMDS_Mesh0DElement, SMDSAbs_0DElement) _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) @@ -4529,3 +5050,5 @@ _GET_ITER_DEFINE( SMDS_VolumeIteratorPtr, volumesIterator, SMDS_MeshVolume, SMDS // END Implementation of SMESH_MeshPartDS // //================================================================================ + +