-// Copyright (C) 2004-2014 CEA/DEN, EDF R&D
+// Copyright (C) 2004-2016 CEA/DEN, EDF R&D
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
//=============================================================================
//
#include "GHS3DPlugin_Hypothesis.hxx"
-#include <SMESH_ProxyMesh.hxx>
-#include <SMESH_Group.hxx>
-#include <StdMeshers_QuadToTriaAdaptor.hxx>
+
+#include <SMESHDS_Mesh.hxx>
#include <TCollection_AsciiString.hxx>
#define getpid _getpid
#endif
+using namespace std;
+
//=======================================================================
//function : GHS3DPlugin_Hypothesis
//=======================================================================
myMaximumMemory(-1),
myInitialMemory(-1),
myOptimizationLevel(DefaultOptimizationLevel()),
- myWorkingDirectory(DefaultWorkingDirectory()),
myKeepFiles(DefaultKeepFiles()),
+ myWorkingDirectory(DefaultWorkingDirectory()),
myVerboseLevel(DefaultVerboseLevel()),
myToCreateNewNodes(DefaultToCreateNewNodes()),
myToUseBoundaryRecoveryVersion(DefaultToUseBoundaryRecoveryVersion()),
myToUseFemCorrection(DefaultToUseFEMCorrection()),
myToRemoveCentralPoint(DefaultToRemoveCentralPoint()),
- myGradation(DefaultGradation()),
myLogInStandardOutput(DefaultStandardOutputLog()),
+ myGradation(DefaultGradation()),
_enfVertexList(DefaultGHS3DEnforcedVertexList()),
_enfVertexCoordsSizeList(DefaultGHS3DEnforcedVertexCoordsValues()),
_enfVertexEntrySizeList(DefaultGHS3DEnforcedVertexEntryValues()),
bool GHS3DPlugin_Hypothesis::GetToMeshHoles(bool checkFreeOption) const
{
if (checkFreeOption && !myTextOption.empty()) {
- if ( myTextOption.find("-c 0"))
+ if ( myTextOption.find("--components all"))
return true;
- if ( myTextOption.find("-c 1"))
+ if ( myTextOption.find("--components outside_components"))
return false;
}
return myToMeshHoles;
//function : SetMaximumMemory
//=======================================================================
-void GHS3DPlugin_Hypothesis::SetMaximumMemory(double MB)
+void GHS3DPlugin_Hypothesis::SetMaximumMemory(long MB)
{
if ( myMaximumMemory != MB ) {
myMaximumMemory = MB;
// * automatic memory adjustment mode. Default is zero
//=======================================================================
-double GHS3DPlugin_Hypothesis::GetMaximumMemory() const
+long GHS3DPlugin_Hypothesis::GetMaximumMemory() const
{
return myMaximumMemory;
}
//function : SetInitialMemory
//=======================================================================
-void GHS3DPlugin_Hypothesis::SetInitialMemory(double MB)
+void GHS3DPlugin_Hypothesis::SetInitialMemory(long MB)
{
if ( myInitialMemory != MB ) {
myInitialMemory = MB;
//function : GetInitialMemory
//=======================================================================
-double GHS3DPlugin_Hypothesis::GetInitialMemory() const
+long GHS3DPlugin_Hypothesis::GetInitialMemory() const
{
return myInitialMemory;
}
}
//=======================================================================
-//function : SetTextOption
+//function : SetAdvancedOption
//=======================================================================
-void GHS3DPlugin_Hypothesis::SetTextOption(const std::string& option)
+void GHS3DPlugin_Hypothesis::SetAdvancedOption(const std::string& option)
{
if ( myTextOption != option ) {
myTextOption = option;
}
//=======================================================================
-//function : GetTextOption
+//function : GetAdvancedOption
//=======================================================================
-std::string GHS3DPlugin_Hypothesis::GetTextOption() const
+std::string GHS3DPlugin_Hypothesis::GetAdvancedOption() const
{
return myTextOption;
}
//function : SetEnforcedVertex
//=======================================================================
-bool GHS3DPlugin_Hypothesis::SetEnforcedVertex(std::string theName, std::string theEntry, std::string theGroupName,
- double size, double x, double y, double z, bool isCompound)
+bool GHS3DPlugin_Hypothesis::SetEnforcedVertex(std::string theName,
+ std::string theEntry,
+ std::string theGroupName,
+ double size,
+ double x, double y, double z,
+ bool isCompound)
{
MESSAGE("GHS3DPlugin_Hypothesis::SetEnforcedVertex(\""<< theName << "\", \""<< theEntry << "\", \"" << theGroupName << "\", "
<< size << ", " << x << ", " << y << ", " << z << ", "<< isCompound << ")");
MESSAGE("GHS3DPlugin_Hypothesis::SetEnforcedGroup");
TIDSortedElemSet theElemSet;
if ( theIDs->length() == 0 ){MESSAGE("The source group is empty");}
- for (int i=0; i < theIDs->length(); i++) {
+ for ( CORBA::ULong i=0; i < theIDs->length(); i++) {
CORBA::Long ind = theIDs[i];
if (elementType == SMESH::NODE)
{
#include <windows.h>
#endif
-double GHS3DPlugin_Hypothesis::DefaultMaximumMemory()
+long GHS3DPlugin_Hypothesis::DefaultMaximumMemory()
{
#ifndef WIN32
struct sysinfo si;
- int err = sysinfo( &si );
+ long err = sysinfo( &si );
if ( err == 0 ) {
- int ramMB = si.totalram * si.mem_unit / 1024 / 1024;
+ long ramMB = si.totalram * si.mem_unit / 1024 / 1024;
return ( 0.7 * ramMB );
}
#else
// See http://msdn.microsoft.com/en-us/library/aa366589.aspx
MEMORYSTATUSEX statex;
statex.dwLength = sizeof (statex);
- int err = GlobalMemoryStatusEx (&statex);
+ long err = GlobalMemoryStatusEx (&statex);
if (err != 0) {
- int totMB =
- statex.ullTotalPhys / 1024 / 1024 +
- statex.ullTotalPageFile / 1024 / 1024 +
- statex.ullTotalVirtual / 1024 / 1024;
- return ( 0.7 * totMB );
+ double totMB = (double)statex.ullAvailPhys / 1024. / 1024.;
+ return (long)( 0.7 * totMB );
}
#endif
return 1024;
//function : DefaultInitialMemory
//=======================================================================
-double GHS3DPlugin_Hypothesis::DefaultInitialMemory()
+long GHS3DPlugin_Hypothesis::DefaultInitialMemory()
{
return DefaultMaximumMemory();
}
}
if (enfVertex->coords.size()) {
save << " " << "__BEGIN_COORDS__";
- for (int i=0;i<enfVertex->coords.size();i++)
+ for ( size_t i = 0; i < enfVertex->coords.size(); i++ )
save << " " << enfVertex->coords[i];
save << " " << "__END_COORDS__";
}
int i;
double d;
- isOK = (load >> i);
+ isOK = static_cast<bool>(load >> i);
if (isOK)
myToMeshHoles = i;
else
load.clear(ios::badbit | load.rdstate());
- isOK = (load >> d);
+ isOK = static_cast<bool>(load >> d);
if (isOK)
myMaximumMemory = d;
else
load.clear(ios::badbit | load.rdstate());
- isOK = (load >> d);
+ isOK = static_cast<bool>(load >> d);
if (isOK)
myInitialMemory = d;
else
load.clear(ios::badbit | load.rdstate());
- isOK = (load >> i);
+ isOK = static_cast<bool>(load >> i);
if (isOK)
myOptimizationLevel = i;
else
load.clear(ios::badbit | load.rdstate());
- isOK = (load >> myWorkingDirectory);
+ isOK = static_cast<bool>(load >> myWorkingDirectory);
if (isOK) {
if ( myWorkingDirectory == "0") { // myWorkingDirectory was empty
myKeepFiles = false;
load.clear(ios::badbit | load.rdstate());
if ( !myWorkingDirectory.empty() ) {
- isOK = (load >> i);
+ isOK = static_cast<bool>(load >> i);
if (isOK)
myKeepFiles = i;
else
load.clear(ios::badbit | load.rdstate());
}
- isOK = (load >> i);
+ isOK = static_cast<bool>(load >> i);
if (isOK)
myVerboseLevel = (short) i;
else
load.clear(ios::badbit | load.rdstate());
- isOK = (load >> i);
+ isOK = static_cast<bool>(load >> i);
if (isOK)
myToCreateNewNodes = (bool) i;
else
load.clear(ios::badbit | load.rdstate());
- isOK = (load >> i);
+ isOK = static_cast<bool>(load >> i);
if (isOK)
myToUseBoundaryRecoveryVersion = (bool) i;
else
load.clear(ios::badbit | load.rdstate());
- isOK = (load >> i);
+ isOK = static_cast<bool>(load >> i);
if (isOK)
myToUseFemCorrection = (bool) i;
else
load.clear(ios::badbit | load.rdstate());
- isOK = (load >> i);
+ isOK = static_cast<bool>(load >> i);
if (isOK)
myToRemoveCentralPoint = (bool) i;
else
load.clear(ios::badbit | load.rdstate());
- isOK = (load >> d);
+ isOK = static_cast<bool>(load >> d);
if (isOK)
myGradation = d;
else
bool hasOptions = false;
bool hasEnforcedVertices = false;
bool hasEnforcedMeshes = false;
- isOK = (load >> separator);
+ isOK = static_cast<bool>(load >> separator);
if ( isOK && ( separator == "0" || separator == "1" ))
{
myToMakeGroupsOfDomains = ( separator == "1" );
- isOK = (load >> separator);
+ isOK = static_cast<bool>(load >> separator);
}
if (isOK) {
if (hasOptions) {
std::string txt;
while (isOK) {
- isOK = (load >> txt);
+ isOK = static_cast<bool>(load >> txt);
if (isOK) {
if (txt == "__OPTIONS_END__") {
if (!myTextOption.empty()) {
}
if (hasOptions) {
- isOK = (load >> separator);
+ isOK = static_cast<bool>(load >> separator);
if (isOK && separator == "__ENFORCED_VERTICES_BEGIN__")
hasEnforcedVertices = true;
if (isOK && separator == "__ENFORCED_MESHES_BEGIN__")
double size, coords[3];
bool isCompound;
bool hasCoords = false;
- isOK = (load >> txt); // __BEGIN_VERTEX__
+ isOK = static_cast<bool>(load >> txt); // __BEGIN_VERTEX__
while (isOK) {
- if (txt == "__ENFORCED_VERTICES_END__")
- isOK = false;
-
+ if (txt == "__ENFORCED_VERTICES_END__") {
+ //isOK = false;
+ break;
+ }
+
TGHS3DEnforcedVertex *enfVertex = new TGHS3DEnforcedVertex();
while (isOK) {
- isOK = (load >> txt);
+ isOK = static_cast<bool>(load >> txt);
if (txt == "__END_VERTEX__") {
enfVertex->name = name;
enfVertex->geomEntry = entry;
if (txt == "__BEGIN_NAME__") { // __BEGIN_NAME__
while (isOK && (txt != "__END_NAME__")) {
- isOK = (load >> txt);
+ isOK = static_cast<bool>(load >> txt);
if (txt != "__END_NAME__") {
if (!name.empty())
name += " ";
}
if (txt == "__BEGIN_ENTRY__") { // __BEGIN_ENTRY__
- isOK = (load >> entry);
- isOK = (load >> isCompound);
- isOK = (load >> txt); // __END_ENTRY__
+ isOK = static_cast<bool>(load >> entry);
+ isOK = static_cast<bool>(load >> isCompound);
+ isOK = static_cast<bool>(load >> txt); // __END_ENTRY__
if (txt != "__END_ENTRY__")
throw std::exception();
MESSAGE("entry: " << entry);
if (txt == "__BEGIN_GROUP__") { // __BEGIN_GROUP__
while (isOK && (txt != "__END_GROUP__")) {
- isOK = (load >> txt);
+ isOK = static_cast<bool>(load >> txt);
if (txt != "__END_GROUP__") {
if (!groupName.empty())
groupName += " ";
if (txt == "__BEGIN_COORDS__") { // __BEGIN_COORDS__
hasCoords = true;
- isOK = (load >> coords[0] >> coords[1] >> coords[2]);
- isOK = (load >> txt); // __END_COORDS__
+ isOK = static_cast<bool>(load >> coords[0] >> coords[1] >> coords[2]);
+ isOK = static_cast<bool>(load >> txt); // __END_COORDS__
if (txt != "__END_COORDS__")
throw std::exception();
MESSAGE("coords: " << coords[0] <<","<< coords[1] <<","<< coords[2]);
}
if (txt == "__BEGIN_SIZE__") { // __BEGIN_ENTRY__
- isOK = (load >> size);
- isOK = (load >> txt); // __END_ENTRY__
+ isOK = static_cast<bool>(load >> size);
+ isOK = static_cast<bool>(load >> txt); // __END_ENTRY__
if (txt != "__END_SIZE__") {
throw std::exception();
}
MESSAGE("size: " << size);
}
}
- isOK = (load >> txt); // __BEGIN_VERTEX__
+ isOK = static_cast<bool>(load >> txt); // __BEGIN_VERTEX__
}
}
if (hasEnforcedVertices) {
- isOK = (load >> separator);
+ isOK = static_cast<bool>(load >> separator);
if (isOK && separator == "__ENFORCED_MESHES_BEGIN__")
hasEnforcedMeshes = true;
}
if (hasEnforcedMeshes) {
std::string txt, name, entry, groupName;
int elementType = -1, persistID = -1;
- isOK = (load >> txt); // __BEGIN_ENF_MESH__
+ isOK = static_cast<bool>(load >> txt); // __BEGIN_ENF_MESH__
while (isOK) {
// if (isOK) {
if (txt == "__ENFORCED_MESHES_END__")
TGHS3DEnforcedMesh *enfMesh = new TGHS3DEnforcedMesh();
while (isOK) {
- isOK = (load >> txt);
+ isOK = static_cast<bool>(load >> txt);
if (txt == "__END_ENF_MESH__") {
enfMesh->name = name;
enfMesh->entry = entry;
enfMesh->persistID = persistID;
_enfMeshList.insert(enfMesh);
- std::cout << "Restoring of enforced mesh " <<name << " done" << std::endl;
+ //std::cout << "Restoring of enforced mesh " <<name << " done" << std::endl;
name.clear();
entry.clear();
if (txt == "__BEGIN_NAME__") { // __BEGIN_NAME__
while (isOK && (txt != "__END_NAME__")) {
- isOK = (load >> txt);
+ isOK = static_cast<bool>(load >> txt);
if (txt != "__END_NAME__") {
if (!name.empty())
name += " ";
}
if (txt == "__BEGIN_ENTRY__") { // __BEGIN_ENTRY__
- isOK = (load >> entry);
- isOK = (load >> txt); // __END_ENTRY__
+ isOK = static_cast<bool>(load >> entry);
+ isOK = static_cast<bool>(load >> txt); // __END_ENTRY__
if (txt != "__END_ENTRY__")
throw std::exception();
MESSAGE("entry: " << entry);
}
if (txt == "__BEGIN_ELEM_TYPE__") { // __BEGIN_ELEM_TYPE__
- isOK = (load >> elementType);
- isOK = (load >> txt); // __END_ELEM_TYPE__
+ isOK = static_cast<bool>(load >> elementType);
+ isOK = static_cast<bool>(load >> txt); // __END_ELEM_TYPE__
if (txt != "__END_ELEM_TYPE__")
throw std::exception();
MESSAGE("elementType: " << elementType);
if (txt == "__BEGIN_GROUP__") { // __BEGIN_GROUP__
while (isOK && (txt != "__END_GROUP__")) {
- isOK = (load >> txt);
+ isOK = static_cast<bool>(load >> txt);
if (txt != "__END_GROUP__") {
if (!groupName.empty())
groupName += " ";
} // if
if (txt == "__PERSIST_ID__") {
- isOK = (load >> persistID);
+ isOK = static_cast<bool>(load >> persistID);
MESSAGE("persistID: " << persistID);
}
- std::cout << "isOK: " << isOK << std::endl;
+ //std::cout << "isOK: " << isOK << std::endl;
} // while
// } // if
- isOK = (load >> txt); // __BEGIN_ENF_MESH__
+ isOK = static_cast<bool>(load >> txt); // __BEGIN_ENF_MESH__
} // while
} // if
//================================================================================
std::string GHS3DPlugin_Hypothesis::CommandToRun(const GHS3DPlugin_Hypothesis* hyp,
- const bool hasShapeToMesh)
+ const bool hasShapeToMesh,
+ const bool forExecutable)
{
- TCollection_AsciiString cmd = GetExeName().c_str();
+ std::string cmd = GetExeName();
// check if any option is overridden by hyp->myTextOption
- bool m = hyp ? ( hyp->myTextOption.find("-m") == std::string::npos ) : true;
- bool M = hyp ? ( hyp->myTextOption.find("-M") == std::string::npos ) : true;
- bool c = hyp ? ( hyp->myTextOption.find("-c") == std::string::npos ) : true;
- bool o = hyp ? ( hyp->myTextOption.find("-o") == std::string::npos ) : true;
- bool p0 = hyp ? ( hyp->myTextOption.find("-p0") == std::string::npos ) : true;
+ bool max_memory = hyp ? ( hyp->myTextOption.find("--max_memory") == std::string::npos ) : true;
+ bool auto_memory = hyp ? ( hyp->myTextOption.find("--automatic_memory") == std::string::npos ) : true;
+ bool comp = hyp ? ( hyp->myTextOption.find("--components") == std::string::npos ) : true;
+ bool optim_level = hyp ? ( hyp->myTextOption.find("--optimisation_level") == std::string::npos ) : true;
+ bool no_int_points = hyp ? ( hyp->myTextOption.find("--no_internal_points") == std::string::npos ) : true;
bool C = hyp ? ( hyp->myTextOption.find("-C") == std::string::npos ) : true;
- bool v = hyp ? ( hyp->myTextOption.find("-v") == std::string::npos ) : true;
+ bool verbose = hyp ? ( hyp->myTextOption.find("--verbose") == std::string::npos ) : true;
bool fem = hyp ? ( hyp->myTextOption.find("-FEM")== std::string::npos ) : true;
- bool rem = hyp ? ( hyp->myTextOption.find("-no_initial_central_point")== std::string::npos ) : true;
+ bool rem = hyp ? ( hyp->myTextOption.find("--no_initial_central_point")== std::string::npos ) : true;
bool gra = hyp ? ( hyp->myTextOption.find("-Dcpropa")== std::string::npos ) : true;
// if use boundary recovery version, few options are allowed
// MG-Tetra needs to know amount of memory it may use (MB).
// Default memory is defined at MG-Tetra installation but it may be not enough,
// so allow to use about all available memory
- if ( m ) {
- double aMaximumMemory = hyp ? hyp->myMaximumMemory : -1;
- cmd += " -m ";
- if ( aMaximumMemory < 0 )
- cmd += DefaultMaximumMemory();
- else
- cmd += aMaximumMemory;
+ if ( max_memory ) {
+ long aMaximumMemory = hyp ? hyp->myMaximumMemory : -1;
+ cmd += " --max_memory ";
+ if ( aMaximumMemory < 0 ) cmd += SMESH_Comment( DefaultMaximumMemory() );
+ else cmd += SMESH_Comment( aMaximumMemory );
}
- if ( M && !useBndRecovery ) {
- double aInitialMemory = hyp ? hyp->myInitialMemory : -1;
- cmd += " -M ";
- if ( aInitialMemory > 0 )
- cmd += aInitialMemory;
- else
- cmd += "100";
+ if ( auto_memory && !useBndRecovery ) {
+ long aInitialMemory = hyp ? hyp->myInitialMemory : -1;
+ cmd += " --automatic_memory ";
+ if ( aInitialMemory > 0 ) cmd += SMESH_Comment( aInitialMemory );
+ else cmd += "100";
}
// component to mesh
- // 0 , all components to be meshed
- // 1 , only the main ( outermost ) component to be meshed
- if ( c && !useBndRecovery ) {
+ if ( comp && !useBndRecovery ) {
// We always run MG-Tetra with "to mesh holes'==TRUE (see PAL19680)
if ( hasShapeToMesh )
- cmd += " -c 0";
+ cmd += " --components all";
else {
bool aToMeshHoles = hyp ? hyp->myToMeshHoles : DefaultMeshHoles();
- if ( aToMeshHoles )
- cmd += " -c 0";
- else
- cmd += " -c 1";
+ if ( aToMeshHoles ) cmd += " --components all";
+ else cmd += " --components outside_components";
}
}
- const bool toCreateNewNodes = ( p0 && ( !hyp || hyp->myToCreateNewNodes ));
+ const bool toCreateNewNodes = ( no_int_points && ( !hyp || hyp->myToCreateNewNodes ));
// optimization level
- if ( o && hyp && !useBndRecovery && toCreateNewNodes ) {
+ if ( !toCreateNewNodes ) {
+ cmd += " --optimisation_level none"; // issue 22608
+ }
+ else if ( optim_level && hyp && !useBndRecovery ) {
if ( hyp->myOptimizationLevel >= 0 && hyp->myOptimizationLevel < 5 ) {
const char* level[] = { "none" , "light" , "standard" , "standard+" , "strong" };
- cmd += " -o ";
+ cmd += " --optimisation_level ";
cmd += level[ hyp->myOptimizationLevel ];
}
}
- if ( !toCreateNewNodes ) {
- cmd += " -o none"; // issue 22608
- }
// to create internal nodes
- if ( p0 && !toCreateNewNodes ) {
- cmd += " -p0";
+ if ( no_int_points && !toCreateNewNodes ) {
+ if ( forExecutable )
+ cmd += " --no_internal_points";
+ else
+ cmd += " --internalpoints no";
}
// verbose mode
- if ( v && hyp ) {
- cmd += " -v ";
- cmd += hyp->myVerboseLevel;
+ if ( verbose && hyp ) {
+ cmd += " --verbose " + SMESH_Comment( hyp->myVerboseLevel );
}
// boundary recovery version
// to remove initial central point.
if ( rem && hyp && hyp->myToRemoveCentralPoint) {
- cmd += " -no_initial_central_point";
+ if ( forExecutable )
+ cmd += " --no_initial_central_point";
+ else
+ cmd += " --centralpoint no";
}
// options as text
if ( hyp && !hyp->myTextOption.empty() ) {
- cmd += " ";
- cmd += (char*) hyp->myTextOption.c_str();
+ cmd += " " + hyp->myTextOption;
}
// to define volumic gradation.
- if ( gra && hyp) {
- cmd += " -Dcpropa=";
- cmd += hyp->myGradation;
+ if ( gra && hyp ) {
+ if ( forExecutable )
+ cmd += " -Dcpropa=" + SMESH_Comment( hyp->myGradation );
+ else
+ cmd += " --gradation " + SMESH_Comment( hyp->myGradation );
}
#ifdef WIN32
cmd += " < NUL";
#endif
- return cmd.ToCString();
+ return cmd;
}
//================================================================================
