void SetWorstElemMeasure(in short val );
short GetWorstElemMeasure();
+ void SetNbThreads(in short val );
+ short GetNbThreads();
+
void SetUseDelauney(in boolean toUse);
boolean GetUseDelauney();
if self.Parameters(): self.params.SetGrowthRate(theRate)
pass
+ ## Sets @c NbThreads parameter
+ # @param theRate new value of the @c NbThreads parameter
+ def SetNbThreads(self, theNumber):
+ if self.Parameters(): self.params.SetNbThreads(theNumber)
+ pass
+
## Creates meshing hypothesis according to the chosen algorithm type
# and initializes it with default parameters
# @param which hypothesis type; can be either @ref SOLE (default) or @ref SIMPLE
std::cout << "checkoverlap: " << aParams.checkoverlap << std::endl;
std::cout << "checkchartboundary: " << aParams.checkchartboundary << std::endl;
std::cout << "closeedgefac: " << aParams.closeedgefac << std::endl;
+ std::cout << "nbThreadMesher: " << aParams.nbThreads << std::endl;
std::cout << "has_local_size: " << aParams.has_local_size << std::endl;
std::cout << "meshsizefilename: " << aParams.meshsizefilename << std::endl;
std::cout << "has_maxelementvolume_hyp: " << aParams.has_maxelementvolume_hyp << std::endl;
std::getline(myfile, line);
aParams.closeedgefac = std::stoi(line);
std::getline(myfile, line);
+ aParams.nbThreads = std::stoi(line);
+ std::getline(myfile, line);
aParams.has_local_size = std::stoi(line);
std::getline(myfile, line);
aParams.meshsizefilename = line;
myfile << aParams.checkoverlap << std::endl;
myfile << aParams.checkchartboundary << std::endl;
myfile << aParams.closeedgefac << std::endl;
+ myfile << aParams.nbThreads << std::endl;
myfile << aParams.has_local_size << std::endl;
myfile << aParams.meshsizefilename << std::endl;
myfile << aParams.has_maxelementvolume_hyp << std::endl;
_nbVolOptSteps (GetDefaultNbVolOptSteps()),
_elemSizeWeight (GetDefaultElemSizeWeight()),
_worstElemMeasure (GetDefaultWorstElemMeasure()),
+ _nbThreads (GetDefaultNbThreads()),
_surfaceCurvature (GetDefaultSurfaceCurvature()),
_useDelauney (GetDefaultUseDelauney()),
_checkOverlapping (GetDefaultCheckOverlapping()),
//=============================================================================
/*!
- *
+ *
*/
//=============================================================================
void NETGENPlugin_Hypothesis::SetMinSize(double theSize)
//=============================================================================
/*!
- *
+ *
*/
//=============================================================================
void NETGENPlugin_Hypothesis::SetSecondOrder(bool theVal)
//=============================================================================
/*!
- *
+ *
*/
//=============================================================================
void NETGENPlugin_Hypothesis::SetOptimize(bool theVal)
//=============================================================================
/*!
- *
+ *
*/
//=============================================================================
void NETGENPlugin_Hypothesis::SetFineness(Fineness theFineness)
//=============================================================================
/*!
- *
+ *
*/
//=============================================================================
void NETGENPlugin_Hypothesis::SetGrowthRate(double theRate)
//=============================================================================
/*!
- *
+ *
*/
//=============================================================================
void NETGENPlugin_Hypothesis::SetNbSegPerEdge(double theVal)
//=============================================================================
/*!
- *
+ *
*/
//=============================================================================
void NETGENPlugin_Hypothesis::SetNbSegPerRadius(double theVal)
//=============================================================================
/*!
- *
+ *
*/
//=============================================================================
void NETGENPlugin_Hypothesis::SetChordalErrorEnabled(bool theVal)
//=============================================================================
/*!
- *
+ *
*/
//=============================================================================
void NETGENPlugin_Hypothesis::SetChordalError(double theVal)
//=============================================================================
/*!
- *
+ *
*/
//=============================================================================
void NETGENPlugin_Hypothesis::SetLocalSizeOnEntry(const std::string& entry, double localSize)
//=============================================================================
/*!
- *
+ *
*/
//=============================================================================
void NETGENPlugin_Hypothesis::UnsetLocalSizeOnEntry(const std::string& entry)
//=============================================================================
/*!
- *
+ *
*/
//=============================================================================
void NETGENPlugin_Hypothesis::SetMeshSizeFile(const std::string& fileName)
//=============================================================================
/*!
- *
+ *
*/
//=============================================================================
void NETGENPlugin_Hypothesis::SetQuadAllowed(bool theVal)
//=============================================================================
/*!
- *
+ *
*/
//=============================================================================
void NETGENPlugin_Hypothesis::SetSurfaceCurvature(bool theVal)
//=======================================================================
//function : SetNbSurfOptSteps
-//purpose :
+//purpose :
//=======================================================================
void NETGENPlugin_Hypothesis::SetNbSurfOptSteps( int theVal )
//=======================================================================
//function : SetNbVolOptSteps
-//purpose :
+//purpose :
//=======================================================================
void NETGENPlugin_Hypothesis::SetNbVolOptSteps( int theVal )
//=======================================================================
//function : SetElemSizeWeight
-//purpose :
+//purpose :
//=======================================================================
void NETGENPlugin_Hypothesis::SetElemSizeWeight( double theVal )
//=======================================================================
//function : SetWorstElemMeasure
-//purpose :
+//purpose :
//=======================================================================
void NETGENPlugin_Hypothesis::SetWorstElemMeasure( int theVal )
//=======================================================================
//function : SetUseDelauney
-//purpose :
+//purpose :
//=======================================================================
void NETGENPlugin_Hypothesis::SetUseDelauney( bool theVal )
//=======================================================================
//function : SetCheckOverlapping
-//purpose :
+//purpose :
//=======================================================================
void NETGENPlugin_Hypothesis::SetCheckOverlapping( bool theVal )
//=======================================================================
//function : SetCheckChartBoundary
-//purpose :
+//purpose :
//=======================================================================
void NETGENPlugin_Hypothesis::SetCheckChartBoundary( bool theVal )
}
}
+//=======================================================================
+//function : SetNbThreads
+//purpose :
+//=======================================================================
+
+void NETGENPlugin_Hypothesis::SetNbThreads( int theVal )
+{
+ if (theVal != _nbThreads)
+ {
+ _nbThreads = theVal;
+ NotifySubMeshesHypothesisModification();
+ }
+}
+
//=============================================================================
/*!
*
//=============================================================================
/*!
- *
+ *
*/
//=============================================================================
istream & NETGENPlugin_Hypothesis::LoadFrom(istream & load)
#include "Utils_SALOME_Exception.hxx"
#include <map>
+#include <thread>
// Parameters for work of NETGEN
//
void SetCheckChartBoundary( bool toCheck );
bool GetCheckChartBoundary() const { return _checkChartBoundary; }
+ void SetNbThreads( int val );
+ int GetNbThreads() const { return _nbThreads; }
+
// the default values (taken from NETGEN 4.5 sources)
static Fineness GetDefaultFineness() { return Moderate; }
static bool GetDefaultCheckOverlapping() { return true; }
static bool GetDefaultCheckChartBoundary(){ return true; }
static bool GetDefaultFuseEdges() { return true; }
+ static int GetDefaultNbThreads() { return std::thread::hardware_concurrency(); }
// Persistence
virtual std::ostream & SaveTo (std::ostream & save);
//bool _blockFilling; -- not used by netgen
// (SALOME additions)
bool _fuseEdges;
+
+ // Parallelism parameters
+ int _nbThreads;
};
#endif
NETGENPlugin_Hypothesis_i::
NETGENPlugin_Hypothesis_i (PortableServer::POA_ptr thePOA,
::SMESH_Gen* theGenImpl)
- : SALOME::GenericObj_i( thePOA ),
+ : SALOME::GenericObj_i( thePOA ),
SMESH_Hypothesis_i( thePOA ),
mySetMethodFlags(0)
{
//=======================================================================
//function : SetNbSurfOptSteps
-//purpose :
+//purpose :
//=======================================================================
void NETGENPlugin_Hypothesis_i::SetNbSurfOptSteps(CORBA::Short nb )
//=======================================================================
//function : SetNbVolOptSteps
-//purpose :
+//purpose :
//=======================================================================
void NETGENPlugin_Hypothesis_i::SetNbVolOptSteps(CORBA::Short nb )
//=======================================================================
//function : SetElemSizeWeight
-//purpose :
+//purpose :
//=======================================================================
void NETGENPlugin_Hypothesis_i::SetElemSizeWeight(CORBA::Double size )
//=======================================================================
//function : SetWorstElemMeasure
-//purpose :
+//purpose :
//=======================================================================
void NETGENPlugin_Hypothesis_i::SetWorstElemMeasure(CORBA::Short val )
//=======================================================================
//function : GetWorstElemMeasure
-//purpose :
+//purpose :
//=======================================================================
CORBA::Short NETGENPlugin_Hypothesis_i::GetWorstElemMeasure()
return (CORBA::Short) GetImpl()->GetWorstElemMeasure();
}
+//=======================================================================
+//function : SetNbThreads
+//purpose :
+//=======================================================================
+
+void NETGENPlugin_Hypothesis_i::SetNbThreads(CORBA::Short val )
+{
+ if ( GetNbThreads() != val )
+ {
+ this->GetImpl()->SetNbThreads( val );
+ SMESH::TPythonDump() << _this() << ".SetNbThreads( " << SMESH::TVar(val) << " )";
+ }
+}
+
+//=======================================================================
+//function : GetNbThreads
+//purpose :
+//=======================================================================
+
+CORBA::Short NETGENPlugin_Hypothesis_i::GetNbThreads()
+{
+ return (CORBA::Short) GetImpl()->GetNbThreads();
+}
+
//=======================================================================
//function : SetUseDelauney
-//purpose :
+//purpose :
//=======================================================================
void NETGENPlugin_Hypothesis_i::SetUseDelauney(CORBA::Boolean toUse)
//=======================================================================
//function : GetUseDelauney
-//purpose :
+//purpose :
//=======================================================================
CORBA::Boolean NETGENPlugin_Hypothesis_i::GetUseDelauney()
//=======================================================================
//function : SetCheckOverlapping
-//purpose :
+//purpose :
//=======================================================================
void NETGENPlugin_Hypothesis_i::SetCheckOverlapping(CORBA::Boolean toCheck )
//=======================================================================
//function : GetCheckOverlapping
-//purpose :
+//purpose :
//=======================================================================
CORBA::Boolean NETGENPlugin_Hypothesis_i::GetCheckOverlapping()
//=======================================================================
//function : SetCheckChartBoundary
-//purpose :
+//purpose :
//=======================================================================
void NETGENPlugin_Hypothesis_i::SetCheckChartBoundary(CORBA::Boolean toCheck )
//================================================================================
/*!
- * \brief Verify whether hypothesis supports given entity type
+ * \brief Verify whether hypothesis supports given entity type
* \param type - dimension (see SMESH::Dimension enumeration)
* \retval CORBA::Boolean - TRUE if dimension is supported, FALSE otherwise
- *
+ *
* Verify whether hypothesis supports given entity type (see SMESH::Dimension enumeration)
*/
-//================================================================================
+//================================================================================
CORBA::Boolean NETGENPlugin_Hypothesis_i::IsDimSupported( SMESH::Dimension type )
{
return type == SMESH::DIM_3D;
void SetWorstElemMeasure(CORBA::Short val );
CORBA::Short GetWorstElemMeasure();
+ void SetNbThreads(CORBA::Short val );
+ CORBA::Short GetNbThreads();
+
void SetUseDelauney(CORBA::Boolean toUse);
CORBA::Boolean GetUseDelauney();
// Get implementation
::NETGENPlugin_Hypothesis* GetImpl();
- // Verify whether hypothesis supports given entity type
+ // Verify whether hypothesis supports given entity type
CORBA::Boolean IsDimSupported( SMESH::Dimension type );
#ifdef NETGEN_V6
- mparams.nthreads = std::thread::hardware_concurrency();
+ mparams.nthreads = NETGENPlugin_Hypothesis::GetDefaultNbThreads();
if ( getenv( "SALOME_NETGEN_DISABLE_MULTITHREADING" ))
{
mparams.nthreads = 1;
mparams.parallel_meshing = false;
}
-
#endif
}
#ifdef NETGEN_V6
// std::string
mparams.meshsizefilename = hyp->GetMeshSizeFile();
+ mparams.nthreads = hyp->GetNbThreads();
#else
// const char*
mparams.meshsizefilename= hyp->GetMeshSizeFile().empty() ? 0 : hyp->GetMeshSizeFile().c_str();
#ifdef NETGEN_V6
// std::string
aParams.meshsizefilename = hyp->GetMeshSizeFile();
+ aParams.closeedgefac = 2;
+ aParams.nbThreads = hyp->GetNbThreads();
#else
// const char*
aParams.meshsizefilename = hyp->GetMeshSizeFile();
-#endif
-#ifdef NETGEN_V6
- aParams.closeedgefac = 2;
-#else
aParams.closeedgefac = 0;
#endif
}