1 // Copyright (C) 2007-2023 CEA, EDF
3 // This library is free software; you can redistribute it and/or
4 // modify it under the terms of the GNU Lesser General Public
5 // License as published by the Free Software Foundation; either
6 // version 2.1 of the License, or (at your option) any later version.
8 // This library is distributed in the hope that it will be useful,
9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11 // Lesser General Public License for more details.
13 // You should have received a copy of the GNU Lesser General Public
14 // License along with this library; if not, write to the Free Software
15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
20 //=============================================================================
21 // File : HYBRIDPlugin_Hypothesis.cxx
22 // Created : Wed Apr 2 12:36:29 2008
23 // Author : Edward AGAPOV (eap)
24 //=============================================================================
26 #include "HYBRIDPlugin_Hypothesis.hxx"
28 #include <SMESHDS_Mesh.hxx>
30 #include <TopExp_Explorer.hxx>
34 #define getpid _getpid
39 struct GET_DEFAULT // struct used to get default value from GetOptionValue()
42 operator bool* () { return &isDefault; }
46 //=======================================================================
47 //function : HYBRIDPlugin_Hypothesis
48 //=======================================================================
50 HYBRIDPlugin_Hypothesis::HYBRIDPlugin_Hypothesis(int hypId, SMESH_Gen * gen)
51 : SMESH_Hypothesis(hypId, gen),
52 myNbOfBoundaryLayers(DefaultNbOfBoundaryLayers()),
53 myHeightFirstLayer(DefaultHeightFirstLayer()),
54 myHeightIsRelative(DefaultHeightIsRelative()),
55 myBoundaryLayersGrowth(DefaultBoundaryLayersGrowth()),
56 myBoundaryLayersMaxElemAngle(DefaultBoundaryLayersMaxElemAngle()),
57 myBoundaryLayersProgression(DefaultBoundaryLayersProgression()),
58 myElementGeneration(DefaultElementGeneration()),
59 myCoreSize(DefaultCoreSize()),
60 myLayersOnAllWrap(DefaultLayersOnAllWrap()),
61 myCollisionMode(DefaultCollisionMode()),
62 myAddMultinormals(DefaultAddMultinormals()),
63 mySmoothNormals(DefaultSmoothNormals()),
64 myMultinormalsAngle(DefaultMultinormalsAngle()),
65 myGradation(DefaultGradation()),
66 myWorkingDirectory(DefaultWorkingDirectory()),
67 myVerboseLevel(DefaultVerboseLevel()),
68 myLogInStandardOutput(DefaultStandardOutputLog()),
69 myRemoveLogOnSuccess(DefaultRemoveLogOnSuccess()),
70 myKeepFiles(DefaultKeepFiles()),
71 myOptimizationLevel(DefaultOptimizationLevel()),
72 myToMakeGroupsOfDomains(DefaultToMakeGroupsOfDomains()),
73 myToMeshHoles(DefaultMeshHoles()),
76 myToCreateNewNodes(DefaultToCreateNewNodes()),
77 myToUseBoundaryRecoveryVersion(DefaultToUseBoundaryRecoveryVersion()),
78 myToUseFemCorrection(DefaultToUseFEMCorrection()),
79 myToRemoveCentralPoint(DefaultToRemoveCentralPoint())
81 _name = "HYBRID_Parameters";
84 const char* boolOptionNames[] = { "add_multinormals", // no
85 "smooth_normals", // no
88 const char* intOptionNames[] = { "max_number_of_threads", // 4
91 const char* doubleOptionNames[] = { //"global_physical_size", // 0.0 = not set -- myCoreSize
93 //"boundary_layer_max_element_angle", // 165.0 -- myBoundaryLayersMaxElemAngle
94 "multinormal_angle_threshold", // 30.0
97 const char* charOptionNames[] = { "collision_mode", // stop/decrease
102 while (boolOptionNames[i][0])
104 _boolOptions.insert( boolOptionNames[i] );
105 _option2value[boolOptionNames[i++]].clear();
108 while (intOptionNames[i][0])
109 _option2value[intOptionNames[i++]].clear();
112 while (doubleOptionNames[i][0]) {
113 _doubleOptions.insert(doubleOptionNames[i]);
114 _option2value[doubleOptionNames[i++]].clear();
117 while (charOptionNames[i][0]) {
118 _charOptions.insert(charOptionNames[i]);
119 _option2value[charOptionNames[i++]].clear();
122 // default values to be used while MG meshing
124 _defaultOptionValues["add_multinormals" ] = "no";
125 _defaultOptionValues["smooth_normals" ] = "no";
126 _defaultOptionValues["max_number_of_threads" ] = "4";
127 //_defaultOptionValues["global_physical_size" ] = "0";
128 _defaultOptionValues["gradation" ] = "2";
129 //_defaultOptionValues["boundary_layer_max_element_angle"] = "165";
130 _defaultOptionValues["multinormal_angle_threshold" ] = "30";
131 _defaultOptionValues["collision_mode" ] = "stop";
134 // check validity of option names of _defaultOptionValues
135 TOptionValues::iterator n2v = _defaultOptionValues.begin();
136 for ( ; n2v != _defaultOptionValues.end(); ++n2v )
137 ASSERT( _option2value.count( n2v->first ));
138 ASSERT( _option2value.size() == _defaultOptionValues.size() );
142 //=======================================================================
143 //function : SetHeightIsRelative
144 //=======================================================================
146 void HYBRIDPlugin_Hypothesis::SetHeightIsRelative(bool isRelative)
148 if ( myHeightIsRelative != isRelative ) {
149 myHeightIsRelative = isRelative;
150 NotifySubMeshesHypothesisModification();
154 //=======================================================================
155 //function : SetBoundaryLayersMaxElemAngle
156 //=======================================================================
158 void HYBRIDPlugin_Hypothesis::SetBoundaryLayersMaxElemAngle( double angle )
160 if ( myBoundaryLayersMaxElemAngle != angle ) {
161 myBoundaryLayersMaxElemAngle = angle;
162 NotifySubMeshesHypothesisModification();
167 //=======================================================================
168 //function : SetLayersOnAllWrap
169 //=======================================================================
171 void HYBRIDPlugin_Hypothesis::SetLayersOnAllWrap(bool toMesh)
173 if ( myLayersOnAllWrap != toMesh ) {
174 myLayersOnAllWrap = toMesh;
175 NotifySubMeshesHypothesisModification();
179 //=======================================================================
180 //function : GetLayersOnAllWrap
181 //=======================================================================
183 bool HYBRIDPlugin_Hypothesis::GetLayersOnAllWrap(bool /*checkFreeOption*/) const
185 return myLayersOnAllWrap;
188 //=======================================================================
189 //function : SetFacesWithLayers
190 //purpose : Set IDs of faces to grow the layers on
191 //=======================================================================
193 bool HYBRIDPlugin_Hypothesis::SetFacesWithLayers(const std::vector<int>& theVal)
195 if ( myFacesWithLayers != theVal )
197 myFacesWithLayers = theVal;
198 NotifySubMeshesHypothesisModification();
204 //=======================================================================
205 //function : GetFacesWithLayers
206 //purpose : Return IDs of faces to grow the layers on
207 //=======================================================================
209 const std::vector<int>& HYBRIDPlugin_Hypothesis::GetFacesWithLayers() const
211 return myFacesWithLayers;
214 //=======================================================================
215 //function : SetFacesWithImprinting
216 //purpose : Set IDs of faces to grow the layers on
217 //=======================================================================
219 bool HYBRIDPlugin_Hypothesis::SetFacesWithImprinting(const std::vector<int>& theVal)
221 if ( myFacesWithImprinting != theVal )
223 myFacesWithImprinting = theVal;
224 NotifySubMeshesHypothesisModification();
230 //=======================================================================
231 //function : GetFacesWithImprinting
232 //purpose : Return IDs of faces to grow the layers on
233 //=======================================================================
235 const std::vector<int>& HYBRIDPlugin_Hypothesis::GetFacesWithImprinting() const
237 return myFacesWithImprinting;
240 //=======================================================================
241 //function : SetFacesWithSnapping
242 //purpose : Set IDs of faces that already have surface layers
243 //=======================================================================
245 bool HYBRIDPlugin_Hypothesis::SetFacesWithSnapping(const std::vector<int>& theVal)
247 if ( myFacesWithSnapping != theVal )
249 myFacesWithSnapping = theVal;
250 NotifySubMeshesHypothesisModification();
256 //=======================================================================
257 //function : GetFacesWithSnapping
258 //purpose : Return IDs of faces that already have surface layers
259 //=======================================================================
261 const std::vector<int>& HYBRIDPlugin_Hypothesis::GetFacesWithSnapping() const
263 return myFacesWithSnapping;
266 //=======================================================================
267 //function : SetToMeshHoles
268 //=======================================================================
270 void HYBRIDPlugin_Hypothesis::SetToMeshHoles(bool toMesh)
272 if ( myToMeshHoles != toMesh ) {
273 myToMeshHoles = toMesh;
274 NotifySubMeshesHypothesisModification();
278 //=======================================================================
279 //function : GetToMeshHoles
280 //=======================================================================
282 bool HYBRIDPlugin_Hypothesis::GetToMeshHoles(bool /*checkFreeOption*/) const
284 return myToMeshHoles;
287 //=======================================================================
288 //function : SetToMakeGroupsOfDomains
289 //=======================================================================
291 void HYBRIDPlugin_Hypothesis::SetToMakeGroupsOfDomains(bool toMakeGroups)
293 if ( myToMakeGroupsOfDomains != toMakeGroups ) {
294 myToMakeGroupsOfDomains = toMakeGroups;
295 NotifySubMeshesHypothesisModification();
299 //=======================================================================
300 //function : GetToMakeGroupsOfDomains
301 //=======================================================================
303 bool HYBRIDPlugin_Hypothesis::GetToMakeGroupsOfDomains() const
305 return myToMakeGroupsOfDomains;
308 //=======================================================================
309 //function : GetToMakeGroupsOfDomains
310 //=======================================================================
312 bool HYBRIDPlugin_Hypothesis::GetToMakeGroupsOfDomains(const HYBRIDPlugin_Hypothesis* hyp)
315 if ( hyp ) res = /*hyp->GetToMeshHoles(true) &&*/ hyp->GetToMakeGroupsOfDomains();
316 else res = /*DefaultMeshHoles() &&*/ DefaultToMakeGroupsOfDomains();
320 //=======================================================================
321 //function : SetMaximumMemory
322 //=======================================================================
324 void HYBRIDPlugin_Hypothesis::SetMaximumMemory(double MB)
326 if ( myMaximumMemory != MB ) {
327 myMaximumMemory = MB;
328 NotifySubMeshesHypothesisModification();
332 //=======================================================================
333 //function : GetMaximumMemory
334 // * automatic memory adjustment mode. Default is zero
335 //=======================================================================
337 double HYBRIDPlugin_Hypothesis::GetMaximumMemory() const
339 return myMaximumMemory;
342 //=======================================================================
343 //function : SetInitialMemory
344 //=======================================================================
346 void HYBRIDPlugin_Hypothesis::SetInitialMemory(double MB)
348 if ( myInitialMemory != MB ) {
349 myInitialMemory = MB;
350 NotifySubMeshesHypothesisModification();
354 //=======================================================================
355 //function : GetInitialMemory
356 //=======================================================================
358 double HYBRIDPlugin_Hypothesis::GetInitialMemory() const
360 return myInitialMemory;
363 //=======================================================================
364 //function : SetOptimizationLevel
365 //=======================================================================
367 void HYBRIDPlugin_Hypothesis::SetOptimizationLevel(OptimizationLevel level)
369 if ( myOptimizationLevel != level ) {
370 myOptimizationLevel = level;
371 NotifySubMeshesHypothesisModification();
375 //=======================================================================
376 //function : GetOptimizationLevel
377 //=======================================================================
378 HYBRIDPlugin_Hypothesis::OptimizationLevel HYBRIDPlugin_Hypothesis::GetOptimizationLevel() const
380 return (OptimizationLevel) myOptimizationLevel;
383 //=======================================================================
384 //function : SetCollisionMode
385 //=======================================================================
386 void HYBRIDPlugin_Hypothesis::SetCollisionMode(CollisionMode mode)
388 SetOptionValue( "collision_mode", mode == Decrease ? "decrease" : "stop" );
389 myCollisionMode = mode;
392 //=======================================================================
393 //function : GetCollisionMode
394 //=======================================================================
395 HYBRIDPlugin_Hypothesis::CollisionMode HYBRIDPlugin_Hypothesis::GetCollisionMode() const
397 return (CollisionMode) myCollisionMode;
400 //=======================================================================
401 //function : SetBoundaryLayersGrowth
402 //=======================================================================
403 void HYBRIDPlugin_Hypothesis::SetBoundaryLayersGrowth(BoundaryLayersGrowth mode)
405 if ( myBoundaryLayersGrowth != mode ) {
406 myBoundaryLayersGrowth = mode;
407 NotifySubMeshesHypothesisModification();
411 //=======================================================================
412 //function : GetBoundaryLayersGrowth
413 //=======================================================================
414 HYBRIDPlugin_Hypothesis::BoundaryLayersGrowth HYBRIDPlugin_Hypothesis::GetBoundaryLayersGrowth() const
416 return (BoundaryLayersGrowth) myBoundaryLayersGrowth;
419 //=======================================================================
420 //function : SetElementGeneration
421 //=======================================================================
422 void HYBRIDPlugin_Hypothesis::SetElementGeneration(ElementGeneration mode)
424 if ( myElementGeneration != mode ) {
425 myElementGeneration = mode;
426 NotifySubMeshesHypothesisModification();
430 //=======================================================================
431 //function : GetElementGeneration
432 //=======================================================================
433 HYBRIDPlugin_Hypothesis::ElementGeneration HYBRIDPlugin_Hypothesis::GetElementGeneration() const
435 return (ElementGeneration) myElementGeneration;
438 //=======================================================================
439 //function : SetAddMultinormals
440 //=======================================================================
441 void HYBRIDPlugin_Hypothesis::SetAddMultinormals(bool toAddMultinormals)
443 SetOptionValue( "add_multinormals", toAddMultinormals ? "yes" : "no" );
444 myAddMultinormals = toAddMultinormals;
447 //=======================================================================
448 //function : GetAddMultinormals
449 //=======================================================================
451 bool HYBRIDPlugin_Hypothesis::GetAddMultinormals() const
453 return myAddMultinormals;
456 //=======================================================================
457 //function : SetSmoothNormals
458 //=======================================================================
460 void HYBRIDPlugin_Hypothesis::SetSmoothNormals(bool toSmoothNormals)
462 SetOptionValue( "smooth_normals", toSmoothNormals ? "yes" : "no" );
463 mySmoothNormals = toSmoothNormals;
466 //=======================================================================
467 //function : GetSmoothNormals
468 //=======================================================================
470 bool HYBRIDPlugin_Hypothesis::GetSmoothNormals() const
472 return mySmoothNormals;
475 //=======================================================================
476 //function : SetHeightFirstLayer
477 //=======================================================================
479 void HYBRIDPlugin_Hypothesis::SetHeightFirstLayer(double toHeightFirstLayer)
481 if ( myHeightFirstLayer != toHeightFirstLayer ) {
482 myHeightFirstLayer = toHeightFirstLayer;
483 NotifySubMeshesHypothesisModification();
487 //=======================================================================
488 //function : GetHeightFirstLayer
489 //=======================================================================
491 double HYBRIDPlugin_Hypothesis::GetHeightFirstLayer() const
493 return myHeightFirstLayer;
496 //=======================================================================
497 //function : SetBoundaryLayersProgression
498 //=======================================================================
500 void HYBRIDPlugin_Hypothesis::SetBoundaryLayersProgression(double toBoundaryLayersProgression)
502 if ( myBoundaryLayersProgression != toBoundaryLayersProgression ) {
503 myBoundaryLayersProgression = toBoundaryLayersProgression;
504 NotifySubMeshesHypothesisModification();
508 //=======================================================================
509 //function : GetBoundaryLayersProgression
510 //=======================================================================
512 double HYBRIDPlugin_Hypothesis::GetBoundaryLayersProgression() const
514 return myBoundaryLayersProgression;
517 //=======================================================================
518 //function : SetCoreSize
519 //=======================================================================
521 void HYBRIDPlugin_Hypothesis::SetCoreSize(double toCoreSize)
523 if ( myCoreSize != toCoreSize ) {
524 myCoreSize = toCoreSize;
525 NotifySubMeshesHypothesisModification();
529 //=======================================================================
530 //function : GetCoreSize
531 //=======================================================================
533 double HYBRIDPlugin_Hypothesis::GetCoreSize() const
538 //=======================================================================
539 //function : SetMultinormalsAngle
540 //=======================================================================
542 void HYBRIDPlugin_Hypothesis::SetMultinormalsAngle(double toMultinormalsAngle)
544 SetOptionValue( "multinormal_angle_threshold", SMESH_Comment( toMultinormalsAngle ));
545 myMultinormalsAngle = toMultinormalsAngle;
548 //=======================================================================
549 //function : GetMultinormalsAngle
550 //=======================================================================
552 double HYBRIDPlugin_Hypothesis::GetMultinormalsAngle() const
554 return myMultinormalsAngle;
557 //=======================================================================
558 //function : SetNbOfBoundaryLayers
559 //=======================================================================
561 void HYBRIDPlugin_Hypothesis::SetNbOfBoundaryLayers(short toNbOfBoundaryLayers)
563 if ( myNbOfBoundaryLayers != toNbOfBoundaryLayers ) {
564 myNbOfBoundaryLayers = toNbOfBoundaryLayers;
565 NotifySubMeshesHypothesisModification();
569 //=======================================================================
570 //function : GetCoreSize
571 //=======================================================================
573 short HYBRIDPlugin_Hypothesis::GetNbOfBoundaryLayers() const
575 return myNbOfBoundaryLayers;
579 /////////////////////////////////////////////////////////////////////////
582 //=======================================================================
583 //function : SetWorkingDirectory
584 //=======================================================================
586 void HYBRIDPlugin_Hypothesis::SetWorkingDirectory(const std::string& path)
588 if ( myWorkingDirectory != path ) {
589 myWorkingDirectory = path;
590 NotifySubMeshesHypothesisModification();
594 //=======================================================================
595 //function : GetWorkingDirectory
596 //=======================================================================
598 std::string HYBRIDPlugin_Hypothesis::GetWorkingDirectory() const
600 return myWorkingDirectory;
603 //=======================================================================
604 //function : SetKeepFiles
605 //=======================================================================
607 void HYBRIDPlugin_Hypothesis::SetKeepFiles(bool toKeep)
609 if ( myKeepFiles != toKeep ) {
610 myKeepFiles = toKeep;
611 NotifySubMeshesHypothesisModification();
615 //=======================================================================
616 //function : GetKeepFiles
617 //=======================================================================
619 bool HYBRIDPlugin_Hypothesis::GetKeepFiles() const
624 //=======================================================================
625 //function : SetVerboseLevel
626 //=======================================================================
628 void HYBRIDPlugin_Hypothesis::SetVerboseLevel(short level)
630 if ( myVerboseLevel != level ) {
631 myVerboseLevel = level;
632 NotifySubMeshesHypothesisModification();
636 //=======================================================================
637 //function : GetVerboseLevel
638 //=======================================================================
640 short HYBRIDPlugin_Hypothesis::GetVerboseLevel() const
642 return myVerboseLevel;
645 //=======================================================================
646 //function : SetToCreateNewNodes
647 //=======================================================================
649 void HYBRIDPlugin_Hypothesis::SetToCreateNewNodes(bool toCreate)
651 if ( myToCreateNewNodes != toCreate ) {
652 myToCreateNewNodes = toCreate;
653 NotifySubMeshesHypothesisModification();
657 //=======================================================================
658 //function : GetToCreateNewNodes
659 //=======================================================================
661 bool HYBRIDPlugin_Hypothesis::GetToCreateNewNodes() const
663 return myToCreateNewNodes;
666 //=======================================================================
667 //function : SetToUseBoundaryRecoveryVersion
668 //=======================================================================
670 void HYBRIDPlugin_Hypothesis::SetToUseBoundaryRecoveryVersion(bool toUse)
672 if ( myToUseBoundaryRecoveryVersion != toUse ) {
673 myToUseBoundaryRecoveryVersion = toUse;
674 NotifySubMeshesHypothesisModification();
678 //=======================================================================
679 //function : GetToUseBoundaryRecoveryVersion
680 //=======================================================================
682 bool HYBRIDPlugin_Hypothesis::GetToUseBoundaryRecoveryVersion() const
684 return myToUseBoundaryRecoveryVersion;
687 //=======================================================================
688 //function : SetFEMCorrection
689 //=======================================================================
691 void HYBRIDPlugin_Hypothesis::SetFEMCorrection(bool toUseFem)
693 if ( myToUseFemCorrection != toUseFem ) {
694 myToUseFemCorrection = toUseFem;
695 NotifySubMeshesHypothesisModification();
699 //=======================================================================
700 //function : GetFEMCorrection
701 //=======================================================================
703 bool HYBRIDPlugin_Hypothesis::GetFEMCorrection() const
705 return myToUseFemCorrection;
708 //=======================================================================
709 //function : SetToRemoveCentralPoint
710 //=======================================================================
712 void HYBRIDPlugin_Hypothesis::SetToRemoveCentralPoint(bool toRemove)
714 if ( myToRemoveCentralPoint != toRemove ) {
715 myToRemoveCentralPoint = toRemove;
716 NotifySubMeshesHypothesisModification();
720 //=======================================================================
721 //function : GetToRemoveCentralPoint
722 //=======================================================================
724 bool HYBRIDPlugin_Hypothesis::GetToRemoveCentralPoint() const
726 return myToRemoveCentralPoint;
729 //=======================================================================
730 //function : SetAdvancedOption
731 //=======================================================================
733 void HYBRIDPlugin_Hypothesis::SetAdvancedOption(const std::string& option)
735 size_t wsPos = option.find(' ');
736 if ( wsPos == std::string::npos )
738 SetOptionValue( option, "" );
742 std::string opt( option, 0, wsPos );
743 std::string val( option, wsPos + 1 );
744 SetOptionValue( opt, val );
748 //=======================================================================
749 //function : GetAdvancedOption
750 //=======================================================================
752 std::string HYBRIDPlugin_Hypothesis::GetAdvancedOption() const
756 TOptionValues::const_iterator o2v = _option2value.begin();
757 for ( ; o2v != _option2value.end(); ++o2v )
758 if ( !o2v->second.empty() )
762 txt << o2v->first << " " << o2v->second;
764 for ( o2v = _customOption2value.begin(); o2v != _customOption2value.end(); ++o2v )
768 txt << o2v->first << " " << o2v->second;
773 //=======================================================================
774 //function : SetGradation
775 //=======================================================================
777 void HYBRIDPlugin_Hypothesis::SetGradation(double gradation)
779 SetOptionValue( "gradation", SMESH_Comment( gradation ));
780 myGradation = gradation;
783 //=======================================================================
784 //function : GetGradation
785 //=======================================================================
787 double HYBRIDPlugin_Hypothesis::GetGradation() const
792 //=======================================================================
793 //function : SetStandardOutputLog
794 //=======================================================================
796 void HYBRIDPlugin_Hypothesis::SetStandardOutputLog(bool logInStandardOutput)
798 if ( myLogInStandardOutput != logInStandardOutput ) {
799 myLogInStandardOutput = logInStandardOutput;
800 NotifySubMeshesHypothesisModification();
804 //=======================================================================
805 //function : GetStandardOutputLog
806 //=======================================================================
808 bool HYBRIDPlugin_Hypothesis::GetStandardOutputLog() const
810 return myLogInStandardOutput;
813 //=======================================================================
814 //function : SetRemoveLogOnSuccess
815 //=======================================================================
817 void HYBRIDPlugin_Hypothesis::SetRemoveLogOnSuccess(bool removeLogOnSuccess)
819 if ( myRemoveLogOnSuccess != removeLogOnSuccess ) {
820 myRemoveLogOnSuccess = removeLogOnSuccess;
821 NotifySubMeshesHypothesisModification();
825 //=======================================================================
826 //function : GetRemoveLogOnSuccess
827 //=======================================================================
829 bool HYBRIDPlugin_Hypothesis::GetRemoveLogOnSuccess() const
831 return myRemoveLogOnSuccess;
834 //=======================================================================
835 //function : SetEnforcedVertex
836 //=======================================================================
838 bool HYBRIDPlugin_Hypothesis::SetEnforcedVertex(std::string theName, std::string theEntry, std::string theGroupName,
839 double size, double x, double y, double z, bool isCompound)
841 bool toNotify = false;
842 bool toCreate = true;
844 THYBRIDEnforcedVertex *oldEnVertex;
845 THYBRIDEnforcedVertex *newEnfVertex = new THYBRIDEnforcedVertex();
846 newEnfVertex->name = theName;
847 newEnfVertex->geomEntry = theEntry;
848 newEnfVertex->coords.clear();
850 newEnfVertex->coords.push_back(x);
851 newEnfVertex->coords.push_back(y);
852 newEnfVertex->coords.push_back(z);
854 newEnfVertex->groupName = theGroupName;
855 newEnfVertex->size = size;
856 newEnfVertex->isCompound = isCompound;
859 // update _enfVertexList
860 THYBRIDEnforcedVertexList::iterator it = _enfVertexList.find(newEnfVertex);
861 if (it != _enfVertexList.end()) {
864 if (oldEnVertex->name != theName) {
865 oldEnVertex->name = theName;
868 if (oldEnVertex->groupName != theGroupName) {
869 oldEnVertex->groupName = theGroupName;
872 if (oldEnVertex->size != size) {
873 oldEnVertex->size = size;
877 // update map coords / enf vertex if needed
878 if (oldEnVertex->coords.size()) {
879 _coordsEnfVertexMap[oldEnVertex->coords] = oldEnVertex;
880 _enfVertexCoordsSizeList[oldEnVertex->coords] = size;
883 // update map geom entry / enf vertex if needed
884 if (oldEnVertex->geomEntry != "") {
885 _geomEntryEnfVertexMap[oldEnVertex->geomEntry] = oldEnVertex;
886 _enfVertexEntrySizeList[oldEnVertex->geomEntry] = size;
891 // //////// CREATE ////////////
894 _enfVertexList.insert(newEnfVertex);
895 if (theEntry == "") {
896 _coordsEnfVertexMap[newEnfVertex->coords] = newEnfVertex;
897 _enfVertexCoordsSizeList[newEnfVertex->coords] = size;
900 _geomEntryEnfVertexMap[newEnfVertex->geomEntry] = newEnfVertex;
901 _enfVertexEntrySizeList[newEnfVertex->geomEntry] = size;
906 NotifySubMeshesHypothesisModification();
912 //=======================================================================
913 //function : SetEnforcedMesh
914 //=======================================================================
915 bool HYBRIDPlugin_Hypothesis::SetEnforcedMesh(SMESH_Mesh& theMesh, SMESH::ElementType elementType, std::string name, std::string entry, std::string groupName)
917 TIDSortedElemSet theElemSet;
918 SMDS_ElemIteratorPtr eIt = theMesh.GetMeshDS()->elementsIterator(SMDSAbs_ElementType(elementType));
919 while ( eIt->more() )
920 theElemSet.insert( eIt->next() );
921 bool added = SetEnforcedElements( theElemSet, elementType, groupName);
923 THYBRIDEnforcedMesh* newEnfMesh = new THYBRIDEnforcedMesh();
924 newEnfMesh->persistID = theMesh.GetMeshDS()->GetPersistentId();
925 newEnfMesh->name = name;
926 newEnfMesh->entry = entry;
927 newEnfMesh->elementType = elementType;
928 newEnfMesh->groupName = groupName;
930 THYBRIDEnforcedMeshList::iterator it = _enfMeshList.find(newEnfMesh);
931 if (it == _enfMeshList.end()) {
932 _entryEnfMeshMap[entry].insert(newEnfMesh);
933 _enfMeshList.insert(newEnfMesh);
942 //=======================================================================
943 //function : SetEnforcedGroup
944 //=======================================================================
945 bool HYBRIDPlugin_Hypothesis::SetEnforcedGroup(const SMESHDS_Mesh* theMeshDS, SMESH::smIdType_array_var theIDs, SMESH::ElementType elementType, std::string name, std::string entry, std::string groupName)
947 TIDSortedElemSet theElemSet;
948 if ( theIDs->length() == 0 ){MESSAGE("The source group is empty");}
949 for ( CORBA::ULong i = 0; i < theIDs->length(); i++)
951 SMESH::smIdType ind = theIDs[i];
952 if (elementType == SMESH::NODE)
954 const SMDS_MeshNode * node = theMeshDS->FindNode(ind);
956 theElemSet.insert( node );
960 const SMDS_MeshElement * elem = theMeshDS->FindElement(ind);
962 theElemSet.insert( elem );
966 // SMDS_ElemIteratorPtr it = theGroup->GetGroupDS()->GetElements();
967 // while ( it->more() )
968 // theElemSet.insert( it->next() );
970 bool added = SetEnforcedElements( theElemSet, elementType, groupName);
972 THYBRIDEnforcedMesh* newEnfMesh = new THYBRIDEnforcedMesh();
973 newEnfMesh->name = name;
974 newEnfMesh->entry = entry;
975 newEnfMesh->elementType = elementType;
976 newEnfMesh->groupName = groupName;
978 THYBRIDEnforcedMeshList::iterator it = _enfMeshList.find(newEnfMesh);
979 if (it == _enfMeshList.end()) {
980 _entryEnfMeshMap[entry].insert(newEnfMesh);
981 _enfMeshList.insert(newEnfMesh);
987 //=======================================================================
988 //function : SetEnforcedElements
989 //=======================================================================
990 bool HYBRIDPlugin_Hypothesis::SetEnforcedElements(TIDSortedElemSet theElemSet, SMESH::ElementType elementType, std::string groupName)
992 TIDSortedElemSet::const_iterator it = theElemSet.begin();
993 const SMDS_MeshElement* elem;
994 const SMDS_MeshNode* node;
996 std::pair<TIDSortedNodeGroupMap::iterator,bool> nodeRet;
997 std::pair<TIDSortedElemGroupMap::iterator,bool> elemRet;
999 for (;it != theElemSet.end();++it)
1002 switch (elementType) {
1004 node = dynamic_cast<const SMDS_MeshNode*>(elem);
1006 nodeRet = _enfNodes.insert(make_pair(node,groupName));
1007 added = added && nodeRet.second;
1008 std::string msg = added ? "yes":"no";
1011 SMDS_ElemIteratorPtr nodeIt = elem->nodesIterator();
1012 for (;nodeIt->more();) {
1013 node = dynamic_cast<const SMDS_MeshNode*>(nodeIt->next());
1014 nodeRet = _enfNodes.insert(make_pair(node,groupName));
1015 added = added && nodeRet.second;
1021 if (elem->GetType() == SMDSAbs_Edge) {
1022 elemRet = _enfEdges.insert(make_pair(elem,groupName));
1023 added = added && elemRet.second;
1027 if (elem->GetType() == SMDSAbs_Face)
1029 if (elem->NbCornerNodes() == 3) {
1030 elemRet = _enfTriangles.insert(make_pair(elem,groupName));
1031 added = added && elemRet.second;
1040 NotifySubMeshesHypothesisModification();
1045 //=======================================================================
1046 //function : GetEnforcedVertex
1047 //=======================================================================
1049 HYBRIDPlugin_Hypothesis::THYBRIDEnforcedVertex* HYBRIDPlugin_Hypothesis::GetEnforcedVertex(double x, double y, double z)
1051 std::vector<double> coord(3);
1055 if (_coordsEnfVertexMap.count(coord)>0)
1056 return _coordsEnfVertexMap[coord];
1057 std::ostringstream msg ;
1058 msg << "No enforced vertex at " << x << ", " << y << ", " << z;
1059 throw std::invalid_argument(msg.str());
1062 HYBRIDPlugin_Hypothesis::THYBRIDEnforcedVertex* HYBRIDPlugin_Hypothesis::GetEnforcedVertex(const std::string theEntry)
1064 if (_geomEntryEnfVertexMap.count(theEntry)>0)
1065 return _geomEntryEnfVertexMap[theEntry];
1067 std::ostringstream msg ;
1068 msg << "No enforced vertex with entry " << theEntry;
1069 throw std::invalid_argument(msg.str());
1072 //=======================================================================
1073 //function : RemoveEnforcedVertex
1074 //=======================================================================
1076 bool HYBRIDPlugin_Hypothesis::RemoveEnforcedVertex(double x, double y, double z, const std::string theEntry)
1078 bool toNotify = false;
1079 std::ostringstream msg;
1080 THYBRIDEnforcedVertex *oldEnfVertex;
1081 std::vector<double> coords(3);
1086 // check that enf vertex with given enf vertex entry exists
1087 TGeomEntryHYBRIDEnforcedVertexMap::iterator it_enfVertexEntry = _geomEntryEnfVertexMap.find(theEntry);
1088 if (it_enfVertexEntry != _geomEntryEnfVertexMap.end()) {
1090 oldEnfVertex = it_enfVertexEntry->second;
1091 _geomEntryEnfVertexMap.erase(it_enfVertexEntry);
1094 // check that enf vertex with given coords exists
1095 TCoordsHYBRIDEnforcedVertexMap::iterator it_coords_enf = _coordsEnfVertexMap.find(coords);
1096 if (it_coords_enf != _coordsEnfVertexMap.end()) {
1098 oldEnfVertex = it_coords_enf->second;
1099 _coordsEnfVertexMap.erase(it_coords_enf);
1100 _enfVertexCoordsSizeList.erase(_enfVertexCoordsSizeList.find(coords));
1103 throw std::invalid_argument(msg.str());
1108 // update _enfVertexList
1109 THYBRIDEnforcedVertexList::iterator it = _enfVertexList.find(oldEnfVertex);
1110 if (it != _enfVertexList.end()) {
1111 if ((*it)->groupName != "")
1112 _groupsToRemove.insert((*it)->groupName);
1113 _enfVertexList.erase(it);
1118 NotifySubMeshesHypothesisModification();
1123 //=======================================================================
1124 //function : ClearEnforcedVertices
1125 //=======================================================================
1126 void HYBRIDPlugin_Hypothesis::ClearEnforcedVertices()
1128 THYBRIDEnforcedVertexList::const_iterator it = _enfVertexList.begin();
1129 for(;it != _enfVertexList.end();++it) {
1130 if ((*it)->groupName != "")
1131 _groupsToRemove.insert((*it)->groupName);
1133 _enfVertexList.clear();
1134 _coordsEnfVertexMap.clear();
1135 _geomEntryEnfVertexMap.clear();
1136 _enfVertexCoordsSizeList.clear();
1137 _enfVertexEntrySizeList.clear();
1138 NotifySubMeshesHypothesisModification();
1141 //=======================================================================
1142 //function : ClearEnforcedMeshes
1143 //=======================================================================
1144 void HYBRIDPlugin_Hypothesis::ClearEnforcedMeshes()
1146 THYBRIDEnforcedMeshList::const_iterator it = _enfMeshList.begin();
1147 for(;it != _enfMeshList.end();++it) {
1148 if ((*it)->groupName != "")
1149 _groupsToRemove.insert((*it)->groupName);
1153 _enfTriangles.clear();
1154 _nodeIDToSizeMap.clear();
1155 _enfMeshList.clear();
1156 _entryEnfMeshMap.clear();
1157 NotifySubMeshesHypothesisModification();
1160 //================================================================================
1162 * \brief At mesh loading, restore enforced elements by just loaded enforced meshes
1164 //================================================================================
1166 void HYBRIDPlugin_Hypothesis::RestoreEnfElemsByMeshes()
1168 THYBRIDEnforcedMeshList::const_iterator it = _enfMeshList.begin();
1169 for(;it != _enfMeshList.end();++it) {
1170 THYBRIDEnforcedMesh* enfMesh = *it;
1171 if ( SMESH_Mesh* mesh = GetMeshByPersistentID( enfMesh->persistID ))
1172 SetEnforcedMesh( *mesh,
1173 enfMesh->elementType,
1176 enfMesh->groupName );
1177 enfMesh->persistID = -1; // not to restore again
1181 //=======================================================================
1182 //function : SetGroupsToRemove
1183 //=======================================================================
1185 void HYBRIDPlugin_Hypothesis::ClearGroupsToRemove()
1187 _groupsToRemove.clear();
1191 //=======================================================================
1192 //function : DefaultLayersOnAllWrap
1193 //=======================================================================
1195 bool HYBRIDPlugin_Hypothesis::DefaultLayersOnAllWrap()
1200 //=======================================================================
1201 //function : DefaultMeshHoles
1202 //=======================================================================
1204 bool HYBRIDPlugin_Hypothesis::DefaultMeshHoles()
1206 return false; // PAL19680
1209 //=======================================================================
1210 //function : DefaultToMakeGroupsOfDomains
1211 //=======================================================================
1213 bool HYBRIDPlugin_Hypothesis::DefaultToMakeGroupsOfDomains()
1215 return false; // issue 0022172
1218 //=======================================================================
1219 //function : DefaultMaximumMemory
1220 //=======================================================================
1223 #include <windows.h>
1224 #elif !defined(__APPLE__)
1225 #include <sys/sysinfo.h>
1228 double HYBRIDPlugin_Hypothesis::DefaultMaximumMemory()
1231 // See http://msdn.microsoft.com/en-us/library/aa366589.aspx
1232 MEMORYSTATUSEX statex;
1233 statex.dwLength = sizeof (statex);
1234 int err = GlobalMemoryStatusEx (&statex);
1237 statex.ullTotalPhys / 1024 / 1024 +
1238 statex.ullTotalPageFile / 1024 / 1024 +
1239 statex.ullTotalVirtual / 1024 / 1024;
1240 return ( 0.7 * totMB );
1242 #elif !defined(__APPLE__)
1244 int err = sysinfo( &si );
1246 int ramMB = si.totalram * si.mem_unit / 1024 / 1024;
1247 return ( 0.7 * ramMB );
1253 //=======================================================================
1254 //function : DefaultInitialMemory
1255 //=======================================================================
1257 double HYBRIDPlugin_Hypothesis::DefaultInitialMemory()
1259 return DefaultMaximumMemory();
1262 //=======================================================================
1263 //function : DefaultCollisionMode
1264 //=======================================================================
1265 short HYBRIDPlugin_Hypothesis::DefaultCollisionMode()
1270 //=======================================================================
1271 //function : DefaultBoundaryLayersGrowth
1272 //=======================================================================
1273 short HYBRIDPlugin_Hypothesis::DefaultBoundaryLayersGrowth()
1275 return Layer_Growth_Inward;
1278 //=======================================================================
1279 //function : DefaultElementGeneration
1280 //=======================================================================
1281 short HYBRIDPlugin_Hypothesis::DefaultElementGeneration()
1283 return Generation_Tetra_Dominant;
1286 //=======================================================================
1287 //function : DefaultOptimizationLevel
1288 //=======================================================================
1289 short HYBRIDPlugin_Hypothesis::DefaultOptimizationLevel()
1294 //=======================================================================
1295 //function : DefaultWorkingDirectory
1296 //=======================================================================
1298 std::string HYBRIDPlugin_Hypothesis::DefaultWorkingDirectory()
1300 std::string aTmpDir;
1302 char *Tmp_dir = getenv("SALOME_TMP_DIR");
1303 if(Tmp_dir != NULL) {
1316 //=======================================================================
1317 //function : DefaultKeepFiles
1318 //=======================================================================
1320 bool HYBRIDPlugin_Hypothesis::DefaultKeepFiles()
1325 //=======================================================================
1326 //function : DefaultRemoveLogOnSuccess
1327 //=======================================================================
1329 bool HYBRIDPlugin_Hypothesis::DefaultRemoveLogOnSuccess()
1335 //=======================================================================
1336 //function : DefaultVerboseLevel
1337 //=======================================================================
1339 short HYBRIDPlugin_Hypothesis::DefaultVerboseLevel()
1344 //=======================================================================
1345 //function : DefaultToCreateNewNodes
1346 //=======================================================================
1348 bool HYBRIDPlugin_Hypothesis::DefaultToCreateNewNodes()
1353 //=======================================================================
1354 //function : DefaultToUseBoundaryRecoveryVersion
1355 //=======================================================================
1357 bool HYBRIDPlugin_Hypothesis::DefaultToUseBoundaryRecoveryVersion()
1362 //=======================================================================
1363 //function : DefaultToUseFEMCorrection
1364 //=======================================================================
1366 bool HYBRIDPlugin_Hypothesis::DefaultToUseFEMCorrection()
1371 //=======================================================================
1372 //function : DefaultToRemoveCentralPoint
1373 //=======================================================================
1375 bool HYBRIDPlugin_Hypothesis::DefaultToRemoveCentralPoint()
1380 //=======================================================================
1381 //function : DefaultGradation
1382 //=======================================================================
1384 double HYBRIDPlugin_Hypothesis::DefaultGradation()
1389 //=======================================================================
1390 //function : DefaultStandardOutputLog
1391 //=======================================================================
1393 bool HYBRIDPlugin_Hypothesis::DefaultStandardOutputLog()
1398 // //=======================================================================
1399 // //function : DefaultID2SizeMap
1400 // //=======================================================================
1402 // HYBRIDPlugin_Hypothesis::TID2SizeMap HYBRIDPlugin_Hypothesis::DefaultID2SizeMap()
1404 // return HYBRIDPlugin_Hypothesis::TID2SizeMap();
1407 //=======================================================================
1408 //function : DefaultAddMultinormals
1409 //=======================================================================
1410 bool HYBRIDPlugin_Hypothesis::DefaultAddMultinormals()
1415 //=======================================================================
1416 //function : DefaultSmoothNormals
1417 //=======================================================================
1418 bool HYBRIDPlugin_Hypothesis::DefaultSmoothNormals()
1423 //=======================================================================
1424 //function : DefaultHeightFirstLayer
1425 //=======================================================================
1426 double HYBRIDPlugin_Hypothesis::DefaultHeightFirstLayer()
1428 return 0.0; //or epsilon?
1431 //=======================================================================
1432 //function : DefaultBoundaryLayersProgression
1433 //=======================================================================
1434 double HYBRIDPlugin_Hypothesis::DefaultBoundaryLayersProgression()
1439 //=======================================================================
1440 //function : DefaultCoreSize
1441 //=======================================================================
1442 double HYBRIDPlugin_Hypothesis::DefaultCoreSize()
1447 //=======================================================================
1448 //function : DefaultMultinormalsAngle
1449 //=======================================================================
1450 double HYBRIDPlugin_Hypothesis::DefaultMultinormalsAngle()
1455 //=======================================================================
1456 //function : DefaultNbOfBoundaryLayers
1457 //=======================================================================
1458 short HYBRIDPlugin_Hypothesis::DefaultNbOfBoundaryLayers()
1463 //=======================================================================
1465 //=======================================================================
1467 std::ostream & HYBRIDPlugin_Hypothesis::SaveTo(std::ostream & save)
1469 save << (int) myBoundaryLayersGrowth << " ";
1470 save << (int) myElementGeneration << " ";
1471 save << (int) myAddMultinormals << " ";
1472 save << (int) mySmoothNormals << " ";
1473 save << (int) myLayersOnAllWrap << " ";
1475 save << myNbOfBoundaryLayers << " ";
1476 save << myHeightFirstLayer << " ";
1477 save << myBoundaryLayersProgression << " ";
1478 save << myMultinormalsAngle << " ";
1480 save << (int) myKeepFiles << " ";
1481 save << myWorkingDirectory << " ";
1482 save << myVerboseLevel << " ";
1483 save << myCoreSize << " ";
1485 // if (!myTextOption.empty()) {
1486 // save << "__OPTIONS_BEGIN__ ";
1487 // save << myTextOption << " ";
1488 // save << "__OPTIONS_END__ ";
1492 THYBRIDEnforcedVertexList::iterator it = _enfVertexList.begin();
1493 if (it != _enfVertexList.end()) {
1494 save << " " << "__ENFORCED_VERTICES_BEGIN__ ";
1495 for ( ; it != _enfVertexList.end(); ++it ) {
1496 THYBRIDEnforcedVertex *enfVertex = (*it);
1497 save << " " << "__BEGIN_VERTEX__";
1498 if (!enfVertex->name.empty()) {
1499 save << " " << "__BEGIN_NAME__";
1500 save << " " << enfVertex->name;
1501 save << " " << "__END_NAME__";
1503 if (!enfVertex->geomEntry.empty()) {
1504 save << " " << "__BEGIN_ENTRY__";
1505 save << " " << enfVertex->geomEntry;
1506 save << " " << enfVertex->isCompound;
1507 save << " " << "__END_ENTRY__";
1509 if (!enfVertex->groupName.empty()) {
1510 save << " " << "__BEGIN_GROUP__";
1511 save << " " << enfVertex->groupName;
1512 save << " " << "__END_GROUP__";
1514 if (enfVertex->coords.size()) {
1515 save << " " << "__BEGIN_COORDS__";
1516 for ( size_t i = 0; i < enfVertex->coords.size(); i++ )
1517 save << " " << enfVertex->coords[i];
1518 save << " " << "__END_COORDS__";
1520 save << " " << "__BEGIN_SIZE__";
1521 save << " " << enfVertex->size;
1522 save << " " << "__END_SIZE__";
1523 save << " " << "__END_VERTEX__";
1525 save << " " << "__ENFORCED_VERTICES_END__ ";
1528 THYBRIDEnforcedMeshList::iterator it_mesh = _enfMeshList.begin();
1529 if (it_mesh != _enfMeshList.end()) {
1530 save << " " << "__ENFORCED_MESHES_BEGIN__ ";
1531 for ( ; it_mesh != _enfMeshList.end(); ++it_mesh ) {
1532 THYBRIDEnforcedMesh *enfMesh = (*it_mesh);
1533 save << " " << "__BEGIN_ENF_MESH__";
1535 save << " " << "__BEGIN_NAME__";
1536 save << " " << enfMesh->name;
1537 save << " " << "__END_NAME__";
1539 save << " " << "__BEGIN_ENTRY__";
1540 save << " " << enfMesh->entry;
1541 save << " " << "__END_ENTRY__";
1543 save << " " << "__BEGIN_ELEM_TYPE__";
1544 save << " " << (int)enfMesh->elementType;
1545 save << " " << "__END_ELEM_TYPE__";
1547 if (!enfMesh->groupName.empty()) {
1548 save << " " << "__BEGIN_GROUP__";
1549 save << " " << enfMesh->groupName;
1550 save << " " << "__END_GROUP__";
1552 save << " " << "__PERSIST_ID__";
1553 save << " " << enfMesh->persistID;
1554 save << " " << "__END_ENF_MESH__";
1555 std::cout << "Saving of enforced mesh " << enfMesh->name.c_str() << " done" << std::endl;
1557 save << " " << "__ENFORCED_MESHES_END__ ";
1560 save << " " << myFacesWithLayers.size();
1561 for ( size_t i = 0; i < myFacesWithLayers.size(); ++i )
1562 save << " " << myFacesWithLayers[i];
1564 save << " " << myFacesWithImprinting.size();
1565 for ( size_t i = 0; i < myFacesWithImprinting.size(); ++i )
1566 save << " " << myFacesWithImprinting[i];
1568 save << " " << myFacesWithSnapping.size();
1569 for ( size_t i = 0; i < myFacesWithSnapping.size(); ++i )
1570 save << " " << myFacesWithSnapping[i];
1572 // New options in 2.9.6 (issue #17784)
1574 save << " " << myHeightIsRelative;
1575 save << " " << myBoundaryLayersMaxElemAngle;
1576 save << " " << myCollisionMode;
1577 save << " " << myGradation;
1578 save << " " << myOptimizationLevel;
1580 save << " " << _option2value.size();
1581 TOptionValues::iterator o2v = _option2value.begin();
1582 for ( ; o2v != _option2value.end(); ++o2v )
1583 save << " -" << o2v->first << " -" << o2v->second;
1585 save << " " << _customOption2value.size();
1586 for ( o2v = _customOption2value.begin(); o2v != _customOption2value.end(); ++o2v )
1587 save << " -" << o2v->first << " -" << o2v->second;
1592 //=======================================================================
1593 //function : LoadFrom
1594 //=======================================================================
1596 std::istream & HYBRIDPlugin_Hypothesis::LoadFrom(std::istream & load)
1602 isOK = static_cast<bool>(load >> i);
1604 myBoundaryLayersGrowth = (short) i;
1606 load.clear(ios::badbit | load.rdstate());
1608 isOK = static_cast<bool>(load >> i);
1610 myElementGeneration = (short) i;
1612 load.clear(ios::badbit | load.rdstate());
1614 isOK = static_cast<bool>(load >> i);
1616 myAddMultinormals = (bool) i;
1618 load.clear(ios::badbit | load.rdstate());
1620 isOK = static_cast<bool>(load >> i);
1622 mySmoothNormals = (bool) i;
1624 load.clear(ios::badbit | load.rdstate());
1626 isOK = static_cast<bool>(load >> i);
1628 myLayersOnAllWrap = (bool) i;
1630 load.clear(ios::badbit | load.rdstate());
1632 isOK = static_cast<bool>(load >> i);
1634 myNbOfBoundaryLayers = (short) i;
1636 load.clear(ios::badbit | load.rdstate());
1638 isOK = static_cast<bool>(load >> d);
1640 myHeightFirstLayer = d;
1642 load.clear(ios::badbit | load.rdstate());
1644 isOK = static_cast<bool>(load >> d);
1646 myBoundaryLayersProgression = d;
1648 load.clear(ios::badbit | load.rdstate());
1650 isOK = static_cast<bool>(load >> d);
1652 myMultinormalsAngle = d;
1654 load.clear(ios::badbit | load.rdstate());
1656 isOK = static_cast<bool>(load >> i);
1658 myKeepFiles = (bool) i;
1660 load.clear(ios::badbit | load.rdstate());
1662 isOK = static_cast<bool>(load >> myWorkingDirectory);
1664 if ( myWorkingDirectory == "0") { // myWorkingDirectory was empty
1665 myKeepFiles = false;
1666 myWorkingDirectory.clear();
1668 else if ( myWorkingDirectory == "1" ) {
1670 myWorkingDirectory.clear();
1674 load.clear(ios::badbit | load.rdstate());
1676 isOK = static_cast<bool>(load >> i);
1678 myVerboseLevel = (short) i;
1680 load.clear(ios::badbit | load.rdstate());
1682 isOK = static_cast<bool>(load >> d);
1686 load.clear(ios::badbit | load.rdstate());
1688 std::string separator;
1689 bool hasOptions = false;
1690 bool hasEnforcedVertices = false;
1691 bool hasEnforcedMeshes = false;
1692 isOK = static_cast<bool>(load >> separator);
1695 if (separator == "__OPTIONS_BEGIN__")
1697 else if (separator == "__ENFORCED_VERTICES_BEGIN__")
1698 hasEnforcedVertices = true;
1699 else if (separator == "__ENFORCED_MESHES_BEGIN__")
1700 hasEnforcedMeshes = true;
1706 isOK = static_cast<bool>(load >> txt);
1708 if (txt == "__OPTIONS_END__") {
1712 // myTextOption += txt;
1718 isOK = static_cast<bool>(load >> separator);
1719 if (isOK && separator == "__ENFORCED_VERTICES_BEGIN__")
1720 hasEnforcedVertices = true;
1721 if (isOK && separator == "__ENFORCED_MESHES_BEGIN__")
1722 hasEnforcedMeshes = true;
1725 if (hasEnforcedVertices) {
1726 std::string txt, name, entry, groupName;
1727 double size, coords[3];
1729 bool hasCoords = false;
1730 isOK = static_cast<bool>(load >> txt); // __BEGIN_VERTEX__
1732 if (txt == "__ENFORCED_VERTICES_END__")
1735 THYBRIDEnforcedVertex *enfVertex = new THYBRIDEnforcedVertex();
1737 isOK = static_cast<bool>(load >> txt);
1738 if (txt == "__END_VERTEX__") {
1739 enfVertex->name = name;
1740 enfVertex->geomEntry = entry;
1741 enfVertex->isCompound = isCompound;
1742 enfVertex->groupName = groupName;
1743 enfVertex->coords.clear();
1745 enfVertex->coords.assign(coords,coords+3);
1747 _enfVertexList.insert(enfVertex);
1749 if (enfVertex->coords.size())
1750 _coordsEnfVertexMap[enfVertex->coords] = enfVertex;
1751 if (!enfVertex->geomEntry.empty())
1752 _geomEntryEnfVertexMap[enfVertex->geomEntry] = enfVertex;
1761 if (txt == "__BEGIN_NAME__") { // __BEGIN_NAME__
1762 while (isOK && (txt != "__END_NAME__")) {
1763 isOK = static_cast<bool>(load >> txt);
1764 if (txt != "__END_NAME__") {
1772 if (txt == "__BEGIN_ENTRY__") { // __BEGIN_ENTRY__
1773 isOK = static_cast<bool>(load >> entry);
1774 isOK = static_cast<bool>(load >> isCompound);
1775 isOK = static_cast<bool>(load >> txt); // __END_ENTRY__
1776 if (txt != "__END_ENTRY__")
1777 throw std::exception();
1780 if (txt == "__BEGIN_GROUP__") { // __BEGIN_GROUP__
1781 while (isOK && (txt != "__END_GROUP__")) {
1782 isOK = static_cast<bool>(load >> txt);
1783 if (txt != "__END_GROUP__") {
1784 if (!groupName.empty())
1791 if (txt == "__BEGIN_COORDS__") { // __BEGIN_COORDS__
1793 isOK = static_cast<bool>(load >> coords[0] >> coords[1] >> coords[2]);
1794 isOK = static_cast<bool>(load >> txt); // __END_COORDS__
1795 if (txt != "__END_COORDS__")
1796 throw std::exception();
1799 if (txt == "__BEGIN_SIZE__") { // __BEGIN_ENTRY__
1800 isOK = static_cast<bool>(load >> size);
1801 isOK = static_cast<bool>(load >> txt); // __END_ENTRY__
1802 if (txt != "__END_SIZE__") {
1803 throw std::exception();
1807 isOK = static_cast<bool>(load >> txt); // __BEGIN_VERTEX__
1811 if (hasEnforcedVertices) {
1812 isOK = static_cast<bool>(load >> separator);
1813 if (isOK && separator == "__ENFORCED_MESHES_BEGIN__")
1814 hasEnforcedMeshes = true;
1817 if (hasEnforcedMeshes) {
1818 std::string txt, name, entry, groupName;
1819 int elementType = -1, persistID = -1;
1820 isOK = static_cast<bool>(load >> txt); // __BEGIN_ENF_MESH__
1823 if (txt == "__ENFORCED_MESHES_END__")
1826 THYBRIDEnforcedMesh *enfMesh = new THYBRIDEnforcedMesh();
1828 isOK = static_cast<bool>(load >> txt);
1829 if (txt == "__END_ENF_MESH__") {
1830 enfMesh->name = name;
1831 enfMesh->entry = entry;
1832 enfMesh->elementType = (SMESH::ElementType)elementType;
1833 enfMesh->groupName = groupName;
1834 enfMesh->persistID = persistID;
1836 _enfMeshList.insert(enfMesh);
1837 std::cout << "Restoring of enforced mesh " <<name << " done" << std::endl;
1847 if (txt == "__BEGIN_NAME__") { // __BEGIN_NAME__
1848 while (isOK && (txt != "__END_NAME__")) {
1849 isOK = static_cast<bool>(load >> txt);
1850 if (txt != "__END_NAME__") {
1858 if (txt == "__BEGIN_ENTRY__") { // __BEGIN_ENTRY__
1859 isOK = static_cast<bool>(load >> entry);
1860 isOK = static_cast<bool>(load >> txt); // __END_ENTRY__
1861 if (txt != "__END_ENTRY__")
1862 throw std::exception();
1865 if (txt == "__BEGIN_ELEM_TYPE__") { // __BEGIN_ELEM_TYPE__
1866 isOK = static_cast<bool>(load >> elementType);
1867 isOK = static_cast<bool>(load >> txt); // __END_ELEM_TYPE__
1868 if (txt != "__END_ELEM_TYPE__")
1869 throw std::exception();
1872 if (txt == "__BEGIN_GROUP__") { // __BEGIN_GROUP__
1873 while (isOK && (txt != "__END_GROUP__")) {
1874 isOK = static_cast<bool>(load >> txt);
1875 if (txt != "__END_GROUP__") {
1876 if (!groupName.empty())
1883 if (txt == "__PERSIST_ID__") {
1884 isOK = static_cast<bool>(load >> persistID);
1886 std::cout << "isOK: " << isOK << std::endl;
1889 isOK = static_cast<bool>(load >> txt); // __BEGIN_ENF_MESH__
1893 if ( hasEnforcedMeshes )
1894 isOK = static_cast<bool>(load >> separator);
1898 i = atoi( separator.c_str() );
1902 myFacesWithLayers.reserve( i );
1903 while (( myFacesWithLayers.size() < myFacesWithLayers.capacity() ) &&
1904 ( isOK = static_cast<bool>(load >> i)) )
1905 myFacesWithLayers.push_back( i );
1909 isOK = static_cast<bool>(load >> separator);
1912 i = atoi( separator.c_str() );
1916 myFacesWithImprinting.reserve( i );
1917 while (( myFacesWithImprinting.size() < myFacesWithImprinting.capacity() ) &&
1918 ( isOK = static_cast<bool>(load >> i)) )
1919 myFacesWithImprinting.push_back( i );
1923 isOK = static_cast<bool>(load >> separator);
1926 i = atoi( separator.c_str() );
1930 myFacesWithSnapping.reserve( i );
1931 while (( myFacesWithSnapping.size() < myFacesWithSnapping.capacity() ) &&
1932 ( isOK = static_cast<bool>(load >> i)) )
1933 myFacesWithSnapping.push_back( i );
1937 // New options in 2.9.6 (issue #17784)
1939 if ( static_cast<bool>(load >> i))
1941 myHeightIsRelative = (bool) i;
1942 load >> myBoundaryLayersMaxElemAngle;
1943 load >> myCollisionMode;
1944 load >> myGradation;
1945 load >> myOptimizationLevel;
1947 std::string option, value;
1948 if ( static_cast<bool>( load >> i ) && i >= 0 )
1950 for ( int nbRead = 0; nbRead < i; ++nbRead )
1952 load >> option >> value;
1953 _option2value[ std::string( option, 1 )] = std::string( value, 1 );
1956 if ( static_cast<bool>( load >> i ) && i >= 0 )
1958 for ( int nbRead = 0; nbRead < i; ++nbRead )
1960 load >> option >> value;
1961 _customOption2value[ std::string( option, 1 )] = std::string( value, 1 );
1969 //=======================================================================
1970 //function : SetParametersByMesh
1971 //=======================================================================
1973 bool HYBRIDPlugin_Hypothesis::SetParametersByMesh(const SMESH_Mesh* ,const TopoDS_Shape&)
1978 //================================================================================
1980 * \brief Sets myToMakeGroupsOfDomains depending on whether theMesh is on shape or not
1982 //================================================================================
1984 bool HYBRIDPlugin_Hypothesis::SetParametersByDefaults(const TDefaults& dflts,
1985 const SMESH_Mesh* /*theMesh*/)
1987 myToMakeGroupsOfDomains = ( !dflts._shape || dflts._shape->IsNull() );
1991 //================================================================================
1993 * \brief Return command to run hybrid mesher excluding file prefix (-f)
1995 //================================================================================
1997 std::string HYBRIDPlugin_Hypothesis::CommandToRun(const HYBRIDPlugin_Hypothesis* hyp)
1999 SMESH_Comment cmd = GetExeName();
2000 // check if any option is overridden by hyp->_option2value
2001 bool p_h = ( hyp && hyp->HasOptionDefined("-h"));
2002 bool p_v = ( hyp && hyp->HasOptionDefined("-v"));
2003 bool p_blsd = ( hyp && hyp->HasOptionDefined("--normal_direction"));
2004 bool p_hotfl = ( hyp && hyp->HasOptionDefined("--boundary_layer_global_initial_height"));
2005 bool p_nobl = ( hyp && hyp->HasOptionDefined("--number_of_boundary_layers"));
2006 bool p_blgp = ( hyp && hyp->HasOptionDefined("--boundary_layer_geometric_progression"));
2007 bool p_eg = ( hyp && hyp->HasOptionDefined("--element_generation"));
2008 bool p_cs = ( hyp && hyp->HasOptionDefined("--global_physical_size"));
2010 bool nolayers = false;
2011 bool layersOnAllWrap = hyp ? hyp->myLayersOnAllWrap : DefaultLayersOnAllWrap();
2019 std::cout << "!!!!! CommandToRun help only !!!! " << cmd << std::endl;
2024 cmd << " --verbose " << hyp->myVerboseLevel;
2027 if ( !p_nobl && hyp ) {
2028 if ( hyp->myNbOfBoundaryLayers < 1 ) nolayers = true;
2030 if ( !p_hotfl && hyp ) {
2031 if ( hyp->myHeightFirstLayer < 1e-50 ) nolayers = true;
2034 if ( !p_blsd && hyp ) {
2035 if ( hyp->myBoundaryLayersGrowth >= 0 && hyp->myBoundaryLayersGrowth <= 1 ) {
2036 const char* value[] = { "-1" , "1" }; // -1 == inside
2037 cmd << " --normal_direction " << value[ hyp->myBoundaryLayersGrowth ];
2041 if ( !p_hotfl && hyp ) {
2042 cmd << " --boundary_layer_global_initial_height " << hyp->myHeightFirstLayer;
2044 if ( hyp && hyp->GetHeightIsRelative() )
2045 cmd << " --boundary_layer_height_relative_to_local_surface_size yes";
2047 if ( !p_nobl && hyp ) {
2048 cmd << " --number_of_boundary_layers " << ( nolayers ? 0 : hyp->myNbOfBoundaryLayers );
2051 if ( !p_blgp && hyp ) {
2052 cmd << " --boundary_layer_geometric_progression " << hyp->myBoundaryLayersProgression;
2055 if ( !nolayers && hyp )
2057 cmd << " --boundary_layer_size_mode " << ( layersOnAllWrap ? "global" : "local" );
2059 if ( hyp->GetBoundaryLayersMaxElemAngle() != hyp->DefaultBoundaryLayersMaxElemAngle() )
2060 cmd << " --boundary_layer_max_element_angle "
2061 << SMESH_Comment( hyp->GetBoundaryLayersMaxElemAngle() );
2063 if ( !layersOnAllWrap )
2065 // faces with layers
2066 const std::vector<int>& faceLayersIDs = hyp->GetFacesWithLayers();
2067 if ( !faceLayersIDs.empty() )
2068 cmd << " --boundary_layer_surface_tags ";
2069 for ( size_t i = 0; i < faceLayersIDs.size(); ++i )
2070 cmd << faceLayersIDs[i] << ",";
2071 if ( !faceLayersIDs.empty() )
2072 cmd << " --boundary_layer_initial_height_on_surface_tags ";
2073 for ( size_t i = 0; i < faceLayersIDs.size(); ++i )
2074 cmd << hyp->myHeightFirstLayer << ",";
2076 // faces with imprinting
2077 const std::vector<int>& faceImprintingIDs = hyp->GetFacesWithImprinting();
2078 if ( !faceImprintingIDs.empty() )
2079 cmd << " --boundary_layer_imprinting yes --boundary_layer_imprinting_tags ";
2080 for ( size_t i = 0; i < faceImprintingIDs.size(); ++i )
2081 cmd << faceImprintingIDs[i] << ",";
2083 // faces with snapping
2084 const std::vector<int>& faceSnappingIDs = hyp->GetFacesWithSnapping();
2085 if ( !faceSnappingIDs.empty() )
2086 cmd << " --boundary_layer_snapping yes --boundary_layer_snapping_tags ";
2087 for ( size_t i = 0; i < faceSnappingIDs.size(); ++i )
2088 cmd << faceSnappingIDs[i] << ",";
2092 if ( !p_eg && hyp ) {
2093 if ( hyp->myElementGeneration >= 0 && hyp->myElementGeneration <= 3 ) {
2094 const char* value[] = { "tetra_dominant" , "hexa_dominant", "cartesian_core", "extrusion_only" };
2095 cmd << " --element_generation " << value[ hyp->myElementGeneration ];
2099 if ( !p_cs && hyp ) {
2100 if ( hyp->myCoreSize > 0 ) {
2101 cmd << " --global_physical_size " << hyp->myCoreSize;
2108 std::string option, value;
2110 const TOptionValues* options[] = { & hyp->_option2value, & hyp->_customOption2value };
2111 for ( int iOp = 0; iOp < 2; ++iOp )
2113 TOptionValues::const_iterator o2v = options[iOp]->begin();
2114 for ( ; o2v != options[iOp]->end(); ++o2v )
2116 option = o2v->first;
2117 value = hyp->GetOptionValue( option, &isDefault );
2121 if ( value.empty() )
2123 if ( hyp->_defaultOptionValues.count( option ))
2124 continue; // non-custom option with no value
2126 if ( option[0] != '-' )
2130 cmd << option << " " << value;
2138 //std::cout << "!!!!!CommandToRun end " << cmd << std::endl;
2143 //================================================================================
2145 * \brief Return a unique file name
2147 //================================================================================
2149 std::string HYBRIDPlugin_Hypothesis::GetFileName(const HYBRIDPlugin_Hypothesis* hyp)
2151 std::string aTmpDir = hyp ? hyp->GetWorkingDirectory() : DefaultWorkingDirectory();
2152 const char lastChar = *aTmpDir.rbegin();
2154 if(lastChar != '\\') aTmpDir+='\\';
2156 if(lastChar != '/') aTmpDir+='/';
2159 SMESH_Comment aGenericName = aTmpDir;
2160 aGenericName << "HYBRID_";
2161 aGenericName << getpid();
2162 aGenericName << "_";
2163 aGenericName << Abs((Standard_Integer)(long) aGenericName.c_str());
2165 return aGenericName;
2168 //================================================================================
2170 * Return the name of executable
2172 //================================================================================
2174 std::string HYBRIDPlugin_Hypothesis::GetExeName()
2176 //call mg-hybrid.bash is script which assumes new project version(s) mg-hybrid.exe in the prerequisite base and special? licence.
2178 return "mg-hybrid.exe";
2180 return "mg-hybrid.bash";
2184 //=============================================================================
2185 void HYBRIDPlugin_Hypothesis::SetOptionValue(const std::string& optionName,
2186 const std::string& optionValue)
2188 TOptionValues::iterator op_val = _option2value.find(optionName);
2189 if (op_val == _option2value.end())
2191 op_val = _customOption2value.find( optionName );
2192 if ( op_val == _customOption2value.end() || op_val->second != optionValue )
2193 NotifySubMeshesHypothesisModification();
2194 _customOption2value[ optionName ] = optionValue;
2198 if (op_val->second != optionValue)
2200 const char* ptr = optionValue.c_str();
2201 // strip white spaces
2202 while (ptr[0] == ' ')
2204 int i = strlen(ptr);
2205 while (i != 0 && ptr[i - 1] == ' ')
2209 std::string typeName;
2212 } else if (_charOptions.count(optionName)) {
2213 // do not check strings
2214 } else if (_doubleOptions.count(optionName)) {
2215 // check if value is double
2216 ToDbl(ptr, &typeOk);
2218 } else if (_boolOptions.count(optionName)) {
2219 // check if value is bool
2220 ToBool(ptr, &typeOk);
2223 // check if value is int
2224 ToInt(ptr, &typeOk);
2225 typeName = "integer";
2227 if ( typeOk ) // check some specific values ?
2232 std::string msg = "Advanced option '" + optionName + "' = '" + optionValue + "' but must be " + typeName;
2233 throw std::invalid_argument(msg);
2235 std::string value( ptr, i );
2236 if ( _defaultOptionValues[ optionName ] == value )
2239 op_val->second = value;
2241 NotifySubMeshesHypothesisModification();
2245 //=============================================================================
2246 //! Return option value. If isDefault provided, it can be a default value,
2247 // then *isDefault == true. If isDefault is not provided, the value will be
2248 // empty if it equals a default one.
2249 std::string HYBRIDPlugin_Hypothesis::GetOptionValue(const std::string& optionName,
2250 bool* isDefault) const
2252 TOptionValues::const_iterator op_val = _option2value.find(optionName);
2253 if (op_val == _option2value.end())
2255 op_val = _customOption2value.find(optionName);
2256 if (op_val == _customOption2value.end())
2258 std::string msg = "Unknown MG-Tetra option: <" + optionName + ">";
2259 throw std::invalid_argument(msg);
2262 std::string val = op_val->second;
2263 if ( isDefault ) *isDefault = ( val.empty() );
2265 if ( val.empty() && isDefault )
2267 op_val = _defaultOptionValues.find( optionName );
2268 if (op_val != _defaultOptionValues.end())
2269 val = op_val->second;
2275 //=============================================================================
2276 bool HYBRIDPlugin_Hypothesis::HasOptionDefined( const std::string& optionName ) const
2278 bool isDefault = false;
2281 GetOptionValue( optionName, &isDefault );
2283 catch ( std::invalid_argument& )
2290 //=============================================================================
2291 void HYBRIDPlugin_Hypothesis::ClearOption(const std::string& optionName)
2293 TOptionValues::iterator op_val = _customOption2value.find(optionName);
2294 if (op_val != _customOption2value.end())
2295 _customOption2value.erase(op_val);
2297 op_val = _option2value.find(optionName);
2298 if (op_val != _option2value.end())
2299 op_val->second.clear();
2303 //=============================================================================
2304 HYBRIDPlugin_Hypothesis::TOptionValues HYBRIDPlugin_Hypothesis::GetOptionValues() const
2307 TOptionValues::const_iterator op_val = _option2value.begin();
2308 for ( ; op_val != _option2value.end(); ++op_val )
2309 vals.insert( make_pair( op_val->first, GetOptionValue( op_val->first, GET_DEFAULT() )));
2314 //================================================================================
2316 * \brief Converts a string to a bool
2318 //================================================================================
2320 bool HYBRIDPlugin_Hypothesis::ToBool(const std::string& str, bool* isOk )
2322 std::string s = str;
2323 if ( isOk ) *isOk = true;
2325 for ( size_t i = 0; i <= s.size(); ++i )
2326 s[i] = tolower( s[i] );
2328 if ( s == "1" || s == "true" || s == "active" || s == "yes" )
2331 if ( s == "0" || s == "false" || s == "inactive" || s == "no" )
2337 std::string msg = "Not a Boolean value:'" + str + "'";
2338 throw std::invalid_argument(msg);
2343 //================================================================================
2345 * \brief Converts a string to a real value
2347 //================================================================================
2349 double HYBRIDPlugin_Hypothesis::ToDbl(const std::string& str, bool* isOk )
2351 if ( str.empty() ) throw std::invalid_argument("Empty value provided");
2354 double val = strtod(&str[0], &endPtr);
2355 bool ok = (&str[0] != endPtr);
2357 if ( isOk ) *isOk = ok;
2361 std::string msg = "Not a real value:'" + str + "'";
2362 throw std::invalid_argument(msg);
2367 //================================================================================
2369 * \brief Converts a string to a integer value
2371 //================================================================================
2373 int HYBRIDPlugin_Hypothesis::ToInt(const std::string& str, bool* isOk )
2375 if ( str.empty() ) throw std::invalid_argument("Empty value provided");
2378 int val = (int)strtol( &str[0], &endPtr, 10);
2379 bool ok = (&str[0] != endPtr);
2381 if ( isOk ) *isOk = ok;
2385 std::string msg = "Not an integer value:'" + str + "'";
2386 throw std::invalid_argument(msg);
2392 HYBRIDPlugin_Hypothesis::THYBRIDEnforcedVertexList HYBRIDPlugin_Hypothesis::GetEnforcedVertices(const HYBRIDPlugin_Hypothesis* hyp)
2394 return hyp ? hyp->_GetEnforcedVertices():THYBRIDEnforcedVertexList();
2397 HYBRIDPlugin_Hypothesis::THYBRIDEnforcedVertexCoordsValues HYBRIDPlugin_Hypothesis::GetEnforcedVerticesCoordsSize (const HYBRIDPlugin_Hypothesis* hyp)
2399 return hyp ? hyp->_GetEnforcedVerticesCoordsSize(): THYBRIDEnforcedVertexCoordsValues();
2402 HYBRIDPlugin_Hypothesis::THYBRIDEnforcedVertexEntryValues HYBRIDPlugin_Hypothesis::GetEnforcedVerticesEntrySize (const HYBRIDPlugin_Hypothesis* hyp)
2404 return hyp ? hyp->_GetEnforcedVerticesEntrySize():THYBRIDEnforcedVertexEntryValues();
2407 HYBRIDPlugin_Hypothesis::TCoordsHYBRIDEnforcedVertexMap HYBRIDPlugin_Hypothesis::GetEnforcedVerticesByCoords (const HYBRIDPlugin_Hypothesis* hyp)
2409 return hyp ? hyp->_GetEnforcedVerticesByCoords():TCoordsHYBRIDEnforcedVertexMap();
2412 HYBRIDPlugin_Hypothesis::TGeomEntryHYBRIDEnforcedVertexMap HYBRIDPlugin_Hypothesis::GetEnforcedVerticesByEntry (const HYBRIDPlugin_Hypothesis* hyp)
2414 return hyp ? hyp->_GetEnforcedVerticesByEntry():TGeomEntryHYBRIDEnforcedVertexMap();
2417 HYBRIDPlugin_Hypothesis::TIDSortedNodeGroupMap HYBRIDPlugin_Hypothesis::GetEnforcedNodes(const HYBRIDPlugin_Hypothesis* hyp)
2419 return hyp ? hyp->_GetEnforcedNodes():TIDSortedNodeGroupMap();
2422 HYBRIDPlugin_Hypothesis::TIDSortedElemGroupMap HYBRIDPlugin_Hypothesis::GetEnforcedEdges(const HYBRIDPlugin_Hypothesis* hyp)
2424 return hyp ? hyp->_GetEnforcedEdges():TIDSortedElemGroupMap();
2427 HYBRIDPlugin_Hypothesis::TIDSortedElemGroupMap HYBRIDPlugin_Hypothesis::GetEnforcedTriangles(const HYBRIDPlugin_Hypothesis* hyp)
2429 return hyp ? hyp->_GetEnforcedTriangles():TIDSortedElemGroupMap();
2432 HYBRIDPlugin_Hypothesis::TID2SizeMap HYBRIDPlugin_Hypothesis::GetNodeIDToSizeMap(const HYBRIDPlugin_Hypothesis* hyp)
2434 return hyp ? hyp->_GetNodeIDToSizeMap():TID2SizeMap();
2437 HYBRIDPlugin_Hypothesis::TSetStrings HYBRIDPlugin_Hypothesis::GetGroupsToRemove(const HYBRIDPlugin_Hypothesis* hyp)
2439 return hyp ? hyp->_GetGroupsToRemove():TSetStrings();