-// Copyright (C) 2004-2012 CEA/DEN, EDF R&D
+// Copyright (C) 2004-2014 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
// License as published by the Free Software Foundation; either
-// version 2.1 of the License.
+// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
#include <TCollection_AsciiString.hxx>
-#ifdef WNT
+#ifdef WIN32
#include <process.h>
#define getpid _getpid
#endif
GHS3DPlugin_Hypothesis::GHS3DPlugin_Hypothesis(int hypId, int studyId, SMESH_Gen * gen)
: SMESH_Hypothesis(hypId, studyId, gen),
myToMeshHoles(DefaultMeshHoles()),
+ myToMakeGroupsOfDomains(DefaultToMakeGroupsOfDomains()),
myMaximumMemory(-1),
myInitialMemory(-1),
myOptimizationLevel(DefaultOptimizationLevel()),
myToUseFemCorrection(DefaultToUseFEMCorrection()),
myToRemoveCentralPoint(DefaultToRemoveCentralPoint()),
myGradation(DefaultGradation()),
+ myLogInStandardOutput(DefaultStandardOutputLog()),
_enfVertexList(DefaultGHS3DEnforcedVertexList()),
_enfVertexCoordsSizeList(DefaultGHS3DEnforcedVertexCoordsValues()),
_enfVertexEntrySizeList(DefaultGHS3DEnforcedVertexEntryValues()),
_nodeIDToSizeMap(DefaultID2SizeMap()),
_groupsToRemove(DefaultGroupsToRemove())
{
- _name = "GHS3D_Parameters";
+ _name = GetHypType();
_param_algo_dim = 3;
}
return myToMeshHoles;
}
+//=======================================================================
+//function : SetToMakeGroupsOfDomains
+//=======================================================================
+
+void GHS3DPlugin_Hypothesis::SetToMakeGroupsOfDomains(bool toMakeGroups)
+{
+ if ( myToMakeGroupsOfDomains != toMakeGroups ) {
+ myToMakeGroupsOfDomains = toMakeGroups;
+ NotifySubMeshesHypothesisModification();
+ }
+}
+
+//=======================================================================
+//function : GetToMakeGroupsOfDomains
+//=======================================================================
+
+bool GHS3DPlugin_Hypothesis::GetToMakeGroupsOfDomains() const
+{
+ return myToMakeGroupsOfDomains;
+}
+
+//=======================================================================
+//function : GetToMakeGroupsOfDomains
+//=======================================================================
+
+bool GHS3DPlugin_Hypothesis::GetToMakeGroupsOfDomains(const GHS3DPlugin_Hypothesis* hyp)
+{
+ bool res;
+ if ( hyp ) res = /*hyp->GetToMeshHoles(true) &&*/ hyp->GetToMakeGroupsOfDomains();
+ else res = /*DefaultMeshHoles() &&*/ DefaultToMakeGroupsOfDomains();
+ return res;
+}
+
//=======================================================================
//function : SetMaximumMemory
//=======================================================================
-void GHS3DPlugin_Hypothesis::SetMaximumMemory(short MB)
+void GHS3DPlugin_Hypothesis::SetMaximumMemory(double MB)
{
if ( myMaximumMemory != MB ) {
myMaximumMemory = MB;
// * automatic memory adjustment mode. Default is zero
//=======================================================================
-short GHS3DPlugin_Hypothesis::GetMaximumMemory() const
+double GHS3DPlugin_Hypothesis::GetMaximumMemory() const
{
return myMaximumMemory;
}
//function : SetInitialMemory
//=======================================================================
-void GHS3DPlugin_Hypothesis::SetInitialMemory(short MB)
+void GHS3DPlugin_Hypothesis::SetInitialMemory(double MB)
{
if ( myInitialMemory != MB ) {
myInitialMemory = MB;
//function : GetInitialMemory
//=======================================================================
-short GHS3DPlugin_Hypothesis::GetInitialMemory() const
+double GHS3DPlugin_Hypothesis::GetInitialMemory() const
{
return myInitialMemory;
}
return myGradation;
}
+//=======================================================================
+//function : SetStandardOutputLog
+//=======================================================================
+
+void GHS3DPlugin_Hypothesis::SetStandardOutputLog(bool logInStandardOutput)
+{
+ if ( myLogInStandardOutput != logInStandardOutput ) {
+ myLogInStandardOutput = logInStandardOutput;
+ NotifySubMeshesHypothesisModification();
+ }
+}
+
+//=======================================================================
+//function : GetStandardOutputLog
+//=======================================================================
+
+bool GHS3DPlugin_Hypothesis::GetStandardOutputLog() const
+{
+ return myLogInStandardOutput;
+}
+
+//=======================================================================
+//function : SetRemoveLogOnSuccess
+//=======================================================================
+
+void GHS3DPlugin_Hypothesis::SetRemoveLogOnSuccess(bool removeLogOnSuccess)
+{
+ if ( myRemoveLogOnSuccess != removeLogOnSuccess ) {
+ myRemoveLogOnSuccess = removeLogOnSuccess;
+ NotifySubMeshesHypothesisModification();
+ }
+}
+
+//=======================================================================
+//function : GetRemoveLogOnSuccess
+//=======================================================================
+
+bool GHS3DPlugin_Hypothesis::GetRemoveLogOnSuccess() const
+{
+ return myRemoveLogOnSuccess;
+}
+
//=======================================================================
//function : SetEnforcedVertex
//=======================================================================
bool added = SetEnforcedElements( theElemSet, elementType, groupName);
if (added) {
TGHS3DEnforcedMesh* newEnfMesh = new TGHS3DEnforcedMesh();
- newEnfMesh->name = name;
- newEnfMesh->entry = entry;
+ newEnfMesh->persistID = theMesh.GetMeshDS()->GetPersistentId();
+ newEnfMesh->name = name;
+ newEnfMesh->entry = entry;
newEnfMesh->elementType = elementType;
- newEnfMesh->groupName = groupName;
+ newEnfMesh->groupName = groupName;
TGHS3DEnforcedMeshList::iterator it = _enfMeshList.find(newEnfMesh);
if (it == _enfMeshList.end()) {
_entryEnfMeshMap[entry].insert(newEnfMesh);
_enfMeshList.insert(newEnfMesh);
}
+ else {
+ delete newEnfMesh;
+ }
}
return added;
}
NotifySubMeshesHypothesisModification();
}
+//================================================================================
+/*!
+ * \brief At mesh loading, restore enforced elements by just loaded enforced meshes
+ */
+//================================================================================
+
+void GHS3DPlugin_Hypothesis::RestoreEnfElemsByMeshes()
+{
+ TGHS3DEnforcedMeshList::const_iterator it = _enfMeshList.begin();
+ for(;it != _enfMeshList.end();++it) {
+ TGHS3DEnforcedMesh* enfMesh = *it;
+ if ( SMESH_Mesh* mesh = GetMeshByPersistentID( enfMesh->persistID ))
+ SetEnforcedMesh( *mesh,
+ enfMesh->elementType,
+ enfMesh->name,
+ enfMesh->entry,
+ enfMesh->groupName );
+ enfMesh->persistID = -1; // not to restore again
+ }
+}
//=======================================================================
//function : SetGroupsToRemove
return false; // PAL19680
}
+//=======================================================================
+//function : DefaultToMakeGroupsOfDomains
+//=======================================================================
+
+bool GHS3DPlugin_Hypothesis::DefaultToMakeGroupsOfDomains()
+{
+ return false; // issue 0022172
+}
+
//=======================================================================
//function : DefaultMaximumMemory
//=======================================================================
#include <windows.h>
#endif
-short GHS3DPlugin_Hypothesis::DefaultMaximumMemory()
+double GHS3DPlugin_Hypothesis::DefaultMaximumMemory()
{
#ifndef WIN32
struct sysinfo si;
int err = sysinfo( &si );
if ( err == 0 ) {
int ramMB = si.totalram * si.mem_unit / 1024 / 1024;
- return (int) ( 0.7 * ramMB );
+ return ( 0.7 * ramMB );
}
#else
// See http://msdn.microsoft.com/en-us/library/aa366589.aspx
statex.ullTotalPhys / 1024 / 1024 +
statex.ullTotalPageFile / 1024 / 1024 +
statex.ullTotalVirtual / 1024 / 1024;
- return (int) ( 0.7 * totMB );
+ return ( 0.7 * totMB );
}
#endif
return 1024;
//function : DefaultInitialMemory
//=======================================================================
-short GHS3DPlugin_Hypothesis::DefaultInitialMemory()
+double GHS3DPlugin_Hypothesis::DefaultInitialMemory()
{
return DefaultMaximumMemory();
}
return false;
}
+//=======================================================================
+//function : DefaultRemoveLogOnSuccess
+//=======================================================================
+
+bool GHS3DPlugin_Hypothesis::DefaultRemoveLogOnSuccess()
+{
+ return false;
+}
+
+
//=======================================================================
//function : DefaultVerboseLevel
//=======================================================================
return 1.05;
}
+//=======================================================================
+//function : DefaultStandardOutputLog
+//=======================================================================
+
+bool GHS3DPlugin_Hypothesis::DefaultStandardOutputLog()
+{
+ return false;
+}
+
// //=======================================================================
// //function : DefaultID2SizeMap
// //=======================================================================
save << (int)myToUseFemCorrection << " ";
save << (int)myToRemoveCentralPoint << " ";
save << myGradation << " ";
+ save << myToMakeGroupsOfDomains << " ";
if (!myTextOption.empty()) {
save << "__OPTIONS_BEGIN__ ";
save << myTextOption << " ";
save << " " << enfMesh->groupName;
save << " " << "__END_GROUP__";
}
+ save << " " << "__PERSIST_ID__";
+ save << " " << enfMesh->persistID;
save << " " << "__END_ENF_MESH__";
std::cout << "Saving of enforced mesh " << enfMesh->name.c_str() << " done" << std::endl;
}
std::istream & GHS3DPlugin_Hypothesis::LoadFrom(std::istream & load)
{
- bool isOK = true;
- int i;
- double d;
-
- isOK = (load >> i);
- if (isOK)
- myToMeshHoles = i;
- else
- load.clear(ios::badbit | load.rdstate());
-
- isOK = (load >> i);
- if (isOK)
- myMaximumMemory = i;
- else
- load.clear(ios::badbit | load.rdstate());
-
- isOK = (load >> i);
- if (isOK)
- myInitialMemory = i;
- else
- load.clear(ios::badbit | load.rdstate());
-
- isOK = (load >> i);
- if (isOK)
- myOptimizationLevel = i;
- else
- load.clear(ios::badbit | load.rdstate());
-
- isOK = (load >> myWorkingDirectory);
- if (isOK) {
- if ( myWorkingDirectory == "0") { // myWorkingDirectory was empty
- myKeepFiles = false;
- myWorkingDirectory.clear();
- }
- else if ( myWorkingDirectory == "1" ) {
- myKeepFiles = true;
- myWorkingDirectory.clear();
- }
- }
- else
- load.clear(ios::badbit | load.rdstate());
-
- if ( !myWorkingDirectory.empty() ) {
- isOK = (load >> i);
- if (isOK)
- myKeepFiles = i;
- else
- load.clear(ios::badbit | load.rdstate());
- }
-
- isOK = (load >> i);
- if (isOK)
- myVerboseLevel = (short) i;
- else
- load.clear(ios::badbit | load.rdstate());
-
- isOK = (load >> i);
- if (isOK)
- myToCreateNewNodes = (bool) i;
- else
- load.clear(ios::badbit | load.rdstate());
-
- isOK = (load >> i);
- if (isOK)
- myToUseBoundaryRecoveryVersion = (bool) i;
- else
- load.clear(ios::badbit | load.rdstate());
-
- isOK = (load >> i);
- if (isOK)
- myToUseFemCorrection = (bool) i;
- else
- load.clear(ios::badbit | load.rdstate());
-
- isOK = (load >> i);
- if (isOK)
- myToRemoveCentralPoint = (bool) i;
- else
- load.clear(ios::badbit | load.rdstate());
-
- isOK = (load >> d);
+ bool isOK = true;
+ int i;
+ double d;
+
+ isOK = (load >> i);
+ if (isOK)
+ myToMeshHoles = i;
+ else
+ load.clear(ios::badbit | load.rdstate());
+
+ isOK = (load >> d);
+ if (isOK)
+ myMaximumMemory = d;
+ else
+ load.clear(ios::badbit | load.rdstate());
+
+ isOK = (load >> d);
+ if (isOK)
+ myInitialMemory = d;
+ else
+ load.clear(ios::badbit | load.rdstate());
+
+ isOK = (load >> i);
+ if (isOK)
+ myOptimizationLevel = i;
+ else
+ load.clear(ios::badbit | load.rdstate());
+
+ isOK = (load >> myWorkingDirectory);
+ if (isOK) {
+ if ( myWorkingDirectory == "0") { // myWorkingDirectory was empty
+ myKeepFiles = false;
+ myWorkingDirectory.clear();
+ }
+ else if ( myWorkingDirectory == "1" ) {
+ myKeepFiles = true;
+ myWorkingDirectory.clear();
+ }
+ }
+ else
+ load.clear(ios::badbit | load.rdstate());
+
+ if ( !myWorkingDirectory.empty() ) {
+ isOK = (load >> i);
if (isOK)
- myGradation = d;
+ myKeepFiles = i;
else
- load.clear(ios::badbit | load.rdstate());
-
- std::string separator;
- bool hasOptions = false;
- bool hasEnforcedVertices = false;
- bool hasEnforcedMeshes = false;
- isOK = (load >> separator);
-
- if (isOK) {
- if (separator == "__OPTIONS_BEGIN__")
- hasOptions = true;
- else if (separator == "__ENFORCED_VERTICES_BEGIN__")
- hasEnforcedVertices = true;
- else if (separator == "__ENFORCED_MESHES_BEGIN__")
- hasEnforcedMeshes = true;
- }
-
- if (hasOptions) {
- std::string txt;
- while (isOK) {
- isOK = (load >> txt);
- if (isOK) {
- if (txt == "__OPTIONS_END__") {
- if (!myTextOption.empty()) {
- // Remove last space
- myTextOption.erase(myTextOption.end()-1);
- }
- isOK = false;
- break;
- }
- myTextOption += txt;
- myTextOption += " ";
- }
- }
- }
-
- if (hasOptions) {
- isOK = (load >> separator);
- if (isOK && separator == "__ENFORCED_VERTICES_BEGIN__")
- hasEnforcedVertices = true;
- if (isOK && separator == "__ENFORCED_MESHES_BEGIN__")
- hasEnforcedMeshes = true;
- }
+ load.clear(ios::badbit | load.rdstate());
+ }
+
+ isOK = (load >> i);
+ if (isOK)
+ myVerboseLevel = (short) i;
+ else
+ load.clear(ios::badbit | load.rdstate());
+
+ isOK = (load >> i);
+ if (isOK)
+ myToCreateNewNodes = (bool) i;
+ else
+ load.clear(ios::badbit | load.rdstate());
+
+ isOK = (load >> i);
+ if (isOK)
+ myToUseBoundaryRecoveryVersion = (bool) i;
+ else
+ load.clear(ios::badbit | load.rdstate());
+
+ isOK = (load >> i);
+ if (isOK)
+ myToUseFemCorrection = (bool) i;
+ else
+ load.clear(ios::badbit | load.rdstate());
+
+ isOK = (load >> i);
+ if (isOK)
+ myToRemoveCentralPoint = (bool) i;
+ else
+ load.clear(ios::badbit | load.rdstate());
+
+ isOK = (load >> d);
+ if (isOK)
+ myGradation = d;
+ else
+ load.clear(ios::badbit | load.rdstate());
+
+ std::string separator;
+ bool hasOptions = false;
+ bool hasEnforcedVertices = false;
+ bool hasEnforcedMeshes = false;
+ isOK = (load >> separator);
+
+ if ( isOK && ( separator == "0" || separator == "1" ))
+ {
+ myToMakeGroupsOfDomains = ( separator == "1" );
+ isOK = (load >> separator);
+ }
+
+ if (isOK) {
+ if (separator == "__OPTIONS_BEGIN__")
+ hasOptions = true;
+ else if (separator == "__ENFORCED_VERTICES_BEGIN__")
+ hasEnforcedVertices = true;
+ else if (separator == "__ENFORCED_MESHES_BEGIN__")
+ hasEnforcedMeshes = true;
+ }
+
+ if (hasOptions) {
+ std::string txt;
+ while (isOK) {
+ isOK = (load >> txt);
+ if (isOK) {
+ if (txt == "__OPTIONS_END__") {
+ if (!myTextOption.empty()) {
+ // Remove last space
+ myTextOption.erase(myTextOption.end()-1);
+ }
+ isOK = false;
+ break;
+ }
+ myTextOption += txt;
+ myTextOption += " ";
+ }
+ }
+ }
+
+ if (hasOptions) {
+ isOK = (load >> separator);
+ if (isOK && separator == "__ENFORCED_VERTICES_BEGIN__")
+ hasEnforcedVertices = true;
+ if (isOK && separator == "__ENFORCED_MESHES_BEGIN__")
+ hasEnforcedMeshes = true;
+ }
if (hasEnforcedVertices) {
- std::string txt, name, entry, groupName;
- double size, coords[3];
- bool isCompound;
- bool hasCoords = false;
- isOK = (load >> txt); // __BEGIN_VERTEX__
- while (isOK) {
- if (txt == "__ENFORCED_VERTICES_END__")
- isOK = false;
-
- TGHS3DEnforcedVertex *enfVertex = new TGHS3DEnforcedVertex();
- while (isOK) {
- isOK = (load >> txt);
- if (txt == "__END_VERTEX__") {
- enfVertex->name = name;
- enfVertex->geomEntry = entry;
- enfVertex->isCompound = isCompound;
- enfVertex->groupName = groupName;
- enfVertex->coords.clear();
- if (hasCoords)
- enfVertex->coords.assign(coords,coords+3);
-
- _enfVertexList.insert(enfVertex);
-
- if (enfVertex->coords.size())
- _coordsEnfVertexMap[enfVertex->coords] = enfVertex;
- if (!enfVertex->geomEntry.empty())
- _geomEntryEnfVertexMap[enfVertex->geomEntry] = enfVertex;
-
- name.clear();
- entry.clear();
- groupName.clear();
- hasCoords = false;
- isOK = false;
- }
-
- if (txt == "__BEGIN_NAME__") { // __BEGIN_NAME__
- while (isOK && (txt != "__END_NAME__")) {
- isOK = (load >> txt);
- if (txt != "__END_NAME__") {
- if (!name.empty())
- name += " ";
- name += txt;
- }
- }
- MESSAGE("name: " <<name);
- }
-
- if (txt == "__BEGIN_ENTRY__") { // __BEGIN_ENTRY__
- isOK = (load >> entry);
- isOK = (load >> isCompound);
- isOK = (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);
- if (txt != "__END_GROUP__") {
- if (!groupName.empty())
- groupName += " ";
- groupName += txt;
- }
- }
- MESSAGE("groupName: " << groupName);
- }
-
- if (txt == "__BEGIN_COORDS__") { // __BEGIN_COORDS__
- hasCoords = true;
- isOK = (load >> coords[0] >> coords[1] >> coords[2]);
- isOK = (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__
- if (txt != "__END_SIZE__") {
- throw std::exception();
- }
- MESSAGE("size: " << size);
- }
- }
- isOK = (load >> txt); // __BEGIN_VERTEX__
- }
+ std::string txt, name, entry, groupName;
+ double size, coords[3];
+ bool isCompound;
+ bool hasCoords = false;
+ isOK = (load >> txt); // __BEGIN_VERTEX__
+ while (isOK) {
+ if (txt == "__ENFORCED_VERTICES_END__")
+ isOK = false;
+
+ TGHS3DEnforcedVertex *enfVertex = new TGHS3DEnforcedVertex();
+ while (isOK) {
+ isOK = (load >> txt);
+ if (txt == "__END_VERTEX__") {
+ enfVertex->name = name;
+ enfVertex->geomEntry = entry;
+ enfVertex->isCompound = isCompound;
+ enfVertex->groupName = groupName;
+ enfVertex->coords.clear();
+ if (hasCoords)
+ enfVertex->coords.assign(coords,coords+3);
+
+ _enfVertexList.insert(enfVertex);
+
+ if (enfVertex->coords.size())
+ _coordsEnfVertexMap[enfVertex->coords] = enfVertex;
+ if (!enfVertex->geomEntry.empty())
+ _geomEntryEnfVertexMap[enfVertex->geomEntry] = enfVertex;
+
+ name.clear();
+ entry.clear();
+ groupName.clear();
+ hasCoords = false;
+ isOK = false;
+ }
+
+ if (txt == "__BEGIN_NAME__") { // __BEGIN_NAME__
+ while (isOK && (txt != "__END_NAME__")) {
+ isOK = (load >> txt);
+ if (txt != "__END_NAME__") {
+ if (!name.empty())
+ name += " ";
+ name += txt;
+ }
+ }
+ MESSAGE("name: " <<name);
+ }
+
+ if (txt == "__BEGIN_ENTRY__") { // __BEGIN_ENTRY__
+ isOK = (load >> entry);
+ isOK = (load >> isCompound);
+ isOK = (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);
+ if (txt != "__END_GROUP__") {
+ if (!groupName.empty())
+ groupName += " ";
+ groupName += txt;
+ }
+ }
+ MESSAGE("groupName: " << groupName);
+ }
+
+ if (txt == "__BEGIN_COORDS__") { // __BEGIN_COORDS__
+ hasCoords = true;
+ isOK = (load >> coords[0] >> coords[1] >> coords[2]);
+ isOK = (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__
+ if (txt != "__END_SIZE__") {
+ throw std::exception();
+ }
+ MESSAGE("size: " << size);
+ }
+ }
+ isOK = (load >> txt); // __BEGIN_VERTEX__
+ }
}
if (hasEnforcedVertices) {
- isOK = (load >> separator);
- if (isOK && separator == "__ENFORCED_MESHES_BEGIN__")
- hasEnforcedMeshes = true;
+ isOK = (load >> separator);
+ if (isOK && separator == "__ENFORCED_MESHES_BEGIN__")
+ hasEnforcedMeshes = true;
}
if (hasEnforcedMeshes) {
- std::string txt, name, entry, groupName;
- int elementType = -1;
- isOK = (load >> txt); // __BEGIN_ENF_MESH__
- while (isOK) {
-// if (isOK) {
- if (txt == "__ENFORCED_MESHES_END__")
- isOK = false;
-
- TGHS3DEnforcedMesh *enfMesh = new TGHS3DEnforcedMesh();
- while (isOK) {
- isOK = (load >> txt);
- if (txt == "__END_ENF_MESH__") {
- enfMesh->name = name;
- enfMesh->entry = entry;
- enfMesh->elementType = (SMESH::ElementType)elementType;
- enfMesh->groupName = groupName;
-
- _enfMeshList.insert(enfMesh);
- std::cout << "Restoring of enforced mesh " <<name << " done" << std::endl;
-
- name.clear();
- entry.clear();
- elementType = -1;
- groupName.clear();
- isOK = false;
- }
-
- if (txt == "__BEGIN_NAME__") { // __BEGIN_NAME__
- while (isOK && (txt != "__END_NAME__")) {
- isOK = (load >> txt);
- if (txt != "__END_NAME__") {
- if (!name.empty())
- name += " ";
- name += txt;
- }
- }
- MESSAGE("name: " <<name);
- }
-
- if (txt == "__BEGIN_ENTRY__") { // __BEGIN_ENTRY__
- isOK = (load >> entry);
- isOK = (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__
- 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);
- if (txt != "__END_GROUP__") {
- if (!groupName.empty())
- groupName += " ";
- groupName += txt;
- }
- } // while
- MESSAGE("groupName: " << groupName);
- } // if
- std::cout << "isOK: " << isOK << std::endl;
- } // while
-// } // if
- isOK = (load >> txt); // __BEGIN_ENF_MESH__
- } // while
+ std::string txt, name, entry, groupName;
+ int elementType = -1, persistID = -1;
+ isOK = (load >> txt); // __BEGIN_ENF_MESH__
+ while (isOK) {
+ // if (isOK) {
+ if (txt == "__ENFORCED_MESHES_END__")
+ isOK = false;
+
+ TGHS3DEnforcedMesh *enfMesh = new TGHS3DEnforcedMesh();
+ while (isOK) {
+ isOK = (load >> txt);
+ if (txt == "__END_ENF_MESH__") {
+ enfMesh->name = name;
+ enfMesh->entry = entry;
+ enfMesh->elementType = (SMESH::ElementType)elementType;
+ enfMesh->groupName = groupName;
+ enfMesh->persistID = persistID;
+
+ _enfMeshList.insert(enfMesh);
+ std::cout << "Restoring of enforced mesh " <<name << " done" << std::endl;
+
+ name.clear();
+ entry.clear();
+ elementType = -1;
+ groupName.clear();
+ persistID = -1;
+ isOK = false;
+ }
+
+ if (txt == "__BEGIN_NAME__") { // __BEGIN_NAME__
+ while (isOK && (txt != "__END_NAME__")) {
+ isOK = (load >> txt);
+ if (txt != "__END_NAME__") {
+ if (!name.empty())
+ name += " ";
+ name += txt;
+ }
+ }
+ MESSAGE("name: " <<name);
+ }
+
+ if (txt == "__BEGIN_ENTRY__") { // __BEGIN_ENTRY__
+ isOK = (load >> entry);
+ isOK = (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__
+ 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);
+ if (txt != "__END_GROUP__") {
+ if (!groupName.empty())
+ groupName += " ";
+ groupName += txt;
+ }
+ } // while
+ MESSAGE("groupName: " << groupName);
+ } // if
+
+ if (txt == "__PERSIST_ID__") {
+ isOK = (load >> persistID);
+ MESSAGE("persistID: " << persistID);
+ }
+ std::cout << "isOK: " << isOK << std::endl;
+ } // while
+ // } // if
+ isOK = (load >> txt); // __BEGIN_ENF_MESH__
+ } // while
} // if
return load;
//================================================================================
/*!
- * \brief Return false
+ * \brief Sets myToMakeGroupsOfDomains depending on whether theMesh is on shape or not
*/
//================================================================================
-bool GHS3DPlugin_Hypothesis::SetParametersByDefaults(const TDefaults& /*dflts*/,
+bool GHS3DPlugin_Hypothesis::SetParametersByDefaults(const TDefaults& dflts,
const SMESH_Mesh* /*theMesh*/)
{
- return false;
+ myToMakeGroupsOfDomains = ( !dflts._shape || dflts._shape->IsNull() );
+ return true;
}
//================================================================================
std::string GHS3DPlugin_Hypothesis::CommandToRun(const GHS3DPlugin_Hypothesis* hyp,
const bool hasShapeToMesh)
{
- TCollection_AsciiString cmd;
- if (hasShapeToMesh)
- cmd = "ghs3d-41"; // to use old mesh2 format
- else
- cmd = "ghs3d"; // to use new mesh format
+ TCollection_AsciiString cmd = GetExeName().c_str();
// 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;
// Default memory is defined at ghs3d installation but it may be not enough,
// so allow to use about all available memory
if ( m ) {
- short aMaximumMemory = hyp ? hyp->myMaximumMemory : -1;
+ double aMaximumMemory = hyp ? hyp->myMaximumMemory : -1;
cmd += " -m ";
if ( aMaximumMemory < 0 )
cmd += DefaultMaximumMemory();
cmd += aMaximumMemory;
}
if ( M && !useBndRecovery ) {
- short aInitialMemory = hyp ? hyp->myInitialMemory : -1;
+ double aInitialMemory = hyp ? hyp->myInitialMemory : -1;
cmd += " -M ";
if ( aInitialMemory > 0 )
cmd += aInitialMemory;
cmd += " -c 1";
}
}
+ const bool toCreateNewNodes = ( p0 && ( !hyp || hyp->myToCreateNewNodes ));
// optimization level
- if ( o && hyp && !useBndRecovery ) {
+ if ( o && hyp && !useBndRecovery && toCreateNewNodes ) {
if ( hyp->myOptimizationLevel >= 0 && hyp->myOptimizationLevel < 5 ) {
const char* level[] = { "none" , "light" , "standard" , "standard+" , "strong" };
cmd += " -o ";
cmd += level[ hyp->myOptimizationLevel ];
}
}
+ if ( !toCreateNewNodes ) {
+ cmd += " -o none"; // issue 22608
+ }
// to create internal nodes
- if ( p0 && hyp && !hyp->myToCreateNewNodes ) {
+ if ( p0 && !toCreateNewNodes ) {
cmd += " -p0";
}
cmd += hyp->myGradation;
}
-#ifdef WNT
+#ifdef WIN32
cmd += " < NUL";
#endif
return aGenericName.ToCString();
}
+//================================================================================
+/*
+ * Return the name of executable
+ */
+//================================================================================
+
+std::string GHS3DPlugin_Hypothesis::GetExeName()
+{
+ return "mg-tetra.exe";
+}
//================================================================================
/*!
