X-Git-Url: http://git.salome-platform.org/gitweb/?p=modules%2Fsmesh.git;a=blobdiff_plain;f=src%2FSMESH%2FSMESH_Gen.cxx;h=65e59d98dfdb38e53223261b42b0937910621293;hp=c62e70e32ba4006cb04e535064b53a6e567a90c3;hb=HEAD;hpb=88141f757b048eaa5aae0be49faaf274448bbcaf diff --git a/src/SMESH/SMESH_Gen.cxx b/src/SMESH/SMESH_Gen.cxx index c62e70e32..8b042cf00 100644 --- a/src/SMESH/SMESH_Gen.cxx +++ b/src/SMESH/SMESH_Gen.cxx @@ -1,4 +1,4 @@ -// Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE +// Copyright (C) 2007-2024 CEA, EDF, OPEN CASCADE // // Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS @@ -25,37 +25,94 @@ // Author : Paul RASCLE, EDF // Module : SMESH // - //#define CHRONODEF - +// #include "SMESH_Gen.hxx" +#include "SMESH_DriverMesh.hxx" #include "SMDS_Mesh.hxx" #include "SMDS_MeshElement.hxx" #include "SMDS_MeshNode.hxx" #include "SMESHDS_Document.hxx" #include "SMESH_HypoFilter.hxx" #include "SMESH_Mesh.hxx" +#include "SMESH_SequentialMesh.hxx" +#include "SMESH_ParallelMesh.hxx" #include "SMESH_MesherHelper.hxx" #include "SMESH_subMesh.hxx" -#include "utilities.h" -#include "OpUtil.hxx" -#include "Utils_ExceptHandlers.hxx" +#include +#include -#include +#include #include +#include #include "memoire.h" +#include + +#include +#include #ifdef WIN32 #include #endif +#include + +#ifndef WIN32 +#include +#endif + using namespace std; +#ifndef WIN32 +#include +namespace fs = boost::filesystem; +#endif -//#include +// Environment variable separator +#ifdef WIN32 + #define env_sep ';' +#else + #define env_sep ':' +#endif +namespace +{ + // a structure used to nullify SMESH_Gen field of SMESH_Hypothesis, + // which is needed for SMESH_Hypothesis not deleted before ~SMESH_Gen() + struct _Hyp : public SMESH_Hypothesis + { + void NullifyGen() + { + _gen = 0; + } + }; + + //================================================================================ + /*! + * \brief Fill a map of shapes with all sub-shape of a sub-mesh + */ + //================================================================================ + + TopTools_IndexedMapOfShape * fillAllowed( SMESH_subMesh* sm, + const bool toFill, + TopTools_IndexedMapOfShape * allowedSub ) + { + if ( !toFill || !allowedSub ) + { + return nullptr; + } + if ( allowedSub->IsEmpty() ) + { + allowedSub->ReSize( sm->DependsOn().size() + 1 ); + allowedSub->Add( sm->GetSubShape() ); + for ( const auto & key_sm : sm->DependsOn() ) + allowedSub->Add( key_sm.second->GetSubShape() ); + } + return allowedSub; + } +} //============================================================================= /*! @@ -65,25 +122,12 @@ using namespace std; SMESH_Gen::SMESH_Gen() { + _studyContext = new StudyContextStruct; + _studyContext->myDocument = new SMESHDS_Document(); _localId = 0; _hypId = 0; _segmentation = _nbSegments = 10; - SMDS_Mesh::_meshList.clear(); _compute_canceled = false; - //vtkDebugLeaks::SetExitError(0); -} - -namespace -{ - // a structure used to nullify SMESH_Gen field of SMESH_Hypothesis, - // which is needed for SMESH_Hypothesis not deleted before ~SMESH_Gen() - struct _Hyp : public SMESH_Hypothesis - { - void NullifyGen() - { - _gen = 0; - } - }; } //============================================================================= @@ -94,19 +138,14 @@ namespace SMESH_Gen::~SMESH_Gen() { - std::map < int, StudyContextStruct * >::iterator i_sc = _mapStudyContext.begin(); - for ( ; i_sc != _mapStudyContext.end(); ++i_sc ) + std::map < int, SMESH_Hypothesis * >::iterator i_hyp = _studyContext->mapHypothesis.begin(); + for ( ; i_hyp != _studyContext->mapHypothesis.end(); ++i_hyp ) { - StudyContextStruct* context = i_sc->second; - std::map < int, SMESH_Hypothesis * >::iterator i_hyp = context->mapHypothesis.begin(); - for ( ; i_hyp != context->mapHypothesis.end(); ++i_hyp ) - { - if ( _Hyp* h = static_cast< _Hyp*>( i_hyp->second )) - h->NullifyGen(); - } - delete context->myDocument; - delete context; + if ( _Hyp* h = static_cast< _Hyp*>( i_hyp->second )) + h->NullifyGen(); } + delete _studyContext->myDocument; + delete _studyContext; } //============================================================================= @@ -116,36 +155,313 @@ SMESH_Gen::~SMESH_Gen() */ //============================================================================= -SMESH_Mesh* SMESH_Gen::CreateMesh(int theStudyId, bool theIsEmbeddedMode) - throw(SALOME_Exception) +SMESH_Mesh* SMESH_Gen::CreateMesh(bool theIsEmbeddedMode) { Unexpect aCatch(SalomeException); - // Get studyContext, create it if it doesn't exist, with a SMESHDS_Document - StudyContextStruct *aStudyContext = GetStudyContext(theStudyId); + // create a new SMESH_mesh object + SMESH_Mesh *aMesh = new SMESH_SequentialMesh( + _localId++, + this, + theIsEmbeddedMode, + _studyContext->myDocument); + _studyContext->mapMesh[_localId-1] = aMesh; + + return aMesh; +} + +//============================================================================= +/*! + * Creates a parallel mesh in a study. + * if (theIsEmbeddedMode) { mesh modification commands are not logged } + */ +//============================================================================= + +SMESH_ParallelMesh* SMESH_Gen::CreateParallelMesh(bool theIsEmbeddedMode) +{ + Unexpect aCatch(SalomeException); // create a new SMESH_mesh object - SMESH_Mesh *aMesh = new SMESH_Mesh(_localId++, - theStudyId, + SMESH_ParallelMesh *aMesh = new SMESH_ParallelMesh( + _localId++, this, theIsEmbeddedMode, - aStudyContext->myDocument); - aStudyContext->mapMesh[_localId-1] = aMesh; + _studyContext->myDocument); + _studyContext->mapMesh[_localId-1] = aMesh; return aMesh; } +//============================================================================= +/*! + * Algo to run the computation of all the submeshes of a mesh in sequentila + */ +//============================================================================= + +bool SMESH_Gen::sequentialComputeSubMeshes( + SMESH_Mesh & aMesh, + const TopoDS_Shape & aShape, + const ::MeshDimension aDim, + TSetOfInt* aShapesId /*=0*/, + TopTools_IndexedMapOfShape* allowedSubShapes, + SMESH_subMesh::compute_event &computeEvent, + const bool includeSelf, + const bool complexShapeFirst, + const bool aShapeOnly) +{ + MESSAGE("Sequential Compute of submeshes"); + + bool ret = true; + + SMESH_subMeshIteratorPtr smIt; + SMESH_subMesh *shapeSM = aMesh.GetSubMesh(aShape); + + smIt = shapeSM->getDependsOnIterator(includeSelf, !complexShapeFirst); + while ( smIt->more() ) + { + SMESH_subMesh* smToCompute = smIt->next(); + + // do not mesh vertices of a pseudo shape + const TopoDS_Shape& shape = smToCompute->GetSubShape(); + const TopAbs_ShapeEnum shapeType = shape.ShapeType(); + if ( !aMesh.HasShapeToMesh() && shapeType == TopAbs_VERTEX ) + continue; + + // check for preview dimension limitations + if ( aShapesId && SMESH_Gen::GetShapeDim( shapeType ) > (int)aDim ) + { + // clear compute state not to show previous compute errors + // if preview invoked less dimension less than previous + smToCompute->ComputeStateEngine( SMESH_subMesh::CHECK_COMPUTE_STATE ); + continue; + } + + if (smToCompute->GetComputeState() == SMESH_subMesh::READY_TO_COMPUTE) + { + if (_compute_canceled) + return false; + smToCompute->SetAllowedSubShapes( fillAllowed( shapeSM, aShapeOnly, allowedSubShapes )); + setCurrentSubMesh( smToCompute ); + smToCompute->ComputeStateEngine( computeEvent ); + setCurrentSubMesh( nullptr ); + smToCompute->SetAllowedSubShapes( nullptr ); + } + + // we check all the sub-meshes here and detect if any of them failed to compute + if (smToCompute->GetComputeState() == SMESH_subMesh::FAILED_TO_COMPUTE && + ( shapeType != TopAbs_EDGE || !SMESH_Algo::isDegenerated( TopoDS::Edge( shape )))) + ret = false; + else if ( aShapesId ) + aShapesId->insert( smToCompute->GetId() ); + } + //aMesh.GetMeshDS()->Modified(); + return ret; + +}; + +//============================================================================= +/* + * compute of a submesh + * This function is passed to the thread pool + */ +//============================================================================= +const std::function + compute_function([] (SMESH_subMesh* sm, + SMESH_subMesh::compute_event event, + SMESH_subMesh *shapeSM, + bool aShapeOnly, + TopTools_IndexedMapOfShape *allowedSubShapes, + TSetOfInt* aShapesId) -> void +{ + if (sm->GetComputeState() == SMESH_subMesh::READY_TO_COMPUTE) + { + sm->SetAllowedSubShapes( fillAllowed( shapeSM, aShapeOnly, allowedSubShapes )); + //setCurrentSubMesh( sm ); + sm->ComputeStateEngine(event); + //setCurrentSubMesh( nullptr ); + sm->SetAllowedSubShapes( nullptr ); + } + + if ( aShapesId ) + aShapesId->insert( sm->GetId() ); + +}); + + +//============================================================================= +/* + * Copy a file on remote resource + */ +//============================================================================= + +void SMESH_Gen::send_mesh(SMESH_Mesh& aMesh, std::string file_name) +{ +#ifndef WIN32 + SMESH_ParallelMesh& aParMesh = dynamic_cast(aMesh); + // Calling run_mesher + // Path to mesher script + fs::path send_files = fs::path(std::getenv("SMESH_ROOT_DIR"))/ + fs::path("bin")/ + fs::path("salome")/ + fs::path("send_files.py"); + + std::string s_program="python3"; + std::list params; + params.push_back(send_files.string()); + params.push_back(file_name); + params.push_back("--resource="+aParMesh.GetResource()); + + // log file + fs::path log_file=aParMesh.GetTmpFolder() / fs::path("copy.log"); + QString out_file = log_file.string().c_str(); + + // Building arguments for QProcess + QString program = QString::fromStdString(s_program); + QStringList arguments; + for(auto arg : params){ + arguments << arg.c_str(); + } + + std::string cmd = ""; + cmd += s_program; + for(auto arg: params){ + cmd += " " + arg; + } + MESSAGE("Send files command: "); + MESSAGE(cmd); + + QProcess myProcess; + myProcess.setProcessChannelMode(QProcess::MergedChannels); + myProcess.setStandardOutputFile(out_file); + + myProcess.start(program, arguments); + // Waiting for process to finish (argument -1 make it wait until the end of + // the process otherwise it just waits 30 seconds) + bool finished = myProcess.waitForFinished(-1); + int ret = myProcess.exitCode(); + + if(ret != 0 || !finished){ + // Run crahed + std::string msg = "Issue with send_files: \n"; + msg += "See log for more details: " + log_file.string() + "\n"; + msg += cmd + "\n"; + throw SALOME_Exception(msg); + } +#endif +} + +//============================================================================= +/*! + * Algo to run the computation of all the submeshes of a mesh in parallel + */ +//============================================================================= + +bool SMESH_Gen::parallelComputeSubMeshes( + SMESH_Mesh & aMesh, + const TopoDS_Shape & aShape, + const ::MeshDimension aDim, + TSetOfInt* aShapesId /*=0*/, + TopTools_IndexedMapOfShape* allowedSubShapes, + SMESH_subMesh::compute_event &computeEvent, + const bool includeSelf, + const bool complexShapeFirst, + const bool aShapeOnly) +{ +#ifdef WIN32 + throw SALOME_Exception("ParallelMesh is not working on Windows"); +#else + + bool ret = true; + + SMESH_subMeshIteratorPtr smIt; + SMESH_subMesh *shapeSM = aMesh.GetSubMesh(aShape); + SMESH_ParallelMesh &aParMesh = dynamic_cast(aMesh); + + TopAbs_ShapeEnum previousShapeType = TopAbs_VERTEX; + MESSAGE("Parallel Compute of submeshes"); + + + smIt = shapeSM->getDependsOnIterator(includeSelf, !complexShapeFirst); + while ( smIt->more() ) + { + SMESH_subMesh* smToCompute = smIt->next(); + + // do not mesh vertices of a pseudo shape + const TopoDS_Shape& shape = smToCompute->GetSubShape(); + const TopAbs_ShapeEnum shapeType = shape.ShapeType(); + // Not doing in parallel 1D meshes + if ( !aMesh.HasShapeToMesh() && shapeType == TopAbs_VERTEX ) + continue; + + if (shapeType != previousShapeType) { + // Waiting for all threads for the previous type to end + aMesh.wait(); + + std::string file_name=""; + if (previousShapeType == aParMesh.GetDumpElement()) + file_name = "Mesh"+std::to_string(aParMesh.GetParallelismDimension()-1)+"D.med"; + + if(file_name != "") + { + fs::path mesh_file = fs::path(aParMesh.GetTmpFolder()) / fs::path(file_name); + SMESH_DriverMesh::exportMesh(mesh_file.string(), aMesh, "MESH"); + if (aParMesh.GetParallelismMethod() == ParallelismMethod::MultiNode) { + this->send_mesh(aMesh, mesh_file.string()); + } + } + //Resetting threaded pool info + previousShapeType = shapeType; + } + + // check for preview dimension limitations + if ( aShapesId && SMESH_Gen::GetShapeDim( shapeType ) > (int)aDim ) + { + // clear compute state not to show previous compute errors + // if preview invoked less dimension less than previous + smToCompute->ComputeStateEngine( SMESH_subMesh::CHECK_COMPUTE_STATE ); + continue; + } + // Parallelism is only for 3D parts + if(shapeType!=aMesh.GetParallelElement()){ + compute_function(smToCompute, computeEvent, + shapeSM, aShapeOnly, allowedSubShapes, + aShapesId); + }else{ + boost::asio::post(*(aParMesh.GetPool()), std::bind(compute_function, smToCompute, computeEvent, + shapeSM, aShapeOnly, allowedSubShapes, + aShapesId)); + } + } + + // Waiting for the thread for Solids to finish + aMesh.wait(); + + aMesh.GetMeshDS()->Modified(); + + // Cleanup done here as in Python the destructor is not called + aParMesh.cleanup(); + + return ret; +#endif +}; + //============================================================================= /* * Compute a mesh */ //============================================================================= -bool SMESH_Gen::Compute(SMESH_Mesh & aMesh, - const TopoDS_Shape & aShape, - const int aFlags /*= COMPACT_MESH*/, - const ::MeshDimension aDim /*=::MeshDim_3D*/, - TSetOfInt* aShapesId /*=0*/) +bool SMESH_Gen::Compute(SMESH_Mesh & aMesh, + const TopoDS_Shape & aShape, + const int aFlags /*= COMPACT_MESH*/, + const ::MeshDimension aDim /*=::MeshDim_3D*/, + TSetOfInt* aShapesId /*=0*/, + TopTools_IndexedMapOfShape* anAllowedSubShapes/*=0*/) { MEMOSTAT; @@ -155,7 +471,7 @@ bool SMESH_Gen::Compute(SMESH_Mesh & aMesh, bool ret = true; - SMESH_subMesh *sm = aMesh.GetSubMesh(aShape); + SMESH_subMesh *sm, *shapeSM = aMesh.GetSubMesh(aShape); const bool includeSelf = true; const bool complexShapeFirst = true; @@ -171,60 +487,34 @@ bool SMESH_Gen::Compute(SMESH_Mesh & aMesh, if ( !aMesh.HasShapeToMesh() ) computeEvent = SMESH_subMesh::COMPUTE_NOGEOM; // if several algos and no geometry + TopTools_IndexedMapOfShape *allowedSubShapes = anAllowedSubShapes, allowedSub; + if ( aShapeOnly && !allowedSubShapes ) + allowedSubShapes = &allowedSub; + if ( anUpward ) // is called from the below code in this method { // =============================================== // Mesh all the sub-shapes starting from vertices // =============================================== + ret = aMesh.ComputeSubMeshes( + this, + aMesh, aShape, aDim, + aShapesId, allowedSubShapes, + computeEvent, + includeSelf, + complexShapeFirst, + aShapeOnly); - smIt = sm->getDependsOnIterator(includeSelf, !complexShapeFirst); - while ( smIt->more() ) - { - SMESH_subMesh* smToCompute = smIt->next(); - - // do not mesh vertices of a pseudo shape - const TopoDS_Shape& shape = smToCompute->GetSubShape(); - const TopAbs_ShapeEnum shapeType = shape.ShapeType(); - if ( !aMesh.HasShapeToMesh() && shapeType == TopAbs_VERTEX ) - continue; - - // check for preview dimension limitations - if ( aShapesId && GetShapeDim( shapeType ) > (int)aDim ) - { - // clear compute state not to show previous compute errors - // if preview invoked less dimension less than previous - smToCompute->ComputeStateEngine( SMESH_subMesh::CHECK_COMPUTE_STATE ); - continue; - } - - if (smToCompute->GetComputeState() == SMESH_subMesh::READY_TO_COMPUTE) - { - if (_compute_canceled) - return false; - setCurrentSubMesh( smToCompute ); - smToCompute->ComputeStateEngine( computeEvent ); - setCurrentSubMesh( NULL ); - } - - // we check all the sub-meshes here and detect if any of them failed to compute - if (smToCompute->GetComputeState() == SMESH_subMesh::FAILED_TO_COMPUTE && - ( shapeType != TopAbs_EDGE || !SMESH_Algo::isDegenerated( TopoDS::Edge( shape )))) - ret = false; - else if ( aShapesId ) - aShapesId->insert( smToCompute->GetId() ); - } - //aMesh.GetMeshDS()->Modified(); return ret; } else { // ================================================================ - // Apply algos that do NOT require discreteized boundaries + // Apply algos that do NOT require discretized boundaries // ("all-dimensional") and do NOT support sub-meshes, starting from - // the most complex shapes and collect sub-meshes with algos that + // the most complex shapes and collect sub-meshes with algos that // DO support sub-meshes // ================================================================ - list< SMESH_subMesh* > smWithAlgoSupportingSubmeshes[4]; // for each dim // map to sort sm with same dim algos according to dim of @@ -236,7 +526,7 @@ bool SMESH_Gen::Compute(SMESH_Mesh & aMesh, TopoDS_Shape algoShape; int prevShapeDim = -1, aShapeDim; - smIt = sm->getDependsOnIterator(includeSelf, complexShapeFirst); + smIt = shapeSM->getDependsOnIterator(includeSelf, complexShapeFirst); while ( smIt->more() ) { SMESH_subMesh* smToCompute = smIt->next(); @@ -246,7 +536,7 @@ bool SMESH_Gen::Compute(SMESH_Mesh & aMesh, const TopoDS_Shape& aSubShape = smToCompute->GetSubShape(); aShapeDim = GetShapeDim( aSubShape ); if ( aShapeDim < 1 ) break; - + // check for preview dimension limitations if ( aShapesId && aShapeDim > (int)aDim ) continue; @@ -288,9 +578,11 @@ bool SMESH_Gen::Compute(SMESH_Mesh & aMesh, { if (_compute_canceled) return false; + smToCompute->SetAllowedSubShapes( fillAllowed( shapeSM, aShapeOnly, allowedSubShapes )); setCurrentSubMesh( smToCompute ); smToCompute->ComputeStateEngine( computeEvent ); - setCurrentSubMesh( NULL ); + setCurrentSubMesh( nullptr ); + smToCompute->SetAllowedSubShapes( nullptr ); if ( aShapesId ) aShapesId->insert( smToCompute->GetId() ); } @@ -309,12 +601,43 @@ bool SMESH_Gen::Compute(SMESH_Mesh & aMesh, std::vector< SMESH_subMesh* > smVec; for ( aShapeDim = 0; aShapeDim < 4; ++aShapeDim ) + smVec.insert( smVec.end(), + smWithAlgoSupportingSubmeshes[aShapeDim].begin(), + smWithAlgoSupportingSubmeshes[aShapeDim].end() ); + + // gather sub-shapes with local uni-dimensional algos (bos #29143) + // ---------------------------------------------------------------- + TopTools_MapOfShape uniDimAlgoShapes; + if ( !smVec.empty() ) + { + ShapeToHypothesis::Iterator s2hyps( aMesh.GetMeshDS()->GetHypotheses() ); + for ( ; s2hyps.More(); s2hyps.Next() ) + { + const TopoDS_Shape& s = s2hyps.Key(); + if ( s.IsSame( aMesh.GetShapeToMesh() )) + continue; + for ( auto & hyp : s2hyps.Value() ) + { + if ( const SMESH_Algo* algo = dynamic_cast< const SMESH_Algo*>( hyp )) + if ( algo->NeedDiscreteBoundary() ) + { + TopAbs_ShapeEnum sType; + switch ( algo->GetDim() ) { + case 3: sType = TopAbs_SOLID; break; + case 2: sType = TopAbs_FACE; break; + default: sType = TopAbs_EDGE; break; + } + for ( TopExp_Explorer ex( s2hyps.Key(), sType ); ex.More(); ex.Next() ) + uniDimAlgoShapes.Add( ex.Current() ); + } + } + } + } + { // ------------------------------------------------ // sort list of sub-meshes according to mesh order // ------------------------------------------------ - smVec.assign( smWithAlgoSupportingSubmeshes[ aShapeDim ].begin(), - smWithAlgoSupportingSubmeshes[ aShapeDim ].end() ); aMesh.SortByMeshOrder( smVec ); // ------------------------------------------------------------ @@ -325,70 +648,84 @@ bool SMESH_Gen::Compute(SMESH_Mesh & aMesh, for ( size_t i = 0; i < smVec.size(); ++i ) { sm = smVec[i]; + if ( sm->GetComputeState() != SMESH_subMesh::READY_TO_COMPUTE) + continue; - // get a shape the algo is assigned to - if ( !GetAlgo( sm, & algoShape )) - continue; // strange... + const TopAbs_ShapeEnum shapeType = sm->GetSubShape().ShapeType(); - // look for more local algos - smIt = sm->getDependsOnIterator(!includeSelf, !complexShapeFirst); - while ( smIt->more() ) + if ( !uniDimAlgoShapes.IsEmpty() ) { - SMESH_subMesh* smToCompute = smIt->next(); + // get a shape the algo is assigned to + if ( !GetAlgo( sm, & algoShape )) + continue; // strange... - const TopoDS_Shape& aSubShape = smToCompute->GetSubShape(); - const int aShapeDim = GetShapeDim( aSubShape ); - //if ( aSubShape.ShapeType() == TopAbs_VERTEX ) continue; - if ( aShapeDim < 1 ) continue; + // look for more local algos + if ( SMESH_subMesh* algoSM = aMesh.GetSubMesh( algoShape )) + smIt = algoSM->getDependsOnIterator(!includeSelf, !complexShapeFirst); + else + smIt = sm->getDependsOnIterator(!includeSelf, !complexShapeFirst); - // check for preview dimension limitations - if ( aShapesId && GetShapeDim( aSubShape.ShapeType() ) > (int)aDim ) - continue; + while ( smIt->more() ) + { + SMESH_subMesh* smToCompute = smIt->next(); - SMESH_HypoFilter filter( SMESH_HypoFilter::IsAlgo() ); - filter - .And( SMESH_HypoFilter::IsApplicableTo( aSubShape )) - .And( SMESH_HypoFilter::IsMoreLocalThan( algoShape, aMesh )); + const TopoDS_Shape& aSubShape = smToCompute->GetSubShape(); + const int aShapeDim = GetShapeDim( aSubShape ); + if ( aShapeDim < 1 || aSubShape.ShapeType() <= shapeType ) + continue; + if ( !uniDimAlgoShapes.Contains( aSubShape )) + continue; // [bos #29143] aMesh.GetHypothesis() is too long - if ( SMESH_Algo* subAlgo = (SMESH_Algo*) aMesh.GetHypothesis( smToCompute, filter, true)) - { - if ( ! subAlgo->NeedDiscreteBoundary() ) continue; - SMESH_Hypothesis::Hypothesis_Status status; - if ( subAlgo->CheckHypothesis( aMesh, aSubShape, status )) - // mesh a lower smToCompute starting from vertices - Compute( aMesh, aSubShape, aFlags | SHAPE_ONLY_UPWARD, aDim, aShapesId ); - // Compute( aMesh, aSubShape, aShapeOnly, /*anUpward=*/true, aDim, aShapesId ); + // check for preview dimension limitations + if ( aShapesId && GetShapeDim( aSubShape.ShapeType() ) > (int)aDim ) + continue; + + SMESH_HypoFilter filter( SMESH_HypoFilter::IsAlgo() ); + filter + .And( SMESH_HypoFilter::IsApplicableTo( aSubShape )) + .And( SMESH_HypoFilter::IsMoreLocalThan( algoShape, aMesh )); + + if ( SMESH_Algo* subAlgo = (SMESH_Algo*) aMesh.GetHypothesis( smToCompute, filter, true)) + { + if ( ! subAlgo->NeedDiscreteBoundary() ) continue; + TopTools_IndexedMapOfShape* localAllowed = allowedSubShapes; + if ( localAllowed && localAllowed->IsEmpty() ) + localAllowed = 0; // prevent fillAllowed() with aSubShape + + SMESH_Hypothesis::Hypothesis_Status status; + if ( subAlgo->CheckHypothesis( aMesh, aSubShape, status )) + // mesh a lower smToCompute starting from vertices + Compute( aMesh, aSubShape, aFlags | SHAPE_ONLY_UPWARD, aDim, aShapesId, localAllowed ); + } } } - } - // -------------------------------- - // apply the all-dimensional algos - // -------------------------------- - for ( size_t i = 0; i < smVec.size(); ++i ) - { - sm = smVec[i]; - if ( sm->GetComputeState() == SMESH_subMesh::READY_TO_COMPUTE) + // -------------------------------- + // apply the all-dimensional algo + // -------------------------------- { - const TopAbs_ShapeEnum shapeType = sm->GetSubShape().ShapeType(); + if (_compute_canceled) + return false; // check for preview dimension limitations if ( aShapesId && GetShapeDim( shapeType ) > (int)aDim ) continue; + sm->SetAllowedSubShapes( fillAllowed( shapeSM, aShapeOnly, allowedSubShapes )); - if (_compute_canceled) - return false; setCurrentSubMesh( sm ); sm->ComputeStateEngine( computeEvent ); + setCurrentSubMesh( NULL ); + sm->SetAllowedSubShapes( nullptr ); if ( aShapesId ) aShapesId->insert( sm->GetId() ); } } - } // loop on shape dimensions + } // ----------------------------------------------- // mesh the rest sub-shapes starting from vertices // ----------------------------------------------- - ret = Compute( aMesh, aShape, aFlags | UPWARD, aDim, aShapesId ); + ret = Compute( aMesh, aShape, aFlags | UPWARD, aDim, aShapesId, allowedSubShapes ); + } MEMOSTAT; @@ -402,13 +739,15 @@ bool SMESH_Gen::Compute(SMESH_Mesh & aMesh, SMESH_MesherHelper aHelper( aMesh ); if ( aHelper.IsQuadraticMesh() != SMESH_MesherHelper::LINEAR ) { - aHelper.FixQuadraticElements( sm->GetComputeError() ); + aHelper.FixQuadraticElements( shapeSM->GetComputeError() ); } } if ( aCompactMesh ) - aMesh.GetMeshDS()->compactMesh(); - + { + aMesh.GetMeshDS()->Modified(); + aMesh.GetMeshDS()->CompactMesh(); + } return ret; } @@ -417,8 +756,8 @@ bool SMESH_Gen::Compute(SMESH_Mesh & aMesh, * Prepare Compute a mesh */ //============================================================================= -void SMESH_Gen::PrepareCompute(SMESH_Mesh & aMesh, - const TopoDS_Shape & aShape) +void SMESH_Gen::PrepareCompute(SMESH_Mesh & /*aMesh*/, + const TopoDS_Shape & /*aShape*/) { _compute_canceled = false; resetCurrentSubMesh(); @@ -429,8 +768,8 @@ void SMESH_Gen::PrepareCompute(SMESH_Mesh & aMesh, * Cancel Compute a mesh */ //============================================================================= -void SMESH_Gen::CancelCompute(SMESH_Mesh & aMesh, - const TopoDS_Shape & aShape) +void SMESH_Gen::CancelCompute(SMESH_Mesh & /*aMesh*/, + const TopoDS_Shape & /*aShape*/) { _compute_canceled = true; if ( const SMESH_subMesh* sm = GetCurrentSubMesh() ) @@ -530,7 +869,7 @@ bool SMESH_Gen::Evaluate(SMESH_Mesh & aMesh, const TopoDS_Shape& aSubShape = smToCompute->GetSubShape(); const int aShapeDim = GetShapeDim( aSubShape ); if ( aShapeDim < 1 ) break; - + SMESH_Algo* algo = GetAlgo( smToCompute ); if ( algo && !algo->NeedDiscreteBoundary() ) { if ( algo->SupportSubmeshes() ) { @@ -992,7 +1331,7 @@ std::vector< std::string > SMESH_Gen::GetPluginXMLPaths() while ( from < meshers.size() ) { // cut off plugin name - pos = meshers.find( ':', from ); + pos = meshers.find( env_sep, from ); if ( pos != string::npos ) plugin = meshers.substr( from, pos-from ); else @@ -1017,10 +1356,10 @@ std::vector< std::string > SMESH_Gen::GetPluginXMLPaths() } // get a separator from rootDir - for ( pos = strlen( rootDir )-1; pos >= 0 && sep.empty(); --pos ) - if ( rootDir[pos] == '/' || rootDir[pos] == '\\' ) + for ( int i = strlen( rootDir )-1; i >= 0 && sep.empty(); --i ) + if ( rootDir[i] == '/' || rootDir[i] == '\\' ) { - sep = rootDir[pos]; + sep = rootDir[i]; break; } #ifdef WIN32 @@ -1039,7 +1378,14 @@ std::vector< std::string > SMESH_Gen::GetPluginXMLPaths() xmlPath += sep + plugin + ".xml"; bool fileOK; #ifdef WIN32 - fileOK = (GetFileAttributes(xmlPath.c_str()) != INVALID_FILE_ATTRIBUTES); +# ifdef UNICODE + const wchar_t* path = Kernel_Utils::decode_s(xmlPath); + SMESHUtils::ArrayDeleter deleter( path ); +# else + const char* path = xmlPath.c_str(); +# endif + fileOK = (GetFileAttributes(path) != INVALID_FILE_ATTRIBUTES); + #else fileOK = (access(xmlPath.c_str(), F_OK) == 0); #endif @@ -1149,17 +1495,9 @@ SMESH_Algo *SMESH_Gen::GetAlgo(SMESH_subMesh * aSubMesh, */ //============================================================================= -StudyContextStruct *SMESH_Gen::GetStudyContext(int studyId) +StudyContextStruct *SMESH_Gen::GetStudyContext() { - // Get studyContext, create it if it doesn't exist, with a SMESHDS_Document - - if (_mapStudyContext.find(studyId) == _mapStudyContext.end()) - { - _mapStudyContext[studyId] = new StudyContextStruct; - _mapStudyContext[studyId]->myDocument = new SMESHDS_Document(studyId); - } - StudyContextStruct *myStudyContext = _mapStudyContext[studyId]; - return myStudyContext; + return _studyContext; } //================================================================================ @@ -1186,9 +1524,29 @@ int SMESH_Gen::GetShapeDim(const TopAbs_ShapeEnum & aShapeType) return dim[ aShapeType ]; } +//================================================================================ +/*! + * \brief Return shape dimension by exploding compounds + */ +//================================================================================ + +int SMESH_Gen::GetFlatShapeDim(const TopoDS_Shape &aShape) +{ + int aShapeDim; + if ( aShape.ShapeType() == TopAbs_COMPOUND || + aShape.ShapeType() == TopAbs_COMPSOLID ) + { + TopoDS_Iterator it( aShape ); + aShapeDim = GetFlatShapeDim( it.Value() ); + } + else + aShapeDim = GetShapeDim( aShape ); + return aShapeDim; +} + //============================================================================= /*! - * Genarate a new id unique within this Gen + * Generate a new id unique within this Gen */ //=============================================================================