-// Copyright (C) 2007-2022 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
//
//#define CHRONODEF
//
-#ifndef WIN32
-#include <boost/asio.hpp>
-#endif
#include "SMESH_Gen.hxx"
#include "SMESH_DriverMesh.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 "memoire.h"
#include <functional>
+#include <QString>
+#include <QProcess>
+
#ifdef WIN32
#include <windows.h>
#endif
#include <Basics_Utils.hxx>
+#ifndef WIN32
+#include <boost/asio.hpp>
+#endif
+
using namespace std;
#ifndef WIN32
#include <boost/filesystem.hpp>
Unexpect aCatch(SalomeException);
// create a new SMESH_mesh object
- SMESH_Mesh *aMesh = new SMESH_Mesh(_localId++,
+ SMESH_Mesh *aMesh = new SMESH_SequentialMesh(
+ _localId++,
this,
theIsEmbeddedMode,
_studyContext->myDocument);
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_ParallelMesh *aMesh = new SMESH_ParallelMesh(
+ _localId++,
+ this,
+ theIsEmbeddedMode,
+ _studyContext->myDocument);
+ _studyContext->mapMesh[_localId-1] = aMesh;
+
+ return aMesh;
+}
//=============================================================================
/*!
const bool complexShapeFirst,
const bool aShapeOnly)
{
- MESSAGE("Compute submeshes sequentialy");
+ MESSAGE("Sequential Compute of submeshes");
bool ret = true;
continue;
// check for preview dimension limitations
- if ( aShapesId && GetShapeDim( shapeType ) > (int)aDim )
+ 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
});
+
+//=============================================================================
+/*
+ * 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<SMESH_ParallelMesh&>(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<std::string> 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
SMESH_subMeshIteratorPtr smIt;
SMESH_subMesh *shapeSM = aMesh.GetSubMesh(aShape);
-
- // Pool of thread for computation
- // TODO: move when parallelMesh created
- aMesh.InitPoolThreads();
- aMesh.CreateTmpFolder();
+ SMESH_ParallelMesh &aParMesh = dynamic_cast<SMESH_ParallelMesh&>(aMesh);
TopAbs_ShapeEnum previousShapeType = TopAbs_VERTEX;
- int nbThreads = aMesh.GetNbThreads();
- MESSAGE("Compute submeshes with threads: " << nbThreads);
+ MESSAGE("Parallel Compute of submeshes");
smIt = shapeSM->getDependsOnIterator(includeSelf, !complexShapeFirst);
// 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
+ // Not doing in parallel 1D 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;
- }
+ 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(aMesh.tmp_folder) / fs::path(file_name);
- SMESH_DriverMesh::exportMesh(mesh_file.string(), aMesh, "MESH");
-
+ 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 && GetShapeDim( shapeType ) > (int)aDim )
+ 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;
}
- boost::asio::post(*(aMesh._pool), std::bind(compute_function, smToCompute, computeEvent,
+ // Parallelism is only for 3D parts
+ if(shapeType!=aMesh.GetParallelElement()){
+ compute_function(smToCompute, computeEvent,
shapeSM, aShapeOnly, allowedSubShapes,
- aShapesId));
+ 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();
- aMesh.DeleteTmpFolder();
+
+ // Cleanup done here as in Python the destructor is not called
+ aParMesh.cleanup();
return ret;
#endif
// ===============================================
// 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);
+ ret = aMesh.ComputeSubMeshes(
+ this,
+ aMesh, aShape, aDim,
+ aShapesId, allowedSubShapes,
+ computeEvent,
+ includeSelf,
+ complexShapeFirst,
+ aShapeOnly);
return ret;
}
if ( aShapesId && GetShapeDim( shapeType ) > (int)aDim )
continue;
sm->SetAllowedSubShapes( fillAllowed( shapeSM, aShapeOnly, allowedSubShapes ));
+
setCurrentSubMesh( sm );
sm->ComputeStateEngine( computeEvent );
