#include "SMESH_Gen.hxx"
-#include "SMESH_DriverMesh.hxx"
#include "SMDS_Mesh.hxx"
#include "SMDS_MeshElement.hxx"
#include "SMDS_MeshNode.hxx"
#include <TopoDS_Iterator.hxx>
#include "memoire.h"
-#include <functional>
#ifdef WIN32
#include <windows.h>
#include <Basics_Utils.hxx>
using namespace std;
-#include <boost/filesystem.hpp>
-#include <boost/asio.hpp>
-namespace fs = boost::filesystem;
// Environment variable separator
#ifdef WIN32
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("Compute submeshes sequentialy");
-
- 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 && 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<void(SMESH_subMesh*,
- SMESH_subMesh::compute_event,
- SMESH_subMesh*,
- bool,
- TopTools_IndexedMapOfShape *,
- TSetOfInt*)>
- 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() );
-
-});
-
-//=============================================================================
-/*!
- * 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)
-{
-
- bool ret = true;
-
- SMESH_subMeshIteratorPtr smIt;
- SMESH_subMesh *shapeSM = aMesh.GetSubMesh(aShape);
-
- // Pool of thread for computation
- // TODO: move when parallelMesh created
- aMesh.InitPoolThreads();
-
- TopAbs_ShapeEnum previousShapeType = TopAbs_VERTEX;
- int nbThreads = aMesh.GetNbThreads();
- MESSAGE("Compute submeshes with threads: " << nbThreads);
-
-
- 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 and 2D meshes
- if ( !aMesh.HasShapeToMesh() && shapeType == TopAbs_VERTEX )
- continue;
- if(shapeType==TopAbs_FACE||shapeType==TopAbs_EDGE)
- aMesh.SetNbThreads(0);
- else
- aMesh.SetNbThreads(nbThreads);
-
-
- if (shapeType != previousShapeType) {
- // Waiting for all threads for the previous type to end
- aMesh.wait();
-
- std::string file_name;
- switch(previousShapeType){
- case TopAbs_FACE:
- file_name = "Mesh2D.med";
- break;
- case TopAbs_EDGE:
- file_name = "Mesh1D.med";
- break;
- case TopAbs_VERTEX:
- file_name = "Mesh0D.med";
- break;
- case TopAbs_SOLID:
- default:
- file_name = "";
- break;
- }
- if(file_name != "")
- {
- fs::path mesh_file = fs::path(aMesh.tmp_folder) / fs::path(file_name);
- exportMesh(mesh_file.string(), aMesh, "MESH");
-
- }
- //Resetting threaded pool info
- previousShapeType = shapeType;
- }
-
- // 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;
- }
- boost::asio::post(*(aMesh._pool), std::bind(compute_function, smToCompute, computeEvent,
- shapeSM, aShapeOnly, allowedSubShapes,
- aShapesId));
- }
-
- // Waiting for the thread for Solids to finish
- aMesh.wait();
-
- aMesh.GetMeshDS()->Modified();
-
- return ret;
-};
-
-
//=============================================================================
/*
* Compute a mesh
// ===============================================
// Mesh all the sub-shapes starting from vertices
// ===============================================
- if (aMesh.IsParallel())
- ret = parallelComputeSubMeshes(
- aMesh, aShape, aDim,
- aShapesId, allowedSubShapes,
- computeEvent,
- includeSelf,
- complexShapeFirst,
- aShapeOnly);
- else
- ret = sequentialComputeSubMeshes(
- aMesh, aShape, aDim,
- aShapesId, allowedSubShapes,
- computeEvent,
- includeSelf,
- complexShapeFirst,
- aShapeOnly);
+ 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 && 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;
}
else
{
// ================================================================
- // Apply algos that do NOT require discretized boundaries
+ // Apply algos that do NOT require discreteized boundaries
// ("all-dimensional") and do NOT support sub-meshes, starting from
// 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
sm->SetAllowedSubShapes( fillAllowed( shapeSM, aShapeOnly, allowedSubShapes ));
setCurrentSubMesh( sm );
sm->ComputeStateEngine( computeEvent );
-
setCurrentSubMesh( NULL );
sm->SetAllowedSubShapes( nullptr );
if ( aShapesId )
// mesh the rest sub-shapes starting from vertices
// -----------------------------------------------
ret = Compute( aMesh, aShape, aFlags | UPWARD, aDim, aShapesId, allowedSubShapes );
-
}
MEMOSTAT;
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() ) {
