-// Copyright (C) 2007-2022 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2023 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
#include "NETGENPlugin_Hypothesis.hxx"
-#include "NETGENPlugin_DriverParam.hxx"
-
#include <SMDS_MeshElement.hxx>
#include <SMDS_MeshNode.hxx>
#include <SMESHDS_Mesh.hxx>
#include <StdMeshers_QuadToTriaAdaptor.hxx>
#include <StdMeshers_ViscousLayers.hxx>
#include <SMESH_subMesh.hxx>
-#include <SMESH_DriverShape.hxx>
-#include <SMESH_DriverMesh.hxx>
#include <BRepGProp.hxx>
#include <vector>
#include <map>
-#include <QString>
-#include <QProcess>
-
#include <cstdlib>
-#include <boost/filesystem.hpp>
-namespace fs = boost::filesystem;
/*
Netgen include files
}
-void NETGENPlugin_NETGEN_3D::fillParameters(const NETGENPlugin_Hypothesis* hyp, netgen_params &aParams)
-{
- aParams.maxh = hyp->GetMaxSize();
- aParams.minh = hyp->GetMinSize();
- aParams.segmentsperedge = hyp->GetNbSegPerEdge();
- aParams.grading = hyp->GetGrowthRate();
- aParams.curvaturesafety = hyp->GetNbSegPerRadius();
- aParams.secondorder = hyp->GetSecondOrder() ? 1 : 0;
- aParams.quad = hyp->GetQuadAllowed() ? 1 : 0;
- aParams.optimize = hyp->GetOptimize();
- aParams.fineness = hyp->GetFineness();
- aParams.uselocalh = hyp->GetSurfaceCurvature();
- aParams.merge_solids = hyp->GetFuseEdges();
- aParams.chordalError = hyp->GetChordalErrorEnabled() ? hyp->GetChordalError() : -1.;
- aParams.optsteps2d = aParams.optimize ? hyp->GetNbSurfOptSteps() : 0;
- aParams.optsteps3d = aParams.optimize ? hyp->GetNbVolOptSteps() : 0;
- aParams.elsizeweight = hyp->GetElemSizeWeight();
- aParams.opterrpow = hyp->GetWorstElemMeasure();
- aParams.delaunay = hyp->GetUseDelauney();
- aParams.checkoverlap = hyp->GetCheckOverlapping();
- aParams.checkchartboundary = hyp->GetCheckChartBoundary();
-#ifdef NETGEN_V6
- // std::string
- aParams.meshsizefilename = hyp->GetMeshSizeFile();
-#else
- // const char*
- aParams.meshsizefilename = hyp->GetMeshSizeFile();
-#endif
-#ifdef NETGEN_V6
- aParams.closeedgefac = 2;
-#else
- aParams.closeedgefac = 0;
-#endif
-}
-
-// write in a binary file the orientation for each 2D element of the mesh
-void NETGENPlugin_NETGEN_3D::exportElementOrientation(SMESH_Mesh& aMesh,
- const TopoDS_Shape& aShape,
- netgen_params& aParams,
- const std::string output_file)
-{
- SMESH_MesherHelper helper(aMesh);
- NETGENPlugin_Internals internals( aMesh, aShape, /*is3D=*/true );
- SMESH_ProxyMesh::Ptr proxyMesh( new SMESH_ProxyMesh( aMesh ));
- std::map<vtkIdType, bool> elemOrientation;
-
- for ( TopExp_Explorer exFa( aShape, TopAbs_FACE ); exFa.More(); exFa.Next())
- {
- const TopoDS_Shape& aShapeFace = exFa.Current();
- int faceID = aMesh.GetMeshDS()->ShapeToIndex( aShapeFace );
- bool isInternalFace = internals.isInternalShape( faceID );
- bool isRev = false;
- if ( !isInternalFace &&
- helper.NbAncestors(aShapeFace, aMesh, aShape.ShapeType()) > 1 )
- // IsReversedSubMesh() can work wrong on strongly curved faces,
- // so we use it as less as possible
- isRev = helper.IsReversedSubMesh( TopoDS::Face( aShapeFace ));
-
- const SMESHDS_SubMesh * aSubMeshDSFace = proxyMesh->GetSubMesh( aShapeFace );
- if ( !aSubMeshDSFace ) continue;
-
- SMDS_ElemIteratorPtr iteratorElem = aSubMeshDSFace->GetElements();
- if ( aParams._quadraticMesh &&
- dynamic_cast< const SMESH_ProxyMesh::SubMesh*>( aSubMeshDSFace ))
- {
- // add medium nodes of proxy triangles to helper (#16843)
- while ( iteratorElem->more() )
- helper.AddTLinks( static_cast< const SMDS_MeshFace* >( iteratorElem->next() ));
-
- iteratorElem = aSubMeshDSFace->GetElements();
- }
- while ( iteratorElem->more() ) // loop on elements on a geom face
- {
- // check mesh face
- const SMDS_MeshElement* elem = iteratorElem->next();
- if ( !elem )
- error( COMPERR_BAD_INPUT_MESH, "Null element encounters");
- if ( elem->NbCornerNodes() != 3 )
- error( COMPERR_BAD_INPUT_MESH, "Not triangle element encounters");
- elemOrientation[elem->GetID()] = isRev;
- } // loop on elements on a face
- } // loop on faces of a SOLID or SHELL
-
- {
- std::ofstream df(output_file, ios::out|ios::binary);
- int size=elemOrientation.size();
-
- df.write((char*)&size, sizeof(int));
- for(auto const& [id, orient]:elemOrientation){
- df.write((char*)&id, sizeof(vtkIdType));
- df.write((char*)&orient, sizeof(bool));
- }
- }
-}
-
-int NETGENPlugin_NETGEN_3D::RemoteCompute(SMESH_Mesh& aMesh,
- const TopoDS_Shape& aShape)
-{
- aMesh.Lock();
- auto time0 = std::chrono::high_resolution_clock::now();
- SMESH_Hypothesis::Hypothesis_Status hypStatus;
- CheckHypothesis(aMesh, aShape, hypStatus);
- auto time1 = std::chrono::high_resolution_clock::now();
- auto elapsed = std::chrono::duration_cast<std::chrono::nanoseconds>(time1-time0);
- std::cout << "Time for check_hypo: " << elapsed.count() * 1e-9 << std::endl;
-
-
- // Temporary folder for run
- fs::path tmp_folder = aMesh.tmp_folder / fs::unique_path(fs::path("Volume-%%%%-%%%%"));
- fs::create_directories(tmp_folder);
- // Using MESH2D generated after all triangles where created.
- fs::path mesh_file=aMesh.tmp_folder / fs::path("Mesh2D.med");
- fs::path element_orientation_file=tmp_folder / fs::path("element_orientation.dat");
- fs::path new_element_file=tmp_folder / fs::path("new_elements.dat");
- fs::path tmp_mesh_file=tmp_folder / fs::path("tmp_mesh.med");
- // Not used kept for debug
- //fs::path output_mesh_file=tmp_folder / fs::path("output_mesh.med");
- fs::path shape_file=tmp_folder / fs::path("shape.brep");
- fs::path param_file=tmp_folder / fs::path("netgen3d_param.txt");
- fs::path log_file=tmp_folder / fs::path("run.log");
- fs::path cmd_file=tmp_folder / fs::path("cmd.log");
- //TODO: Handle variable mesh_name
- std::string mesh_name = "Maillage_1";
-
- //Writing Shape
- exportShape(shape_file.string(), aShape);
- auto time2 = std::chrono::high_resolution_clock::now();
- elapsed = std::chrono::duration_cast<std::chrono::nanoseconds>(time2-time1);
- std::cout << "Time for exportShape: " << elapsed.count() * 1e-9 << std::endl;
-
- //Writing hypo
- netgen_params aParams;
- fillParameters(_hypParameters, aParams);
-
- exportNetgenParams(param_file.string(), aParams);
- auto time3 = std::chrono::high_resolution_clock::now();
- elapsed = std::chrono::duration_cast<std::chrono::nanoseconds>(time3-time2);
- std::cout << "Time for fill+export param: " << elapsed.count() * 1e-9 << std::endl;
-
- // Exporting element orientation
- exportElementOrientation(aMesh, aShape, aParams, element_orientation_file.string());
- auto time4 = std::chrono::high_resolution_clock::now();
- elapsed = std::chrono::duration_cast<std::chrono::nanoseconds>(time4-time3);
- std::cout << "Time for exportElemOrient: " << elapsed.count() * 1e-9 << std::endl;
-
- aMesh.Unlock();
- // Calling run_mesher
- // TODO: check if we need to handle the .exe for windows
- std::string cmd;
- fs::path run_mesher_exe =
- fs::path(std::getenv("NETGENPLUGIN_ROOT_DIR"))/
- fs::path("bin")/
- fs::path("salome")/
- fs::path("NETGENPlugin_Runner");
-
- cmd = run_mesher_exe.string() +
- " NETGEN3D " + mesh_file.string() + " "
- + shape_file.string() + " "
- + param_file.string() + " "
- + element_orientation_file.string() + " "
- + std::to_string(aMesh.GetMesherNbThreads()) + " "
- + new_element_file.string() + " "
- + "NONE";
- // Writing command in log
- {
- std::ofstream flog(cmd_file.string());
- flog << cmd << endl;
- flog << endl;
- }
- //std::cout << "Running command: " << std::endl;
- //std::cout << cmd << std::endl;
-
-
- // Building arguments for QProcess
- QString program = run_mesher_exe.c_str();
- QStringList arguments;
- arguments << "NETGEN3D";
- arguments << mesh_file.c_str();
- arguments << shape_file.c_str();
- arguments << param_file.c_str();
- arguments << element_orientation_file.c_str();
- arguments << std::to_string(aMesh.GetMesherNbThreads()).c_str();
- arguments << new_element_file.c_str();
- arguments << "NONE";
- QString out_file = log_file.c_str();
- QProcess myProcess;
- myProcess.setStandardOutputFile(out_file);
-
- myProcess.start(program, arguments);
- myProcess.waitForFinished();
- int ret = myProcess.exitStatus();
-
- auto time5 = std::chrono::high_resolution_clock::now();
- elapsed = std::chrono::duration_cast<std::chrono::nanoseconds>(time5-time4);
- std::cout << "Time for exec of run_mesher: " << elapsed.count() * 1e-9 << std::endl;
-
- if(ret != 0){
- // Run crahed
- std::cout << "Issue with command: " << std::endl;
- std::cout << "See log for more details: " << log_file.string() << std::endl;
- std::cout << cmd << std::endl;
- return false;
- }
-
- aMesh.Lock();
- {
- std::ifstream df(new_element_file.string(), ios::binary);
-
- int Netgen_NbOfNodes;
- int Netgen_NbOfNodesNew;
- int Netgen_NbOfTetra;
- double Netgen_point[3];
- int Netgen_tetrahedron[4];
- int nodeID;
-
- SMESH_MesherHelper helper(aMesh);
- // This function is mandatory for setElementsOnShape to work
- helper.IsQuadraticSubMesh(aShape);
- helper.SetElementsOnShape( true );
-
- // Number of nodes in intial mesh
- df.read((char*) &Netgen_NbOfNodes, sizeof(int));
- // Number of nodes added by netgen
- df.read((char*) &Netgen_NbOfNodesNew, sizeof(int));
-
- // Filling nodevec (correspondence netgen numbering mesh numbering)
- vector< const SMDS_MeshNode* > nodeVec ( Netgen_NbOfNodesNew + 1 );
- //vector<int> nodeTmpVec ( Netgen_NbOfNodesNew + 1 );
- SMESHDS_Mesh * meshDS = helper.GetMeshDS();
- for (int nodeIndex = 1 ; nodeIndex <= Netgen_NbOfNodes; ++nodeIndex )
- {
- //Id of the point
- df.read((char*) &nodeID, sizeof(int));
- nodeVec.at(nodeIndex) = meshDS->FindNode(nodeID);
- }
-
- // Add new points and update nodeVec
- for (int nodeIndex = Netgen_NbOfNodes +1 ; nodeIndex <= Netgen_NbOfNodesNew; ++nodeIndex )
- {
- df.read((char *) &Netgen_point, sizeof(double)*3);
-
- nodeVec.at(nodeIndex) = helper.AddNode(Netgen_point[0],
- Netgen_point[1],
- Netgen_point[2]);
- }
-
- // Add tetrahedrons
- df.read((char*) &Netgen_NbOfTetra, sizeof(int));
-
- for ( int elemIndex = 1; elemIndex <= Netgen_NbOfTetra; ++elemIndex )
- {
- df.read((char*) &Netgen_tetrahedron, sizeof(int)*4);
- helper.AddVolume(
- nodeVec.at( Netgen_tetrahedron[0] ),
- nodeVec.at( Netgen_tetrahedron[1] ),
- nodeVec.at( Netgen_tetrahedron[2] ),
- nodeVec.at( Netgen_tetrahedron[3] ));
- }
- }
- auto time7 = std::chrono::high_resolution_clock::now();
- elapsed = std::chrono::duration_cast<std::chrono::nanoseconds>(time7-time5);
- std::cout << "Time for exec of add_in_mesh: " << elapsed.count() * 1e-9 << std::endl;
-
- aMesh.Unlock();
-
- return true;
-}
//=============================================================================
/*!
*/
//=============================================================================
+
/**
- * @brief Get an iterator on the Surface element with their orientation
+ * @brief Compute the list of already meshed Surface elements and info
+ * on their orientation and if they are internal
*
+ * @param aMesh Global Mesh
+ * @param aShape Shape associated to the mesh
+ * @param proxyMesh pointer to mesh used fo find the elements
+ * @param internals information on internal sub shapes
+ * @param helper helper associated to the mesh
+ * @param listElements map of surface element associated with
+ * their orientation and internal status
+ * @return true if their was some error
*/
-
- bool getSurfaceElements(
+bool NETGENPlugin_NETGEN_3D::getSurfaceElements(
SMESH_Mesh& aMesh,
const TopoDS_Shape& aShape,
SMESH_ProxyMesh::Ptr proxyMesh,
NETGENPlugin_Internals &internals,
SMESH_MesherHelper &helper,
- netgen_params &aParams,
- std::map<const SMDS_MeshElement*, tuple<bool, bool>>& listElements
+ std::map<const SMDS_MeshElement*, tuple<bool, bool>, TIDCompare>& listElements
)
{
SMESHDS_Mesh* meshDS = aMesh.GetMeshDS();
if ( !aSubMeshDSFace ) continue;
SMDS_ElemIteratorPtr iteratorElem = aSubMeshDSFace->GetElements();
- if ( aParams._quadraticMesh &&
+ if ( _quadraticMesh &&
dynamic_cast< const SMESH_ProxyMesh::SubMesh*>( aSubMeshDSFace ))
{
// add medium nodes of proxy triangles to helper (#16843)
const SMDS_MeshElement* elem = iteratorElem->next();
// check mesh face
if ( !elem ){
- aParams._error = COMPERR_BAD_INPUT_MESH;
- aParams._comment = "Null element encounters";
- return true;
+ return error( COMPERR_BAD_INPUT_MESH, "Null element encounters");
}
if ( elem->NbCornerNodes() != 3 ){
- aParams._error = COMPERR_BAD_INPUT_MESH;
- aParams._comment = "Not triangle element encounters";
- return true;
+ return error( COMPERR_BAD_INPUT_MESH, "Not triangle element encounters");
}
listElements[elem] = tuple(isRev, isInternalFace);
}
return false;
}
+/**
+ * @brief Part of Compute: adding already meshed elements
+ * into netgen structure
+ *
+ * @param aMesh Global mesh
+ * @param aShape Shape associated with the mesh
+ * @param nodeVec Mapping between nodes mesh id and netgen structure id
+ * @param ngLib Wrapper on netgen lib
+ * @param helper helper assocaited to the mesh
+ * @param Netgen_NbOfNodes Number of nodes in netge structure
+ * @return true if there was some error
+ */
bool NETGENPlugin_NETGEN_3D::computeFillNgMesh(
SMESH_Mesh& aMesh,
vector< const SMDS_MeshNode* > &nodeVec,
NETGENPlugin_NetgenLibWrapper &ngLib,
SMESH_MesherHelper &helper,
- netgen_params &aParams,
int &Netgen_NbOfNodes)
{
netgen::multithread.terminate = 0;
netgen::multithread.task = "Volume meshing";
- aParams._progressByTic = -1.;
+ _progressByTic = -1.;
SMESHDS_Mesh* meshDS = aMesh.GetMeshDS();
- aParams._quadraticMesh = helper.IsQuadraticSubMesh(aShape);
+ _quadraticMesh = helper.IsQuadraticSubMesh(aShape);
helper.SetElementsOnShape( true );
Netgen_NbOfNodes = 0;
SMESH::Controls::TSequenceOfXYZ nodesCoords;
// maps nodes to ng ID
+ // map must be sorted by ID to ensure that we will have the same number of
+ // 3D element if we recompute
typedef map< const SMDS_MeshNode*, int, TIDCompare > TNodeToIDMap;
typedef TNodeToIDMap::value_type TN2ID;
TNodeToIDMap nodeToNetgenID;
bool isInternalFace=false;
SMESH_ProxyMesh::Ptr proxyMesh( new SMESH_ProxyMesh( aMesh ));
- if ( aParams._viscousLayersHyp )
+ if ( _viscousLayersHyp )
{
netgen::multithread.percent = 3;
- proxyMesh = aParams._viscousLayersHyp->Compute( aMesh, aShape );
+ proxyMesh = _viscousLayersHyp->Compute( aMesh, aShape );
if ( !proxyMesh )
return false;
}
proxyMesh.reset( Adaptor );
}
- std::map<const SMDS_MeshElement*, tuple<bool, bool>> listElements;
- bool ret = getSurfaceElements(aMesh, aShape, proxyMesh, internals, helper, aParams, listElements);
+ // map must be sorted by ID to ensure that we will have the same number of
+ // 3D element if we recompute
+ std::map<const SMDS_MeshElement*, tuple<bool, bool>, TIDCompare> listElements;
+ bool ret = getSurfaceElements(aMesh, aShape, proxyMesh, internals, helper, listElements);
if(ret)
return ret;
return false;
}
+/**
+ * @brief Part of Compute: Setting the netgen parameters from the Hypothesis
+ *
+ * @param aMesh Global mesh
+ * @param ngLib Wrapper on netgen lib
+ * @param occgeo Mapping between nodes mesh id and netgen structure id
+ * @param helper helper assocaited to the mesh
+ * @param endWith end step of netgen
+ * @return true if there was some error
+ */
bool NETGENPlugin_NETGEN_3D::computePrepareParam(
SMESH_Mesh& aMesh,
NETGENPlugin_NetgenLibWrapper &ngLib,
netgen::OCCGeometry &occgeo,
SMESH_MesherHelper &helper,
- netgen_params &aParams,
int &endWith)
{
NETGENPlugin_Mesher aMesher( &aMesh, helper.GetSubShape(), /*isVolume=*/true );
- if ( aParams._hypParameters )
+ if ( _hypParameters )
{
- aMesher.SetParameters( aParams._hypParameters );
+ aMesher.SetParameters( _hypParameters );
- if ( !aParams._hypParameters->GetLocalSizesAndEntries().empty() ||
- !aParams._hypParameters->GetMeshSizeFile().empty() )
+ if ( !_hypParameters->GetLocalSizesAndEntries().empty() ||
+ !_hypParameters->GetMeshSizeFile().empty() )
{
if ( ! &ngMesh->LocalHFunction() )
{
netgen::Point3d pmin, pmax;
ngMesh->GetBox( pmin, pmax, 0 );
- ngMesh->SetLocalH( pmin, pmax, aParams._hypParameters->GetGrowthRate() );
+ ngMesh->SetLocalH( pmin, pmax, _hypParameters->GetGrowthRate() );
}
aMesher.SetLocalSize( occgeo, *ngMesh );
try {
ngMesh->LoadLocalMeshSize( netgen::mparam.meshsizefilename );
} catch (netgen::NgException & ex) {
- aParams._error = COMPERR_BAD_PARMETERS;
- aParams._comment = ex.What();
- return false;
+ return error( COMPERR_BAD_PARMETERS, ex.What() );
}
}
- if ( !aParams._hypParameters->GetOptimize() )
+ if ( !_hypParameters->GetOptimize() )
endWith = netgen::MESHCONST_MESHVOLUME;
}
- else if ( aParams._hypMaxElementVolume )
+ else if ( _hypMaxElementVolume )
{
- netgen::mparam.maxh = pow( 72, 1/6. ) * pow( aParams.maxElementVolume, 1/3. );
+ netgen::mparam.maxh = pow( 72, 1/6. ) * pow( _maxElementVolume, 1/3. );
// limitVolumeSize( ngMesh, mparam.maxh ); // result is unpredictable
}
else if ( aMesh.HasShapeToMesh() )
netgen::mparam.maxh = Dist(pmin, pmax)/2;
}
- if ( !aParams._hypParameters && aMesh.HasShapeToMesh() )
+ if ( !_hypParameters && aMesh.HasShapeToMesh() )
{
netgen::mparam.minh = aMesher.GetDefaultMinSize( helper.GetSubShape(), netgen::mparam.maxh );
}
return false;
}
+/**
+ * @brief Part of Compute: call to the netgen mesher
+ *
+ * @param occgeo netgen geometry structure
+ * @param nodeVec Mapping between nodes mesh id and netgen structure id
+ * @param ngMesh netgen mesh structure
+ * @param ngLib Wrapper on netgen lib
+ * @param startWith starting step of netgen
+ * @param endWith end step of netgen
+ * @return true if there was some error
+ */
bool NETGENPlugin_NETGEN_3D::computeRunMesher(
netgen::OCCGeometry &occgeo,
vector< const SMDS_MeshNode* > &nodeVec,
netgen::Mesh* ngMesh,
NETGENPlugin_NetgenLibWrapper &ngLib,
- netgen_params &aParams,
int &startWith, int &endWith)
{
int err = 1;
if(netgen::multithread.terminate)
return false;
if ( err ){
- aParams._comment = SMESH_Comment("Error in netgen::OCCGenerateMesh() at ") << netgen::multithread.task;
- return true;
+ error(SMESH_Comment("Error in netgen::OCCGenerateMesh() at ") << netgen::multithread.task);
}
}
catch (Standard_Failure& ex)
<< ": " << ex.DynamicType()->Name();
if ( ex.GetMessageString() && strlen( ex.GetMessageString() ))
str << ": " << ex.GetMessageString();
- aParams._comment = str;
- return true;
+ error(str);
}
catch (netgen::NgException& exc)
{
if ( strlen( netgen::multithread.task ) > 0 )
str << " at " << netgen::multithread.task;
str << ": " << exc.What();
- aParams._comment = str;
- return true;
+ error(str);
}
catch (...)
{
SMESH_Comment str("Exception in netgen::OCCGenerateMesh()");
if ( strlen( netgen::multithread.task ) > 0 )
str << " at " << netgen::multithread.task;
- aParams._comment = str;
- return true;
+ error(str);
}
if ( err )
{
SMESH_ComputeErrorPtr ce = NETGENPlugin_Mesher::ReadErrors(nodeVec);
if ( ce && ce->HasBadElems() ){
- aParams._error = ce->myName;
- aParams._comment = ce->myComment;
- return true;
+ error( ce );
}
}
return false;
}
+/**
+ * @brief Part of Compute: Adding new element created by mesher to SMESH_Mesh
+ *
+ * @param nodeVec Mapping between nodes mesh id and netgen structure id
+ * @param ngLib Wrapper on netgen lib
+ * @param helper tool associated to the mesh to add element
+ * @param Netgen_NbOfNodes Number of nodes in netgen structure
+ * @return true if there was some error
+ */
bool NETGENPlugin_NETGEN_3D::computeFillMesh(
vector< const SMDS_MeshNode* > &nodeVec,
NETGENPlugin_NetgenLibWrapper &ngLib,
return false;
}
+
+/**
+ * @brief Compute mesh associate to shape
+ *
+ * @param aMesh The mesh
+ * @param aShape The shape
+ * @return true fi there are some error
+ */
bool NETGENPlugin_NETGEN_3D::Compute(
SMESH_Mesh& aMesh,
const TopoDS_Shape& aShape)
{
- if(aMesh.IsParallel())
- return RemoteCompute(aMesh, aShape);
-
// vector of nodes in which node index == netgen ID
vector< const SMDS_MeshNode* > nodeVec;
NETGENPlugin_NetgenLibWrapper ngLib;
int endWith = netgen::MESHCONST_OPTVOLUME;
int Netgen_NbOfNodes;
- netgen_params aParams;
-
- aParams._hypParameters = const_cast<NETGENPlugin_Hypothesis*>(_hypParameters);
- aParams._hypMaxElementVolume = const_cast<StdMeshers_MaxElementVolume*>(_hypMaxElementVolume);
- aParams.maxElementVolume = _maxElementVolume;
- aParams._progressByTic = _progressByTic;
- aParams._quadraticMesh = _quadraticMesh;
- aParams._viscousLayersHyp = const_cast<StdMeshers_ViscousLayers*>(_viscousLayersHyp);
-
- bool ret;
- ret = computeFillNgMesh(aMesh, aShape, nodeVec, ngLib, helper, aParams, Netgen_NbOfNodes);
- if(ret)
- return error( aParams._error, aParams._comment);
+ computeFillNgMesh(aMesh, aShape, nodeVec, ngLib, helper, Netgen_NbOfNodes);
netgen::OCCGeometry occgeo;
- computePrepareParam(aMesh, ngLib, occgeo, helper, aParams, endWith);
- ret = computeRunMesher(occgeo, nodeVec, ngLib._ngMesh, ngLib, aParams, startWith, endWith);
- if(ret){
- if(aParams._error)
- return error(aParams._error, aParams._comment);
-
- error(aParams._comment);
- return true;
- }
+ computePrepareParam(aMesh, ngLib, occgeo, helper, endWith);
+ computeRunMesher(occgeo, nodeVec, ngLib._ngMesh, ngLib, startWith, endWith);
+
computeFillMesh(nodeVec, ngLib, helper, Netgen_NbOfNodes);
return false;
vector< const SMDS_MeshNode* >& nodeVec,
NETGENPlugin_NetgenLibWrapper& ngLib)
{
- auto time0 = std::chrono::high_resolution_clock::now();
-
netgen::multithread.terminate = 0;
netgen::Mesh* ngMesh = ngLib._ngMesh;
try
{
OCC_CATCH_SIGNALS;
- auto time0 = std::chrono::high_resolution_clock::now();
ngLib.CalcLocalH(ngMesh);
err = ngLib.GenerateMesh(occgeo, startWith, endWith);
str << " at " << netgen::multithread.task;
error(str);
}
- auto time1 = std::chrono::high_resolution_clock::now();
- auto elapsed = std::chrono::duration_cast<std::chrono::nanoseconds>(time1-time0);
- std::cout << "Time for seq:compute: " << elapsed.count() * 1e-9 << std::endl;
int Netgen_NbOfNodesNew = Ng_GetNP(Netgen_mesh);
int Netgen_NbOfTetra = Ng_GetNE(Netgen_mesh);
}
}
}
- auto time2 = std::chrono::high_resolution_clock::now();
- elapsed = std::chrono::duration_cast<std::chrono::nanoseconds>(time2-time1);
- std::cout << "Time for seq:compute: " << elapsed.count() * 1e-9 << std::endl;
-
return !err;
}
strncmp( netgen::multithread.task, volMeshing, 3 ) == 0 ))
{
res = 0.001 + meshingRatio * netgen::multithread.percent / 100.;
- //cout << netgen::multithread.task << " " <<_progressTic << "-" << netgen::multithread.percent << endl;
}
else // different otimizations
{
if ( _progressByTic < 0. )
((NETGENPlugin_NETGEN_3D*)this)->_progressByTic = meshingRatio / _progressTic;
res = _progressByTic * _progressTic;
- //cout << netgen::multithread.task << " " << _progressTic << " " << res << endl;
}
return Min ( res, 0.98 );
}
