X-Git-Url: http://git.salome-platform.org/gitweb/?p=modules%2Fsmesh.git;a=blobdiff_plain;f=src%2FSMESH%2FSMESH_Mesh.cxx;h=660c3e69f94115e98824b30ace7a2e3f83f7da20;hp=76987e5b1f39032709595b1e2b6129ccc526abbb;hb=1aaacad6986b921cf9d0dc48f4f114af032a9445;hpb=dbd1374aa8aeac32c368b8f6add841e0bd90f807 diff --git a/src/SMESH/SMESH_Mesh.cxx b/src/SMESH/SMESH_Mesh.cxx index 76987e5b1..660c3e69f 100644 --- a/src/SMESH/SMESH_Mesh.cxx +++ b/src/SMESH/SMESH_Mesh.cxx @@ -80,8 +80,6 @@ #include #endif -using namespace std; - // maximum stored group name length in MED file #define MAX_MED_GROUP_NAME_LENGTH 80 @@ -106,7 +104,6 @@ class SMESH_Mesh::SubMeshHolder : public SMESHDS_TSubMeshHolder< SMESH_subMesh > //============================================================================= SMESH_Mesh::SMESH_Mesh(int theLocalId, - int theStudyId, SMESH_Gen* theGen, bool theIsEmbeddedMode, SMESHDS_Document* theDocument): @@ -114,7 +111,6 @@ SMESH_Mesh::SMESH_Mesh(int theLocalId, { if(MYDEBUG) MESSAGE("SMESH_Mesh::SMESH_Mesh(int localId)"); _id = theLocalId; - _studyId = theStudyId; _gen = theGen; _myDocument = theDocument; _myMeshDS = theDocument->NewMesh(theIsEmbeddedMode,theLocalId); @@ -135,7 +131,6 @@ SMESH_Mesh::SMESH_Mesh(int theLocalId, SMESH_Mesh::SMESH_Mesh(): _id(-1), - _studyId(-1), _groupId( 0 ), _nbSubShapes( 0 ), _isShapeToMesh( false ), @@ -192,7 +187,7 @@ SMESH_Mesh::~SMESH_Mesh() sm->ComputeStateEngine( SMESH_subMesh::MESH_ENTITY_REMOVED ); // delete groups - map < int, SMESH_Group * >::iterator itg; + std::map < int, SMESH_Group * >::iterator itg; for (itg = _mapGroup.begin(); itg != _mapGroup.end(); itg++) { SMESH_Group *aGroup = (*itg).second; delete aGroup; @@ -208,7 +203,7 @@ SMESH_Mesh::~SMESH_Mesh() // remove self from studyContext if ( _gen ) { - StudyContextStruct * studyContext = _gen->GetStudyContext( _studyId ); + StudyContextStruct * studyContext = _gen->GetStudyContext(); studyContext->mapMesh.erase( _id ); } if ( _myDocument ) @@ -248,7 +243,7 @@ SMESH_Mesh* SMESH_Mesh::FindMesh( int meshId ) const if ( _id == meshId ) return (SMESH_Mesh*) this; - if ( StudyContextStruct *aStudyContext = _gen->GetStudyContext( _studyId )) + if ( StudyContextStruct *aStudyContext = _gen->GetStudyContext()) { std::map < int, SMESH_Mesh * >::iterator i_m = aStudyContext->mapMesh.find( meshId ); if ( i_m != aStudyContext->mapMesh.end() ) @@ -279,7 +274,7 @@ void SMESH_Mesh::ShapeToMesh(const TopoDS_Shape & aShape) // - sub-meshes _subMeshHolder->DeleteAll(); // - groups on geometry - map ::iterator i_gr = _mapGroup.begin(); + std::map ::iterator i_gr = _mapGroup.begin(); while ( i_gr != _mapGroup.end() ) { if ( dynamic_cast( i_gr->second->GetGroupDS() )) { _myMeshDS->RemoveGroup( i_gr->second->GetGroupDS() ); @@ -364,6 +359,7 @@ double SMESH_Mesh::GetShapeDiagonalSize(const TopoDS_Shape & aShape) bool isPrecise = false; if ( nbFaces < maxNbFaces ) try { + OCC_CATCH_SIGNALS; GEOMUtils::PreciseBoundingBox( aShape, Box ); isPrecise = true; } @@ -450,7 +446,7 @@ void SMESH_Mesh::Clear() void SMESH_Mesh::ClearSubMesh(const int theShapeId) { - // clear sub-meshes; get ready to re-compute as a side-effect + // clear sub-meshes; get ready to re-compute as a side-effect if ( SMESH_subMesh *sm = GetSubMeshContaining( theShapeId ) ) { SMESH_subMeshIteratorPtr smIt = sm->getDependsOnIterator(/*includeSelf=*/true, @@ -458,7 +454,7 @@ void SMESH_Mesh::ClearSubMesh(const int theShapeId) while ( smIt->more() ) { sm = smIt->next(); - TopAbs_ShapeEnum shapeType = sm->GetSubShape().ShapeType(); + TopAbs_ShapeEnum shapeType = sm->GetSubShape().ShapeType(); if ( shapeType == TopAbs_VERTEX || shapeType < TopAbs_SOLID ) // all other shapes depends on vertices so they are already cleaned sm->ComputeStateEngine( SMESH_subMesh::CLEAN ); @@ -470,7 +466,7 @@ void SMESH_Mesh::ClearSubMesh(const int theShapeId) //======================================================================= //function : UNVToMesh -//purpose : +//purpose : //======================================================================= int SMESH_Mesh::UNVToMesh(const char* theFileName) @@ -485,32 +481,19 @@ int SMESH_Mesh::UNVToMesh(const char* theFileName) myReader.SetMeshId(-1); myReader.Perform(); - if ( SMDS_MeshGroup* aGroup = (SMDS_MeshGroup*) myReader.GetGroup() ) + TGroupNamesMap& aGroupNames = myReader.GetGroupNamesMap(); + TGroupNamesMap::iterator gr2names; + int anId = 1 + ( _mapGroup.empty() ? 0 : _mapGroup.rbegin()->first ); + for ( gr2names = aGroupNames.begin(); gr2names != aGroupNames.end(); ++gr2names ) { - TGroupNamesMap aGroupNames = myReader.GetGroupNamesMap(); - aGroup->InitSubGroupsIterator(); - while (aGroup->MoreSubGroups()) - { - SMDS_MeshGroup* aSubGroup = (SMDS_MeshGroup*) aGroup->NextSubGroup(); - string aName = aGroupNames[aSubGroup]; - int aId; - if ( SMESH_Group* aSMESHGroup = AddGroup( aSubGroup->GetType(), aName.c_str(), aId )) - { - SMESHDS_Group* aGroupDS = dynamic_cast( aSMESHGroup->GetGroupDS() ); - if ( aGroupDS ) { - aGroupDS->SetStoreName(aName.c_str()); - aSubGroup->InitIterator(); - const SMDS_MeshElement* aElement = 0; - while ( aSubGroup->More() ) - if (( aElement = aSubGroup->Next() )) - aGroupDS->SMDSGroup().Add( aElement ); - - if (aElement) - aGroupDS->SetType( aElement->GetType() ); - } - } - } + SMDS_MeshGroup* aGroup = gr2names->first; + const std::string& aName = gr2names->second; + SMESHDS_Group* aGroupDS = new SMESHDS_Group( anId++, _myMeshDS, aGroup->GetType() ); + aGroupDS->SMDSGroup() = std::move( *aGroup ); + aGroupDS->SetStoreName( aName.c_str() ); + AddGroup( aGroupDS ); } + return 1; } @@ -533,16 +516,15 @@ int SMESH_Mesh::MEDToMesh(const char* theFileName, const char* theMeshName) Driver_Mesh::Status status = myReader.Perform(); #ifdef _DEBUG_ SMESH_ComputeErrorPtr er = myReader.GetError(); - if ( er && !er->IsOK() ) cout << er->myComment << endl; + if ( er && !er->IsOK() ) std::cout << er->myComment << std::endl; #endif // Reading groups (sub-meshes are out of scope of MED import functionality) - list aGroupNames = myReader.GetGroupNamesAndTypes(); - int anId; - list::iterator name_type = aGroupNames.begin(); + std::list aGroupNames = myReader.GetGroupNamesAndTypes(); + std::list::iterator name_type = aGroupNames.begin(); for ( ; name_type != aGroupNames.end(); name_type++ ) { - SMESH_Group* aGroup = AddGroup( name_type->second, name_type->first.c_str(), anId ); + SMESH_Group* aGroup = AddGroup( name_type->second, name_type->first.c_str() ); if ( aGroup ) { SMESHDS_Group* aGroupDS = dynamic_cast( aGroup->GetGroupDS() ); if ( aGroupDS ) { @@ -551,12 +533,16 @@ int SMESH_Mesh::MEDToMesh(const char* theFileName, const char* theMeshName) } } } + + _myMeshDS->Modified(); + _myMeshDS->CompactMesh(); + return (int) status; } //======================================================================= //function : STLToMesh -//purpose : +//purpose : //======================================================================= std::string SMESH_Mesh::STLToMesh(const char* theFileName) @@ -658,10 +644,10 @@ SMESH_Mesh::AddHypothesis(const TopoDS_Shape & aSubShape, // NOTE: this is not a correct way to check a name of hypothesis, // there should be an attribute of hypothesis saying that it can/can't // be global/local - string hypName = anHyp->GetName(); + std::string hypName = anHyp->GetName(); if ( hypName == "NotConformAllowed" ) { - if(MYDEBUG) MESSAGE( "Hypotesis can be only global" ); + if(MYDEBUG) MESSAGE( "Hypothesis can be only global" ); return SMESH_Hypothesis::HYP_INCOMPATIBLE; } } @@ -697,14 +683,14 @@ SMESH_Mesh::AddHypothesis(const TopoDS_Shape & aSubShape, } } - // check concurent hypotheses on ancestors - if (ret < SMESH_Hypothesis::HYP_CONCURENT && !isGlobalHyp ) + // check concurrent hypotheses on ancestors + if (ret < SMESH_Hypothesis::HYP_CONCURRENT && !isGlobalHyp ) { SMESH_subMeshIteratorPtr smIt = subMesh->getDependsOnIterator(false,false); while ( smIt->more() ) { SMESH_subMesh* sm = smIt->next(); - if ( sm->IsApplicableHypotesis( anHyp )) { - ret2 = sm->CheckConcurentHypothesis( anHyp->GetType() ); + if ( sm->IsApplicableHypothesis( anHyp )) { + ret2 = sm->CheckConcurrentHypothesis( anHyp->GetType() ); if (ret2 > ret) { ret = ret2; break; @@ -734,7 +720,7 @@ SMESH_Mesh::RemoveHypothesis(const TopoDS_Shape & aSubShape, Unexpect aCatch(SalomeException); if(MYDEBUG) MESSAGE("SMESH_Mesh::RemoveHypothesis"); - StudyContextStruct *sc = _gen->GetStudyContext(_studyId); + StudyContextStruct *sc = _gen->GetStudyContext(); if (sc->mapHypothesis.find(anHypId) == sc->mapHypothesis.end()) throw SALOME_Exception(LOCALIZED("hypothesis does not exist")); @@ -751,10 +737,10 @@ SMESH_Mesh::RemoveHypothesis(const TopoDS_Shape & aSubShape, SMESH_Hypothesis::Hypothesis_Status ret = subMesh->AlgoStateEngine(event, anHyp); // there may appear concurrent hyps that were covered by the removed hyp - if (ret < SMESH_Hypothesis::HYP_CONCURENT && - subMesh->IsApplicableHypotesis( anHyp ) && - subMesh->CheckConcurentHypothesis( anHyp->GetType() ) != SMESH_Hypothesis::HYP_OK) - ret = SMESH_Hypothesis::HYP_CONCURENT; + if (ret < SMESH_Hypothesis::HYP_CONCURRENT && + subMesh->IsApplicableHypothesis( anHyp ) && + subMesh->CheckConcurrentHypothesis( anHyp->GetType() ) != SMESH_Hypothesis::HYP_OK) + ret = SMESH_Hypothesis::HYP_CONCURRENT; // sub-shapes if (!SMESH_Hypothesis::IsStatusFatal(ret) && @@ -767,14 +753,14 @@ SMESH_Mesh::RemoveHypothesis(const TopoDS_Shape & aSubShape, if (ret2 > ret) // more severe ret = ret2; - // check concurent hypotheses on ancestors - if (ret < SMESH_Hypothesis::HYP_CONCURENT && !IsMainShape( aSubShape ) ) + // check concurrent hypotheses on ancestors + if (ret < SMESH_Hypothesis::HYP_CONCURRENT && !IsMainShape( aSubShape ) ) { SMESH_subMeshIteratorPtr smIt = subMesh->getDependsOnIterator(false,false); while ( smIt->more() ) { SMESH_subMesh* sm = smIt->next(); - if ( sm->IsApplicableHypotesis( anHyp )) { - ret2 = sm->CheckConcurentHypothesis( anHyp->GetType() ); + if ( sm->IsApplicableHypothesis( anHyp )) { + ret2 = sm->CheckConcurrentHypothesis( anHyp->GetType() ); if (ret2 > ret) { ret = ret2; break; @@ -798,7 +784,7 @@ SMESH_Mesh::RemoveHypothesis(const TopoDS_Shape & aSubShape, */ //============================================================================= -const list& +const std::list& SMESH_Mesh::GetHypothesisList(const TopoDS_Shape & aSubShape) const throw(SALOME_Exception) { @@ -845,8 +831,8 @@ const SMESH_Hypothesis * SMESH_Mesh::GetHypothesis(const SMESH_subMesh * aSubM { const TopoDS_Shape & aSubShape = aSubMesh->GetSubShape(); - const list& hypList = _myMeshDS->GetHypothesis(aSubShape); - list::const_iterator hyp = hypList.begin(); + const std::list& hypList = _myMeshDS->GetHypothesis(aSubShape); + std::list::const_iterator hyp = hypList.begin(); for ( ; hyp != hypList.end(); hyp++ ) { const SMESH_Hypothesis * h = cSMESH_Hyp( *hyp ); if ( aFilter.IsOk( h, aSubShape)) { @@ -862,12 +848,12 @@ const SMESH_Hypothesis * SMESH_Mesh::GetHypothesis(const SMESH_subMesh * aSubM const_cast< std::vector< SMESH_subMesh * > & > ( aSubMesh->GetAncestors() ); SortByMeshOrder( ancestors ); - vector::const_iterator smIt = ancestors.begin(); + std::vector::const_iterator smIt = ancestors.begin(); for ( ; smIt != ancestors.end(); smIt++ ) { const TopoDS_Shape& curSh = (*smIt)->GetSubShape(); - const list& hypList = _myMeshDS->GetHypothesis(curSh); - list::const_iterator hyp = hypList.begin(); + const std::list& hypList = _myMeshDS->GetHypothesis(curSh); + std::list::const_iterator hyp = hypList.begin(); for ( ; hyp != hypList.end(); hyp++ ) { const SMESH_Hypothesis * h = cSMESH_Hyp( *hyp ); if (aFilter.IsOk( h, curSh )) { @@ -891,11 +877,11 @@ const SMESH_Hypothesis * SMESH_Mesh::GetHypothesis(const SMESH_subMesh * aSubM */ //================================================================================ -int SMESH_Mesh::GetHypotheses(const TopoDS_Shape & aSubShape, - const SMESH_HypoFilter& aFilter, - list & aHypList, - const bool andAncestors, - list< TopoDS_Shape > * assignedTo/*=0*/) const +int SMESH_Mesh::GetHypotheses(const TopoDS_Shape & aSubShape, + const SMESH_HypoFilter& aFilter, + std::list & aHypList, + const bool andAncestors, + std::list< TopoDS_Shape > * assignedTo/*=0*/) const { return GetHypotheses( const_cast< SMESH_Mesh* >(this)->GetSubMesh( aSubShape ), aFilter, aHypList, andAncestors, assignedTo ); @@ -912,22 +898,22 @@ int SMESH_Mesh::GetHypotheses(const TopoDS_Shape & aSubShape, */ //================================================================================ -int SMESH_Mesh::GetHypotheses(const SMESH_subMesh * aSubMesh, - const SMESH_HypoFilter& aFilter, - list & aHypList, - const bool andAncestors, - list< TopoDS_Shape > * assignedTo/*=0*/) const +int SMESH_Mesh::GetHypotheses(const SMESH_subMesh * aSubMesh, + const SMESH_HypoFilter& aFilter, + std::list & aHypList, + const bool andAncestors, + std::list< TopoDS_Shape > * assignedTo/*=0*/) const { if ( !aSubMesh ) return 0; - set hypTypes; // to exclude same type hypos from the result list + std::set< std::string > hypTypes; // to exclude same type hypos from the result list int nbHyps = 0; // only one main hypothesis is allowed bool mainHypFound = false; // fill in hypTypes - list::const_iterator hyp; + std::list::const_iterator hyp; for ( hyp = aHypList.begin(); hyp != aHypList.end(); hyp++ ) { if ( hypTypes.insert( (*hyp)->GetName() ).second ) nbHyps++; @@ -938,7 +924,7 @@ int SMESH_Mesh::GetHypotheses(const SMESH_subMesh * aSubMesh, // get hypos from aSubShape { const TopoDS_Shape & aSubShape = aSubMesh->GetSubShape(); - const list& hypList = _myMeshDS->GetHypothesis(aSubShape); + const std::list& hypList = _myMeshDS->GetHypothesis(aSubShape); for ( hyp = hypList.begin(); hyp != hypList.end(); hyp++ ) { const SMESH_Hypothesis* h = cSMESH_Hyp( *hyp ); @@ -963,11 +949,11 @@ int SMESH_Mesh::GetHypotheses(const SMESH_subMesh * aSubMesh, const_cast< std::vector< SMESH_subMesh * > & > ( aSubMesh->GetAncestors() ); SortByMeshOrder( ancestors ); - vector::const_iterator smIt = ancestors.begin(); + std::vector::const_iterator smIt = ancestors.begin(); for ( ; smIt != ancestors.end(); smIt++ ) { const TopoDS_Shape& curSh = (*smIt)->GetSubShape(); - const list& hypList = _myMeshDS->GetHypothesis(curSh); + const std::list& hypList = _myMeshDS->GetHypothesis(curSh); for ( hyp = hypList.begin(); hyp != hypList.end(); hyp++ ) { const SMESH_Hypothesis* h = cSMESH_Hyp( *hyp ); @@ -995,7 +981,7 @@ int SMESH_Mesh::GetHypotheses(const SMESH_subMesh * aSubMesh, SMESH_Hypothesis * SMESH_Mesh::GetHypothesis(const int anHypId) const { - StudyContextStruct *sc = _gen->GetStudyContext(_studyId); + StudyContextStruct *sc = _gen->GetStudyContext(); if (sc->mapHypothesis.find(anHypId) == sc->mapHypothesis.end()) return NULL; @@ -1009,7 +995,7 @@ SMESH_Hypothesis * SMESH_Mesh::GetHypothesis(const int anHypId) const */ //============================================================================= -const list & SMESH_Mesh::GetLog() throw(SALOME_Exception) +const std::list & SMESH_Mesh::GetLog() throw(SALOME_Exception) { Unexpect aCatch(SalomeException); return _myMeshDS->GetScript()->GetCommands(); @@ -1113,11 +1099,11 @@ throw(SALOME_Exception) */ //================================================================================ -list +std::list SMESH_Mesh::GetGroupSubMeshesContaining(const TopoDS_Shape & aSubShape) const throw(SALOME_Exception) { - list found; + std::list found; SMESH_subMesh * subMesh = GetSubMeshContaining(aSubShape); if ( !subMesh ) @@ -1169,7 +1155,7 @@ bool SMESH_Mesh::IsUsedHypothesis(SMESHDS_Hypothesis * anHyp, SMESH_Hypothesis* hyp = static_cast(anHyp); // check if anHyp can be used to mesh aSubMesh - if ( !aSubMesh || !aSubMesh->IsApplicableHypotesis( hyp )) + if ( !aSubMesh || !aSubMesh->IsApplicableHypothesis( hyp )) return false; SMESH_Algo *algo = aSubMesh->GetAlgo(); @@ -1184,7 +1170,7 @@ bool SMESH_Mesh::IsUsedHypothesis(SMESHDS_Hypothesis * anHyp, // look trough hypotheses used by algo const SMESH_HypoFilter* hypoKind; if (( hypoKind = algo->GetCompatibleHypoFilter( !hyp->IsAuxiliary() ))) { - list usedHyps; + std::list usedHyps; if ( GetHypotheses( aSubMesh, *hypoKind, usedHyps, true )) return ( find( usedHyps.begin(), usedHyps.end(), anHyp ) != usedHyps.end() ); } @@ -1205,13 +1191,13 @@ void SMESH_Mesh::NotifySubMeshesHypothesisModification(const SMESH_Hypothesis* h if ( !GetMeshDS()->IsUsedHypothesis( hyp )) return; - if (_callUp) - _callUp->HypothesisModified(); + if (_callUp && hyp) + _callUp->HypothesisModified( hyp->GetID() ); SMESH_Algo *algo; const SMESH_HypoFilter* compatibleHypoKind; - list usedHyps; - vector< SMESH_subMesh* > smToNotify; + std::list usedHyps; + std::vector< SMESH_subMesh* > smToNotify; bool allMeshedEdgesNotified = true; SMESH_subMeshIteratorPtr smIt( _subMeshHolder->GetIterator() ); @@ -1232,7 +1218,7 @@ void SMESH_Mesh::NotifySubMeshesHypothesisModification(const SMESH_Hypothesis* h { const TopoDS_Shape & aSubShape = aSubMesh->GetSubShape(); - if (( aSubMesh->IsApplicableHypotesis( hyp )) && + if (( aSubMesh->IsApplicableHypothesis( hyp )) && ( algo = aSubMesh->GetAlgo() ) && ( compatibleHypoKind = algo->GetCompatibleHypoFilter( !hyp->IsAuxiliary() )) && ( compatibleHypoKind->IsOk( hyp, aSubShape ))) @@ -1348,6 +1334,41 @@ bool SMESH_Mesh::HasModificationsToDiscard() const return false; } +//============================================================================= +/*! + * \brief Return true if all sub-meshes are computed OK - to update an icon + */ +//============================================================================= + +bool SMESH_Mesh::IsComputedOK() +{ + if ( NbNodes() == 0 ) + return false; + + // if ( !HasShapeToMesh() ) + // return true; + + if ( SMESH_subMesh* mainSM = GetSubMeshContaining( 1 )) + { + SMESH_subMeshIteratorPtr smIt = mainSM->getDependsOnIterator(/*includeSelf=*/true); + while ( smIt->more() ) + { + const SMESH_subMesh* sm = smIt->next(); + if ( !sm->IsAlwaysComputed() ) + switch ( sm->GetComputeState() ) + { + case SMESH_subMesh::NOT_READY: + case SMESH_subMesh::COMPUTE_OK: + continue; // ok + case SMESH_subMesh::FAILED_TO_COMPUTE: + case SMESH_subMesh::READY_TO_COMPUTE: + return false; + } + } + } + return true; +} + //================================================================================ /*! * \brief Check if any groups of the same type have equal names @@ -1357,12 +1378,12 @@ bool SMESH_Mesh::HasModificationsToDiscard() const bool SMESH_Mesh::HasDuplicatedGroupNamesMED() { // Corrected for Mantis issue 0020028 - map< SMDSAbs_ElementType, set > aGroupNames; - for ( map::iterator it = _mapGroup.begin(); it != _mapGroup.end(); it++ ) + std::map< SMDSAbs_ElementType, std::set< std::string > > aGroupNames; + for ( std::map::iterator it = _mapGroup.begin(); it != _mapGroup.end(); it++ ) { SMESH_Group* aGroup = it->second; SMDSAbs_ElementType aType = aGroup->GetGroupDS()->GetType(); - string aGroupName = aGroup->GetName(); + std::string aGroupName = aGroup->GetName(); aGroupName.resize( MAX_MED_GROUP_NAME_LENGTH ); if ( !aGroupNames[aType].insert(aGroupName).second ) return true; @@ -1379,37 +1400,46 @@ bool SMESH_Mesh::HasDuplicatedGroupNamesMED() * \param [in] theAutoGroups - boolean parameter for creating/not creating * the groups Group_On_All_Nodes, Group_On_All_Faces, ... ; * the typical use is auto_groups=false. - * \param [in] theVersion - defines the version of format of MED file, that will be created + * \param [in] theMinor - define the minor version (y, where version is x.y.z) of MED file format. + * The theMinor must be between 0 and the current minor version of MED file library. + * If theMinor is equal to -1, the minor version is not changed (default). + * The major version (x, where version is x.y.z) cannot be changed. * \param [in] meshPart - mesh data to export * \param [in] theAutoDimension - if \c true, a space dimension of a MED mesh can be either - * - 1D if all mesh nodes lie on OX coordinate axis, or - * - 2D if all mesh nodes lie on XOY coordinate plane, or - * - 3D in the rest cases. - * If \a theAutoDimension is \c false, the space dimension is always 3. + * - 1D if all mesh nodes lie on OX coordinate axis, or + * - 2D if all mesh nodes lie on XOY coordinate plane, or + * - 3D in the rest cases. + * If \a theAutoDimension is \c false, the space dimension is always 3. * \param [in] theAddODOnVertices - to create 0D elements on all vertices * \param [in] theAllElemsToGroup - to make every element to belong to any group (PAL23413) + * \param [in] ZTolerance - tolerance in Z direction. If Z coordinate of a node is close to zero + * within a given tolerance, the coordinate is set to zero. + * If \a ZTolerance is negative, the node coordinates are kept as is. * \return int - mesh index in the file */ //================================================================================ -void SMESH_Mesh::ExportMED(const char * file, - const char* theMeshName, +void SMESH_Mesh::ExportMED(const char * file, + const char* theMeshName, bool theAutoGroups, int theVersion, const SMESHDS_Mesh* meshPart, bool theAutoDimension, bool theAddODOnVertices, + double theZTolerance, bool theAllElemsToGroup) - throw(SALOME_Exception) +throw(SALOME_Exception) { + MESSAGE("MED_VERSION:"<< theVersion); SMESH_TRY; DriverMED_W_SMESHDS_Mesh myWriter; - myWriter.SetFile ( file, MED::EVersion(theVersion) ); + myWriter.SetFile ( file , theVersion); myWriter.SetMesh ( meshPart ? (SMESHDS_Mesh*) meshPart : _myMeshDS ); myWriter.SetAutoDimension( theAutoDimension ); myWriter.AddODOnVertices ( theAddODOnVertices ); - if ( !theMeshName ) + myWriter.SetZTolerance ( theZTolerance ); + if ( !theMeshName ) myWriter.SetMeshId ( _id ); else { myWriter.SetMeshId ( -1 ); @@ -1431,17 +1461,19 @@ void SMESH_Mesh::ExportMED(const char * file, //set aGroupNames; // Corrected for Mantis issue 0020028 if ( !meshPart ) { - map< SMDSAbs_ElementType, set > aGroupNames; + std::map< SMDSAbs_ElementType, std::set > aGroupNames; char aString [256]; int maxNbIter = 10000; // to guarantee cycle finish - for ( map::iterator it = _mapGroup.begin(); it != _mapGroup.end(); it++ ) { + for ( std::map::iterator it = _mapGroup.begin(); + it != _mapGroup.end(); + it++ ) { SMESH_Group* aGroup = it->second; SMESHDS_GroupBase* aGroupDS = aGroup->GetGroupDS(); if ( aGroupDS ) { SMDSAbs_ElementType aType = aGroupDS->GetType(); - string aGroupName0 = aGroup->GetName(); + std::string aGroupName0 = aGroup->GetName(); aGroupName0.resize(MAX_MED_GROUP_NAME_LENGTH); - string aGroupName = aGroupName0; + std::string aGroupName = aGroupName0; for (int i = 1; !aGroupNames[aType].insert(aGroupName).second && i < maxNbIter; i++) { sprintf(&aString[0], "GR_%d_%s", i, aGroupName0.c_str()); aGroupName = aString; @@ -1475,19 +1507,19 @@ void SMESH_Mesh::ExportSAUV(const char *file, #ifdef WIN32 cmd = "%PYTHONBIN% "; #else - cmd = "python "; + cmd = "python3 "; #endif cmd += "-c \""; cmd += "from medutilities import my_remove ; my_remove(r'" + medfilename + "')"; cmd += "\""; system(cmd.c_str()); - ExportMED(medfilename.c_str(), theMeshName, theAutoGroups, /*theVersion=*/1, + ExportMED(medfilename.c_str(), theMeshName, theAutoGroups, /*minor=*/-1, /*meshPart=*/NULL, /*theAutoDimension=*/false, /*theAddODOnVertices=*/false, - /*theAllElemsToGroup=*/true ); // theAllElemsToGroup is for PAL0023413 + /*zTol=*/-1, /*theAllElemsToGroup=*/true ); // theAllElemsToGroup is for PAL0023413 #ifdef WIN32 cmd = "%PYTHONBIN% "; #else - cmd = "python "; + cmd = "python3 "; #endif cmd += "-c \""; cmd += "from medutilities import convert ; convert(r'" + medfilename + "', 'MED', 'GIBI', 1, r'" + file + "')"; @@ -1496,7 +1528,7 @@ void SMESH_Mesh::ExportSAUV(const char *file, #ifdef WIN32 cmd = "%PYTHONBIN% "; #else - cmd = "python "; + cmd = "python3 "; #endif cmd += "-c \""; cmd += "from medutilities import my_remove ; my_remove(r'" + medfilename + "')"; @@ -1540,11 +1572,12 @@ void SMESH_Mesh::ExportUNV(const char * file, // pass group names to SMESHDS if ( !meshPart ) { - for ( map::iterator it = _mapGroup.begin(); it != _mapGroup.end(); it++ ) { + std::map::iterator it = _mapGroup.begin(); + for ( ; it != _mapGroup.end(); it++ ) { SMESH_Group* aGroup = it->second; SMESHDS_GroupBase* aGroupDS = aGroup->GetGroupDS(); if ( aGroupDS ) { - string aGroupName = aGroup->GetName(); + std::string aGroupName = aGroup->GetName(); aGroupDS->SetStoreName( aGroupName.c_str() ); myWriter.AddGroup( aGroupDS ); } @@ -1588,11 +1621,12 @@ void SMESH_Mesh::ExportCGNS(const char * file, int res = Driver_Mesh::DRS_FAIL; // pass group names to SMESHDS - for ( map::iterator it = _mapGroup.begin(); it != _mapGroup.end(); it++ ) { + std::map::iterator it = _mapGroup.begin(); + for ( ; it != _mapGroup.end(); it++ ) { SMESH_Group* group = it->second; SMESHDS_GroupBase* groupDS = group->GetGroupDS(); if ( groupDS ) { - string groupName = group->GetName(); + std::string groupName = group->GetName(); groupDS->SetStoreName( groupName.c_str() ); } } @@ -1671,7 +1705,7 @@ double SMESH_Mesh::GetComputeProgress() const } catch (...) { #ifdef _DEBUG_ - cerr << "Exception in " << algo->GetName() << "::GetProgress()" << endl; + std::cerr << "Exception in " << algo->GetName() << "::GetProgress()" << std::endl; #endif } if ( 0. < rate && rate < 1.001 ) @@ -1994,16 +2028,17 @@ bool SMESH_Mesh::IsMainShape(const TopoDS_Shape& theShape) const SMESH_Group* SMESH_Mesh::AddGroup (const SMDSAbs_ElementType theType, const char* theName, - int& theId, + const int theId, const TopoDS_Shape& theShape, const SMESH_PredicatePtr& thePredicate) { - if (_mapGroup.count(_groupId)) + if ( _mapGroup.count( theId )) return NULL; - theId = _groupId; - SMESH_Group* aGroup = new SMESH_Group (theId, this, theType, theName, theShape, thePredicate); + int id = ( theId < 0 ) ? _groupId : theId; + SMESH_Group* aGroup = new SMESH_Group ( id, this, theType, theName, theShape, thePredicate ); GetMeshDS()->AddGroup( aGroup->GetGroupDS() ); - _mapGroup[_groupId++] = aGroup; + _mapGroup[ id ] = aGroup; + _groupId = 1 + _mapGroup.rbegin()->first; return aGroup; } @@ -2015,10 +2050,10 @@ SMESH_Group* SMESH_Mesh::AddGroup (const SMDSAbs_ElementType theType, SMESH_Group* SMESH_Mesh::AddGroup (SMESHDS_GroupBase* groupDS) throw(SALOME_Exception) { - if ( !groupDS ) + if ( !groupDS ) throw SALOME_Exception(LOCALIZED ("SMESH_Mesh::AddGroup(): NULL SMESHDS_GroupBase")); - map ::iterator i_g = _mapGroup.find( groupDS->GetID() ); + std::map ::iterator i_g = _mapGroup.find( groupDS->GetID() ); if ( i_g != _mapGroup.end() && i_g->second ) { if ( i_g->second->GetGroupDS() == groupDS ) @@ -2040,15 +2075,15 @@ SMESH_Group* SMESH_Mesh::AddGroup (SMESHDS_GroupBase* groupDS) throw(SALOME_Exce /*! * \brief Creates SMESH_Groups for not wrapped SMESHDS_Groups * \retval bool - true if new SMESH_Groups have been created - * + * */ //================================================================================ bool SMESH_Mesh::SynchronizeGroups() { - const size_t nbGroups = _mapGroup.size(); - const set& groups = _myMeshDS->GetGroups(); - set::const_iterator gIt = groups.begin(); + const size_t nbGroups = _mapGroup.size(); + const std::set& groups = _myMeshDS->GetGroups(); + std::set::const_iterator gIt = groups.begin(); for ( ; gIt != groups.end(); ++gIt ) { SMESHDS_GroupBase* groupDS = (SMESHDS_GroupBase*) *gIt; @@ -2057,7 +2092,7 @@ bool SMESH_Mesh::SynchronizeGroups() _mapGroup[_groupId] = new SMESH_Group( groupDS ); } if ( !_mapGroup.empty() ) - _groupId = _mapGroup.rbegin()->first + 1; + _groupId = 1 + _mapGroup.rbegin()->first; return nbGroups < _mapGroup.size(); } @@ -2070,7 +2105,7 @@ bool SMESH_Mesh::SynchronizeGroups() SMESH_Mesh::GroupIteratorPtr SMESH_Mesh::GetGroups() const { - typedef map TMap; + typedef std::map TMap; return GroupIteratorPtr( new SMDS_mapIterator( _mapGroup )); } @@ -2080,11 +2115,12 @@ SMESH_Mesh::GroupIteratorPtr SMESH_Mesh::GetGroups() const */ //============================================================================= -SMESH_Group* SMESH_Mesh::GetGroup (const int theGroupID) +SMESH_Group* SMESH_Mesh::GetGroup (const int theGroupID) const { - if (_mapGroup.find(theGroupID) == _mapGroup.end()) + std::map ::const_iterator id_grp = _mapGroup.find( theGroupID ); + if ( id_grp == _mapGroup.end() ) return NULL; - return _mapGroup[theGroupID]; + return id_grp->second; } @@ -2094,10 +2130,11 @@ SMESH_Group* SMESH_Mesh::GetGroup (const int theGroupID) */ //============================================================================= -list SMESH_Mesh::GetGroupIds() const +std::list SMESH_Mesh::GetGroupIds() const { - list anIds; - for ( map::const_iterator it = _mapGroup.begin(); it != _mapGroup.end(); it++ ) + std::list anIds; + std::map::const_iterator it = _mapGroup.begin(); + for ( ; it != _mapGroup.end(); it++ ) anIds.push_back( it->first ); return anIds; @@ -2166,7 +2203,7 @@ ostream& SMESH_Mesh::Dump(ostream& save) save << ++clause << ") Total number of polyhedrons:\t" << NbPolyhedrons() << endl << endl; for ( int isQuadratic = 0; isQuadratic < 2; ++isQuadratic ) { - string orderStr = isQuadratic ? "quadratic" : "linear"; + std::string orderStr = isQuadratic ? "quadratic" : "linear"; SMDSAbs_ElementOrder order = isQuadratic ? ORDER_QUADRATIC : ORDER_LINEAR; save << ++clause << ") Total number of " << orderStr << " edges:\t" << NbEdges(order) << endl; @@ -2177,7 +2214,7 @@ ostream& SMESH_Mesh::Dump(ostream& save) save << clause << ".1) Number of " << orderStr << " triangles: \t" << nb3 << endl; save << clause << ".2) Number of " << orderStr << " quadrangles:\t" << nb4 << endl; if ( nb3 + nb4 != NbFaces(order) ) { - map myFaceMap; + std::map myFaceMap; SMDS_FaceIteratorPtr itFaces=_myMeshDS->facesIterator(); while( itFaces->more( ) ) { int nbNodes = itFaces->next()->NbNodes(); @@ -2186,9 +2223,9 @@ ostream& SMESH_Mesh::Dump(ostream& save) myFaceMap[ nbNodes ] = myFaceMap[ nbNodes ] + 1; } save << clause << ".3) Faces in detail: " << endl; - map ::iterator itF; + std::map ::iterator itF; for (itF = myFaceMap.begin(); itF != myFaceMap.end(); itF++) - save << "--> nb nodes: " << itF->first << " - nb elemens:\t" << itF->second << endl; + save << "--> nb nodes: " << itF->first << " - nb elements:\t" << itF->second << endl; } } save << ++clause << ") Total number of " << orderStr << " volumes:\t" << NbVolumes(order) << endl; @@ -2202,7 +2239,7 @@ ostream& SMESH_Mesh::Dump(ostream& save) save << clause << ".3) Number of " << orderStr << " prisms: \t" << nb6 << endl; save << clause << ".4) Number of " << orderStr << " pyramids: \t" << nb5 << endl; if ( nb8 + nb4 + nb5 + nb6 != NbVolumes(order) ) { - map myVolumesMap; + std::map myVolumesMap; SMDS_VolumeIteratorPtr itVolumes=_myMeshDS->volumesIterator(); while( itVolumes->more( ) ) { int nbNodes = itVolumes->next()->NbNodes(); @@ -2211,9 +2248,9 @@ ostream& SMESH_Mesh::Dump(ostream& save) myVolumesMap[ nbNodes ] = myVolumesMap[ nbNodes ] + 1; } save << clause << ".5) Volumes in detail: " << endl; - map ::iterator itV; + std::map ::iterator itV; for (itV = myVolumesMap.begin(); itV != myVolumesMap.end(); itV++) - save << "--> nb nodes: " << itV->first << " - nb elemens:\t" << itV->second << endl; + save << "--> nb nodes: " << itV->first << " - nb elements:\t" << itV->second << endl; } } save << endl; @@ -2241,7 +2278,7 @@ SMDSAbs_ElementType SMESH_Mesh::GetElementType( const int id, const bool iselem SMESH_Group* SMESH_Mesh::ConvertToStandalone ( int theGroupID ) { SMESH_Group* aGroup = 0; - map < int, SMESH_Group * >::iterator itg = _mapGroup.find( theGroupID ); + std::map < int, SMESH_Group * >::iterator itg = _mapGroup.find( theGroupID ); if ( itg == _mapGroup.end() ) return aGroup; @@ -2367,12 +2404,12 @@ bool SMESH_Mesh::SortByMeshOrder(std::vector& theListToSort) con return true; bool res = false; - vector onlyOrderedList, smVec; + std::vector onlyOrderedList, smVec; // collect all ordered submeshes in one list as pointers // and get their positions within theListToSort - typedef vector::iterator TPosInList; - map< int, TPosInList > sortedPos; + typedef std::vector::iterator TPosInList; + std::map< int, TPosInList > sortedPos; TPosInList smBeg = theListToSort.begin(), smEnd = theListToSort.end(); TListOfListOfInt::const_iterator listIdsIt = _mySubMeshOrder.begin(); for( ; listIdsIt != _mySubMeshOrder.end(); listIdsIt++) @@ -2403,8 +2440,9 @@ bool SMESH_Mesh::SortByMeshOrder(std::vector& theListToSort) con { TPosInList smPos = find( smBeg, smEnd, smVec[i] ); if ( smPos != smEnd ) { - onlyOrderedList.push_back( smVec[i] ); - sortedPos[ distance( smBeg, smPos )] = smPos; + sortedPos[ std::distance( smBeg, smPos )] = smPos; + if ( sortedPos.size() > onlyOrderedList.size() ) + onlyOrderedList.push_back( smVec[i] ); } } } @@ -2412,11 +2450,11 @@ bool SMESH_Mesh::SortByMeshOrder(std::vector& theListToSort) con return res; res = true; - vector::iterator onlyBIt = onlyOrderedList.begin(); - vector::iterator onlyEIt = onlyOrderedList.end(); + std::vector::iterator onlyBIt = onlyOrderedList.begin(); + std::vector::iterator onlyEIt = onlyOrderedList.end(); // iterate on ordered sub-meshes and insert them in detected positions - map< int, TPosInList >::iterator i_pos = sortedPos.begin(); + std::map< int, TPosInList >::iterator i_pos = sortedPos.begin(); for ( ; onlyBIt != onlyEIt; ++onlyBIt, ++i_pos ) *(i_pos->second) = *onlyBIt;