-// Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2022 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
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMESH : implementaion of SMESH idl descriptions
+// SMESH SMESH : implementation of SMESH idl descriptions
// File : SMESH_Gen.cxx
// Author : Paul RASCLE, EDF
// Module : SMESH
#include "SMESH_Gen.hxx"
+#include "SMESH_DriverMesh.hxx"
#include "SMDS_Mesh.hxx"
#include "SMDS_MeshElement.hxx"
#include "SMDS_MeshNode.hxx"
#include "SMESH_MesherHelper.hxx"
#include "SMESH_subMesh.hxx"
-#include "utilities.h"
-#include "OpUtil.hxx"
-#include "Utils_ExceptHandlers.hxx"
+#include <utilities.h>
+#include <Utils_ExceptHandlers.hxx>
-#include <TopoDS_Iterator.hxx>
+#include <TopExp_Explorer.hxx>
#include <TopoDS.hxx>
+#include <TopoDS_Iterator.hxx>
#include "memoire.h"
+#include <chrono>
+#include <functional>
#ifdef WIN32
#include <windows.h>
#endif
+#include <Basics_Utils.hxx>
+
using namespace std;
+#include <boost/filesystem.hpp>
+#include <boost/asio.hpp>
+namespace fs = boost::filesystem;
+
+// Environment variable separator
+#ifdef WIN32
+ #define env_sep ';'
+#else
+ #define env_sep ':'
+#endif
-//#include <vtkDebugLeaks.h>
+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;
+ }
+}
//=============================================================================
/*!
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);
}
//=============================================================================
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 )
{
- delete i_sc->second->myDocument;
- delete i_sc->second;
- }
+ if ( _Hyp* h = static_cast< _Hyp*>( i_hyp->second ))
+ h->NullifyGen();
+ }
+ delete _studyContext->myDocument;
+ delete _studyContext;
}
//=============================================================================
*/
//=============================================================================
-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 does'nt exist, with a SMESHDS_Document
- StudyContextStruct *aStudyContext = GetStudyContext(theStudyId);
-
// create a new SMESH_mesh object
SMESH_Mesh *aMesh = new SMESH_Mesh(_localId++,
- theStudyId,
this,
theIsEmbeddedMode,
- aStudyContext->myDocument);
- aStudyContext->mapMesh[_localId-1] = aMesh;
+ _studyContext->myDocument);
+ _studyContext->mapMesh[_localId-1] = aMesh;
return aMesh;
}
+//=============================================================================
+/*
+ * Parallel compute of a submesh
+ * This function is used to pass to thread_pool
+ */
+//=============================================================================
+const std::function<void(int,
+ SMESH_subMesh*,
+ SMESH_subMesh::compute_event,
+ SMESH_subMesh*,
+ bool,
+ TopTools_IndexedMapOfShape *,
+ TSetOfInt*)>
+ compute_function([&] (int id,
+ 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() );
+
+});
+
//=============================================================================
/*
* 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;
bool ret = true;
- SMESH_subMesh *sm = aMesh.GetSubMesh(aShape);
+ SMESH_subMesh *sm, *shapeSM = aMesh.GetSubMesh(aShape);
const bool includeSelf = true;
const bool complexShapeFirst = true;
const int globalAlgoDim = 100;
+ // Pool of thread for computation
+ if(aMesh.IsParallel())
+ aMesh.InitPoolThreads();
+
SMESH_subMeshIteratorPtr smIt;
// Fix of Issue 22150. Due to !BLSURF->OnlyUnaryInput(), BLSURF computes edges
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
// ===============================================
- smIt = sm->getDependsOnIterator(includeSelf, !complexShapeFirst);
+ TopAbs_ShapeEnum previousShapeType = TopAbs_VERTEX;
+ int nbThreads = aMesh.GetNbThreads();
+ auto begin = std::chrono::high_resolution_clock::now();
+ std::cout << "Running mesh with threads: " << nbThreads << " mesher: " << aMesh.GetMesherNbThreads() << std::endl;
+
+
+ smIt = shapeSM->getDependsOnIterator(includeSelf, !complexShapeFirst);
while ( smIt->more() )
{
SMESH_subMesh* smToCompute = smIt->next();
const TopAbs_ShapeEnum shapeType = shape.ShapeType();
if ( !aMesh.HasShapeToMesh() && shapeType == TopAbs_VERTEX )
continue;
+ if(shapeType==TopAbs_FACE||shapeType==TopAbs_EDGE)
+ aMesh.SetNbThreads(0);
+ else
+ aMesh.SetNbThreads(nbThreads);
+ //DEBUG std::cout << "Shape Type" << shapeType << " previous" << previousShapeType << std::endl;
+ if ((aMesh.IsParallel()||nbThreads!=0) && 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);
+ // TODO: change mesh name
+ exportMesh(mesh_file.string(), aMesh, "Maillage_1");
+
+ }
+ //Resetting threaded pool info
+ previousShapeType = shapeType;
+ }
// check for preview dimension limitations
if ( aShapesId && GetShapeDim( shapeType ) > (int)aDim )
smToCompute->ComputeStateEngine( SMESH_subMesh::CHECK_COMPUTE_STATE );
continue;
}
-
- if (smToCompute->GetComputeState() == SMESH_subMesh::READY_TO_COMPUTE)
+ if(aMesh.IsParallel())
{
- if (_compute_canceled)
- return false;
- setCurrentSubMesh( smToCompute );
- smToCompute->ComputeStateEngine( computeEvent );
- setCurrentSubMesh( NULL );
+ boost::asio::post(*(aMesh._pool), std::bind(compute_function, 1, smToCompute, computeEvent,
+ shapeSM, aShapeOnly, allowedSubShapes,
+ aShapesId));
+ } else {
+ auto begin2 = std::chrono::high_resolution_clock::now();
+
+ compute_function(1 ,smToCompute, computeEvent,
+ shapeSM, aShapeOnly, allowedSubShapes,
+ aShapesId);
+
+ 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() );
}
+ }
- // 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() );
+ // TODO: Check error handling in parallel mode
+ if(aMesh.IsParallel()){
+ // Waiting for the thread for Solids to finish
+ aMesh.wait();
}
- //aMesh.GetMeshDS()->Modified();
+
+ aMesh.GetMeshDS()->Modified();
+ auto end = std::chrono::high_resolution_clock::now();
+ auto elapsed = std::chrono::duration_cast<std::chrono::nanoseconds>(end - begin);
+ std::cout << "Time for All: " << elapsed.count()*1e-9 << std::endl;
+
+ // Pool of thread for computation
+ if(aMesh.IsParallel())
+ aMesh.DeletePoolThreads();
+
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
// ================================================================
-
+ auto begin = std::chrono::high_resolution_clock::now();
list< SMESH_subMesh* > smWithAlgoSupportingSubmeshes[4]; // for each dim
// map to sort sm with same dim algos according to dim of
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();
const TopoDS_Shape& aSubShape = smToCompute->GetSubShape();
aShapeDim = GetShapeDim( aSubShape );
if ( aShapeDim < 1 ) break;
-
+
// check for preview dimension limitations
if ( aShapesId && aShapeDim > (int)aDim )
continue;
{
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() );
}
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 );
// ------------------------------------------------------------
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;
-
- if (_compute_canceled)
- return false;
+ sm->SetAllowedSubShapes( fillAllowed( shapeSM, aShapeOnly, allowedSubShapes ));
setCurrentSubMesh( sm );
+ auto begin = std::chrono::high_resolution_clock::now();
sm->ComputeStateEngine( computeEvent );
+ auto end = std::chrono::high_resolution_clock::now();
+ auto elapsed = std::chrono::duration_cast<std::chrono::nanoseconds>(end - begin);
+ std::cout << "Time for seq:alldim:compute: " << elapsed.count()*1e-9 << std::endl;
+
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 );
+ auto end = std::chrono::high_resolution_clock::now();
+ auto elapsed = std::chrono::duration_cast<std::chrono::nanoseconds>(end - begin);
+ std::cout << "Time for All: " << elapsed.count()*1e-9 << std::endl;
+
}
MEMOSTAT;
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;
}
* 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();
* 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() )
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() ) {
checkConform = false; // no more check conformity
INFOS( "ERROR: Local <" << algo->GetName() <<
"> would produce not conform mesh: "
- "<Not Conform Mesh Allowed> hypotesis is missing");
+ "<Not Conform Mesh Allowed> hypothesis is missing");
theErrors.push_back( SMESH_Gen::TAlgoStateError() );
theErrors.back().Set( SMESH_Hypothesis::HYP_NOTCONFORM, algo, false );
}
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
}
// 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
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<const wchar_t> 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
*/
//=============================================================================
-StudyContextStruct *SMESH_Gen::GetStudyContext(int studyId)
+StudyContextStruct *SMESH_Gen::GetStudyContext()
{
- // Get studyContext, create it if it does'nt 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;
}
//================================================================================
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 withing this Gen
+ * Generate a new id unique within this Gen
*/
//=============================================================================
