]> SALOME platform Git repositories - plugins/ghs3dplugin.git/blob - src/GHS3DPlugin/GHS3DPlugin_Hypothesis_i.cxx
Salome HOME
edabc43b3ae7c814739a5670e7277912fffb6d41
[plugins/ghs3dplugin.git] / src / GHS3DPlugin / GHS3DPlugin_Hypothesis_i.cxx
1 // Copyright (C) 2004-2016  CEA/DEN, EDF R&D
2 //
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.
7 //
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.
12 //
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
16 //
17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
18 //
19
20 // File      : GHS3DPlugin_Hypothesis_i.cxx
21 // Created   : Wed Apr  2 13:53:01 2008
22 // Author    : Edward AGAPOV (eap)
23 //
24 #include "GHS3DPlugin_Hypothesis_i.hxx"
25
26 #include <SMESH_Gen.hxx>
27 #include <SMESH_PythonDump.hxx>
28
29 #include <Utils_CorbaException.hxx>
30 #include <utilities.h>
31 #include <SMESH_Mesh_i.hxx>
32 #include <SMESH_Group_i.hxx>
33 #include <SMESH_Gen_i.hxx>
34 //#include <SMESH_TypeDefs.hxx>
35 #include <SMESHDS_GroupBase.hxx>
36
37 // SALOME KERNEL includes
38 // #include <SALOMEDSClient.hxx>
39 // #include <SALOMEDSClient_definitions.hxx>
40
41 using namespace std;
42
43 //=======================================================================
44 //function : GHS3DPlugin_Hypothesis_i
45 //=======================================================================
46
47 GHS3DPlugin_Hypothesis_i::GHS3DPlugin_Hypothesis_i (PortableServer::POA_ptr thePOA,
48                                                     ::SMESH_Gen*            theGenImpl)
49   : SALOME::GenericObj_i( thePOA ), 
50     SMESH_Hypothesis_i( thePOA )
51 {
52   myBaseImpl = new ::GHS3DPlugin_Hypothesis (theGenImpl->GetANewId(),
53                                              theGenImpl);
54 }
55
56 //=======================================================================
57 //function : ~GHS3DPlugin_Hypothesis_i
58 //=======================================================================
59
60 GHS3DPlugin_Hypothesis_i::~GHS3DPlugin_Hypothesis_i()
61 {
62 }
63
64 //=======================================================================
65 //function : SetToMeshHoles
66 //=======================================================================
67
68 void GHS3DPlugin_Hypothesis_i::SetToMeshHoles(CORBA::Boolean toMesh)
69 {
70   ASSERT(myBaseImpl);
71   this->GetImpl()->SetToMeshHoles(toMesh);
72   SMESH::TPythonDump() << _this() << ".SetToMeshHoles( " << toMesh << " )";
73 }
74
75 //=======================================================================
76 //function : GetToMeshHoles
77 //=======================================================================
78
79 CORBA::Boolean GHS3DPlugin_Hypothesis_i::GetToMeshHoles()
80 {
81   ASSERT(myBaseImpl);
82   return this->GetImpl()->GetToMeshHoles();
83 }
84
85 //=======================================================================
86 //function : SetToMakeGroupsOfDomains
87 //=======================================================================
88
89 void GHS3DPlugin_Hypothesis_i::SetToMakeGroupsOfDomains(CORBA::Boolean toMakeGroups)
90 {
91   ASSERT(myBaseImpl);
92   this->GetImpl()->SetToMakeGroupsOfDomains(toMakeGroups);
93   SMESH::TPythonDump() << _this() << ".SetToMakeGroupsOfDomains( " << toMakeGroups << " )";
94 }
95
96 //=======================================================================
97 //function : GetToMakeGroupsOfDomains
98 //=======================================================================
99
100 CORBA::Boolean GHS3DPlugin_Hypothesis_i::GetToMakeGroupsOfDomains()
101 {
102   ASSERT(myBaseImpl);
103   return this->GetImpl()->GetToMakeGroupsOfDomains();
104 }
105
106 //=======================================================================
107 //function : SetMaximumMemory
108 //=======================================================================
109
110 void GHS3DPlugin_Hypothesis_i::SetMaximumMemory(CORBA::Float MB)
111   throw ( SALOME::SALOME_Exception )
112 {
113   if ( MB == 0 )
114     THROW_SALOME_CORBA_EXCEPTION( "Invalid memory size",SALOME::BAD_PARAM );
115   ASSERT(myBaseImpl);
116   this->GetImpl()->SetMaximumMemory(MB);
117   SMESH::TPythonDump() << _this() << ".SetMaximumMemory( " << MB << " )";
118 }
119
120 //=======================================================================
121 //function : GetMaximumMemory
122 //=======================================================================
123
124 CORBA::Float GHS3DPlugin_Hypothesis_i::GetMaximumMemory()
125 {
126   ASSERT(myBaseImpl);
127   return this->GetImpl()->GetMaximumMemory();
128 }
129
130 //=======================================================================
131 //function : SetInitialMemory
132 //=======================================================================
133
134 void GHS3DPlugin_Hypothesis_i::SetInitialMemory(CORBA::Float MB)
135   throw ( SALOME::SALOME_Exception )
136 {
137   if ( MB == 0 )
138     THROW_SALOME_CORBA_EXCEPTION( "Invalid memory size",SALOME::BAD_PARAM );
139   ASSERT(myBaseImpl);
140   this->GetImpl()->SetInitialMemory(MB);
141   SMESH::TPythonDump() << _this() << ".SetInitialMemory( " << MB << " )";
142 }
143
144 //=======================================================================
145 //function : GetInitialMemory
146 //=======================================================================
147
148 CORBA::Float GHS3DPlugin_Hypothesis_i::GetInitialMemory()
149 {
150   ASSERT(myBaseImpl);
151   return this->GetImpl()->GetInitialMemory();
152 }
153
154 //=======================================================================
155 //function : SetOptimizationLevel
156 //=======================================================================
157
158 void GHS3DPlugin_Hypothesis_i::SetOptimizationLevel(CORBA::Short level)
159   throw ( SALOME::SALOME_Exception )
160 {
161   ::GHS3DPlugin_Hypothesis::OptimizationLevel l =
162     (::GHS3DPlugin_Hypothesis::OptimizationLevel) level;
163   if ( l < ::GHS3DPlugin_Hypothesis::None ||
164        l > ::GHS3DPlugin_Hypothesis::Strong )
165     THROW_SALOME_CORBA_EXCEPTION( "Invalid optimization level",SALOME::BAD_PARAM );
166     
167   ASSERT(myBaseImpl);
168   this->GetImpl()->SetOptimizationLevel(l);
169   SMESH::TPythonDump() << _this() << ".SetOptimizationLevel( " << level << " )";
170 }
171
172 //=======================================================================
173 //function : GetOptimizationLevel
174 //=======================================================================
175
176 CORBA::Short GHS3DPlugin_Hypothesis_i::GetOptimizationLevel()
177 {
178   ASSERT(myBaseImpl);
179   return this->GetImpl()->GetOptimizationLevel();
180 }
181
182 //=======================================================================
183 //function : SetWorkingDirectory
184 //=======================================================================
185
186 void GHS3DPlugin_Hypothesis_i::SetWorkingDirectory(const char* path) throw ( SALOME::SALOME_Exception )
187 {
188   if (!path )
189     THROW_SALOME_CORBA_EXCEPTION( "Null working directory",SALOME::BAD_PARAM );
190
191   string file(path);
192   const char lastChar = *file.rbegin();
193 #ifdef WIN32
194   if ( lastChar != '\\' ) file += '\\';
195 #else
196   if ( lastChar != '/' ) file += '/';
197 #endif
198   file += "GHS3D.log";
199   SMESH_Mesh_i::PrepareForWriting (file.c_str());
200
201   ASSERT(myBaseImpl);
202   this->GetImpl()->SetWorkingDirectory(path);
203   SMESH::TPythonDump() << _this() << ".SetWorkingDirectory( '" << path << "' )";
204 }
205
206 //=======================================================================
207 //function : GetWorkingDirectory
208 //=======================================================================
209
210 char* GHS3DPlugin_Hypothesis_i::GetWorkingDirectory()
211 {
212   ASSERT(myBaseImpl);
213   return CORBA::string_dup( this->GetImpl()->GetWorkingDirectory().c_str() );
214 }
215
216 //=======================================================================
217 //function : SetKeepFiles
218 //=======================================================================
219
220 void GHS3DPlugin_Hypothesis_i::SetKeepFiles(CORBA::Boolean toKeep)
221 {
222   ASSERT(myBaseImpl);
223   this->GetImpl()->SetKeepFiles(toKeep);
224   SMESH::TPythonDump() << _this() << ".SetKeepFiles( " << toKeep << " )";
225 }
226
227 //=======================================================================
228 //function : GetKeepFiles
229 //=======================================================================
230
231 CORBA::Boolean GHS3DPlugin_Hypothesis_i::GetKeepFiles()
232 {
233   ASSERT(myBaseImpl);
234   return this->GetImpl()->GetKeepFiles();
235 }
236
237 //=======================================================================
238 //function : SetVerboseLevel
239 //=======================================================================
240
241 void GHS3DPlugin_Hypothesis_i::SetVerboseLevel(CORBA::Short level)
242   throw ( SALOME::SALOME_Exception )
243 {
244   if (level < 0 || level > 10 )
245     THROW_SALOME_CORBA_EXCEPTION( "Invalid verbose level, valid range is [0-10]",
246                                   SALOME::BAD_PARAM );
247   ASSERT(myBaseImpl);
248   this->GetImpl()->SetVerboseLevel(level);
249   SMESH::TPythonDump() << _this() << ".SetVerboseLevel( " << level << " )";
250 }
251
252 //=======================================================================
253 //function : GetVerboseLevel
254 //=======================================================================
255
256 CORBA::Short GHS3DPlugin_Hypothesis_i::GetVerboseLevel()
257 {
258   ASSERT(myBaseImpl);
259   return this->GetImpl()->GetVerboseLevel();
260 }
261
262 //=======================================================================
263 //function : SetToCreateNewNodes
264 //=======================================================================
265
266 void GHS3DPlugin_Hypothesis_i::SetToCreateNewNodes(CORBA::Boolean toCreate)
267 {
268   ASSERT(myBaseImpl);
269   this->GetImpl()->SetToCreateNewNodes(toCreate);
270   SMESH::TPythonDump() << _this() << ".SetToCreateNewNodes( " << toCreate << " )";
271 }
272
273 //=======================================================================
274 //function : GetToCreateNewNodes
275 //=======================================================================
276
277 CORBA::Boolean GHS3DPlugin_Hypothesis_i::GetToCreateNewNodes()
278 {
279   ASSERT(myBaseImpl);
280   return this->GetImpl()->GetToCreateNewNodes();
281 }
282
283 //=======================================================================
284 //function : SetToUseBoundaryRecoveryVersion
285 //=======================================================================
286
287 void GHS3DPlugin_Hypothesis_i::SetToUseBoundaryRecoveryVersion(CORBA::Boolean toUse)
288 {
289   ASSERT(myBaseImpl);
290   this->GetImpl()->SetToUseBoundaryRecoveryVersion(toUse);
291   SMESH::TPythonDump() << _this() << ".SetToUseBoundaryRecoveryVersion( " << toUse << " )";
292 }
293
294 //=======================================================================
295 //function : GetToUseBoundaryRecoveryVersion
296 //=======================================================================
297
298 CORBA::Boolean GHS3DPlugin_Hypothesis_i::GetToUseBoundaryRecoveryVersion()
299 {
300   ASSERT(myBaseImpl);
301   return this->GetImpl()->GetToUseBoundaryRecoveryVersion();
302 }
303
304 //=======================================================================
305 //function : SetFEMCorrection
306 //=======================================================================
307
308 void GHS3DPlugin_Hypothesis_i::SetFEMCorrection(CORBA::Boolean toUseFem)
309 {
310   ASSERT(myBaseImpl);
311   this->GetImpl()->SetFEMCorrection(toUseFem);
312   SMESH::TPythonDump() << _this() << ".SetFEMCorrection( " << toUseFem << " )";
313 }
314
315 //=======================================================================
316 //function : GetFEMCorrection
317 //=======================================================================
318
319 CORBA::Boolean GHS3DPlugin_Hypothesis_i::GetFEMCorrection()
320 {
321   ASSERT(myBaseImpl);
322   return this->GetImpl()->GetFEMCorrection();
323 }
324
325 //=======================================================================
326 //function : SetToRemoveCentralPoint
327 //=======================================================================
328
329 void GHS3DPlugin_Hypothesis_i::SetToRemoveCentralPoint(CORBA::Boolean toRemove)
330 {
331   ASSERT(myBaseImpl);
332   this->GetImpl()->SetToRemoveCentralPoint(toRemove);
333   SMESH::TPythonDump() << _this() << ".SetToRemoveCentralPoint( " << toRemove << " )";
334 }
335
336 //=======================================================================
337 //function : GetToRemoveCentralPoint
338 //=======================================================================
339
340 CORBA::Boolean GHS3DPlugin_Hypothesis_i::GetToRemoveCentralPoint()
341 {
342   ASSERT(myBaseImpl);
343   return this->GetImpl()->GetToRemoveCentralPoint();
344 }
345
346 //=======================================================================
347 //function : SetTextOption
348 //=======================================================================
349
350 void GHS3DPlugin_Hypothesis_i::SetTextOption(const char* option)
351 {
352   ASSERT(myBaseImpl);
353   this->GetImpl()->SetAdvancedOption(option);
354   SMESH::TPythonDump() << _this() << ".SetAdvancedOption( '" << option << "' )";
355 }
356
357 //=======================================================================
358 //function : GetTextOption
359 //=======================================================================
360
361 char* GHS3DPlugin_Hypothesis_i::GetTextOption()
362 {
363   ASSERT(myBaseImpl);
364   return CORBA::string_dup( this->GetImpl()->GetAdvancedOption().c_str() );
365 }
366
367 //=======================================================================
368 //function : SetAdvancedOption
369 //=======================================================================
370
371 void GHS3DPlugin_Hypothesis_i::SetAdvancedOption(const char* option)
372 {
373   ASSERT(myBaseImpl);
374   this->GetImpl()->SetAdvancedOption(option);
375   SMESH::TPythonDump() << _this() << ".SetAdvancedOption( '" << option << "' )";
376 }
377
378 //=======================================================================
379 //function : GetAdvancedOption
380 //=======================================================================
381
382 char* GHS3DPlugin_Hypothesis_i::GetAdvancedOption()
383 {
384   ASSERT(myBaseImpl);
385   return CORBA::string_dup( this->GetImpl()->GetAdvancedOption().c_str() );
386 }
387
388 //=======================================================================
389 //function : SetToRemoveCentralPoint
390 //=======================================================================
391
392 void GHS3DPlugin_Hypothesis_i::SetGradation(CORBA::Double gradation)
393 {
394   ASSERT(myBaseImpl);
395   if (gradation != GetGradation()) {
396     this->GetImpl()->SetGradation(gradation);
397     SMESH::TPythonDump() << _this() << ".SetGradation( " << gradation << " )";
398   }
399 }
400
401 //=======================================================================
402 //function : GetToRemoveCentralPoint
403 //=======================================================================
404
405 CORBA::Double GHS3DPlugin_Hypothesis_i::GetGradation()
406 {
407   ASSERT(myBaseImpl);
408   return this->GetImpl()->GetGradation();
409 }
410
411 //=======================================================================
412 //function : SetStandardOutputLog
413 //=======================================================================
414
415 void GHS3DPlugin_Hypothesis_i::SetStandardOutputLog(CORBA::Boolean logInStandardOutput)
416 {
417   ASSERT(myBaseImpl);
418   this->GetImpl()->SetStandardOutputLog(logInStandardOutput);
419   SMESH::TPythonDump() << _this() << ".SetPrintLogInFile( " << !logInStandardOutput << " )";
420 }
421
422 //=======================================================================
423 //function : GetStandardOutputLog
424 //=======================================================================
425
426 CORBA::Boolean GHS3DPlugin_Hypothesis_i::GetStandardOutputLog()
427 {
428   ASSERT(myBaseImpl);
429   return this->GetImpl()->GetStandardOutputLog();
430 }
431
432 //=======================================================================
433 //function : SetRemoveLogOnSuccess
434 //=======================================================================
435
436 void GHS3DPlugin_Hypothesis_i::SetRemoveLogOnSuccess(CORBA::Boolean removeLogOnSuccess)
437 {
438   ASSERT(myBaseImpl);
439   this->GetImpl()->SetRemoveLogOnSuccess(removeLogOnSuccess);
440   SMESH::TPythonDump() << _this() << ".SetRemoveLogOnSuccess( " << removeLogOnSuccess << " )";
441 }
442
443 //=======================================================================
444 //function : GetRemoveLogOnSuccess
445 //=======================================================================
446
447 CORBA::Boolean GHS3DPlugin_Hypothesis_i::GetRemoveLogOnSuccess()
448 {
449   ASSERT(myBaseImpl);
450   return this->GetImpl()->GetRemoveLogOnSuccess();
451 }
452
453 //=======================================================================
454 //function : SetEnforcedVertex
455 //=======================================================================
456
457 bool GHS3DPlugin_Hypothesis_i::SetEnforcedVertex(CORBA::Double x, CORBA::Double y, CORBA::Double z, CORBA::Double size)
458   throw (SALOME::SALOME_Exception) {
459   ASSERT(myBaseImpl);
460   return p_SetEnforcedVertex(size, x, y, z);
461 }
462
463 bool GHS3DPlugin_Hypothesis_i::SetEnforcedVertexNamed(CORBA::Double x, CORBA::Double y, CORBA::Double z, CORBA::Double size, const char* theVertexName)
464   throw (SALOME::SALOME_Exception) {
465   ASSERT(myBaseImpl);
466   return p_SetEnforcedVertex(size, x, y, z, theVertexName, "", "");
467 }
468
469 bool GHS3DPlugin_Hypothesis_i::SetEnforcedVertexWithGroup(CORBA::Double x, CORBA::Double y, CORBA::Double z, CORBA::Double size, const char* theGroupName)
470   throw (SALOME::SALOME_Exception) {
471   ASSERT(myBaseImpl);
472   return p_SetEnforcedVertex(size, x, y, z, "", "", theGroupName);
473 }
474
475 bool GHS3DPlugin_Hypothesis_i::SetEnforcedVertexNamedWithGroup(CORBA::Double x, CORBA::Double y, CORBA::Double z, CORBA::Double size, const char* theVertexName, const char* theGroupName)
476   throw (SALOME::SALOME_Exception) {
477   ASSERT(myBaseImpl);
478   return p_SetEnforcedVertex(size, x, y, z, theVertexName, "", theGroupName);
479 }
480
481 bool GHS3DPlugin_Hypothesis_i::SetEnforcedVertexGeom(GEOM::GEOM_Object_ptr theVertex, CORBA::Double size)
482   throw (SALOME::SALOME_Exception) {
483   ASSERT(myBaseImpl);
484   
485   if ((theVertex->GetShapeType() != GEOM::VERTEX) && (theVertex->GetShapeType() != GEOM::COMPOUND)) {
486     THROW_SALOME_CORBA_EXCEPTION("theVertex shape type is not VERTEX or COMPOUND", SALOME::BAD_PARAM);
487   }
488   
489   string theVertexEntry = theVertex->GetStudyEntry();
490   CORBA::Double x = 0, y = 0, z = 0;
491   CORBA::Boolean isCompound = false;
492   GEOM::GEOM_Gen_ptr geomGen = SMESH_Gen_i::GetGeomEngine();
493   if (theVertexEntry.empty()) {
494     string aName;
495     if (theVertex->GetShapeType() == GEOM::VERTEX) {
496       aName = "Vertex_";
497     }
498     if (theVertex->GetShapeType() == GEOM::COMPOUND) {
499       aName = "Compound_";
500       isCompound = true;
501     }
502     aName += theVertex->GetEntry();
503     SALOMEDS::SObject_ptr theSVertex = geomGen->PublishInStudy(NULL, theVertex, aName.c_str());
504     if (!theSVertex->_is_nil())
505       theVertexEntry = theSVertex->GetID();
506   }
507   if (theVertexEntry.empty())
508     THROW_SALOME_CORBA_EXCEPTION( "Geom object is not published in study" ,SALOME::BAD_PARAM );
509
510   if (theVertex->GetShapeType() == GEOM::VERTEX) {
511     GEOM::GEOM_IMeasureOperations_var measureOp = geomGen->GetIMeasureOperations();
512     if (CORBA::is_nil(measureOp))
513       return false;
514     
515     measureOp->PointCoordinates (theVertex, x, y, z);
516   }
517
518   string theVertexName = theVertex->GetName();
519   
520   return p_SetEnforcedVertex(size, x, y, z, theVertexName.c_str(), theVertexEntry.c_str(), "", isCompound);
521 }
522
523 bool GHS3DPlugin_Hypothesis_i::SetEnforcedVertexGeomWithGroup(GEOM::GEOM_Object_ptr theVertex, CORBA::Double size, const char* theGroupName)
524   throw (SALOME::SALOME_Exception) {
525   ASSERT(myBaseImpl);
526   
527   if ((theVertex->GetShapeType() != GEOM::VERTEX) && (theVertex->GetShapeType() != GEOM::COMPOUND)) {
528     THROW_SALOME_CORBA_EXCEPTION("theVertex shape type is not VERTEX or COMPOUND", SALOME::BAD_PARAM);
529   }
530   
531   string theVertexEntry = theVertex->GetStudyEntry();
532   CORBA::Double x = 0, y = 0, z = 0;
533   CORBA::Boolean isCompound = false;
534   GEOM::GEOM_Gen_ptr geomGen = SMESH_Gen_i::GetGeomEngine();
535   if (theVertexEntry.empty()) {
536     string aName;
537     if (theVertex->GetShapeType() == GEOM::VERTEX) {
538       aName = "Vertex_";
539     }
540     if (theVertex->GetShapeType() == GEOM::COMPOUND) {
541       aName = "Compound_";
542       isCompound = true;
543     }
544     aName += theVertex->GetEntry();
545     SALOMEDS::SObject_ptr theSVertex = geomGen->PublishInStudy(NULL, theVertex, aName.c_str());
546     if (!theSVertex->_is_nil())
547       theVertexEntry = theSVertex->GetID();
548   }
549   if (theVertexEntry.empty())
550     THROW_SALOME_CORBA_EXCEPTION( "Geom object is not published in study" ,SALOME::BAD_PARAM );
551
552   if (theVertex->GetShapeType() == GEOM::VERTEX) {
553     GEOM::GEOM_IMeasureOperations_var measureOp = geomGen->GetIMeasureOperations();
554     if (CORBA::is_nil(measureOp))
555       return false;
556     
557     measureOp->PointCoordinates (theVertex, x, y, z);
558   }
559     
560   string theVertexName = theVertex->GetName();
561   
562   return p_SetEnforcedVertex(size, x, y, z, theVertexName.c_str(), theVertexEntry.c_str(), theGroupName, isCompound);
563 }
564
565 bool GHS3DPlugin_Hypothesis_i:: p_SetEnforcedVertex(CORBA::Double size, CORBA::Double x, CORBA::Double y, CORBA::Double z,
566                                                     const char* theVertexName, const char* theVertexEntry, const char* theGroupName,
567                                                     CORBA::Boolean isCompound)
568   throw (SALOME::SALOME_Exception) {
569   ASSERT(myBaseImpl);
570   bool newValue = false;
571
572   ::GHS3DPlugin_Hypothesis::TCoordsGHS3DEnforcedVertexMap coordsList;
573   ::GHS3DPlugin_Hypothesis::TGeomEntryGHS3DEnforcedVertexMap enfVertexEntryList;
574   if (string(theVertexEntry).empty()) {
575     coordsList = this->GetImpl()->_GetEnforcedVerticesByCoords();
576     std::vector<double> coords;
577     coords.push_back(x);
578     coords.push_back(y);
579     coords.push_back(z);
580     if (coordsList.find(coords) == coordsList.end()) {
581       newValue = true;
582     }
583     else {
584       ::GHS3DPlugin_Hypothesis::TGHS3DEnforcedVertex *enfVertex = this->GetImpl()->GetEnforcedVertex(x, y, z);
585       if ((enfVertex->name != theVertexName) || (enfVertex->groupName != theGroupName) || (enfVertex->size != size)) {
586         newValue = true;
587       }
588     }
589
590     if (newValue) {
591       if (string(theVertexName).empty()) {
592         if (string(theGroupName).empty())
593           SMESH::TPythonDump() << "isDone = " << _this() << ".SetEnforcedVertex(" << x << ", " << y << ", " << z << ", " << size << ")";
594         else
595           SMESH::TPythonDump() << "isDone = " << _this() << ".SetEnforcedVertexWithGroup(" << x << ", " << y << ", " << z << ", " << size << ", \"" << theGroupName << "\")";
596       }
597       else {
598         if (string(theGroupName).empty())
599           SMESH::TPythonDump() << "isDone = " << _this() << ".SetEnforcedVertexNamed(" << x << ", " << y << ", " << z << ", " << size  << ", \"" << theVertexName << "\")";
600         else
601           SMESH::TPythonDump() << "isDone = " << _this() << ".SetEnforcedVertexNamedWithGroup(" << x << ", " << y << ", " << z << ", " << size  << ", \"" << theVertexName << "\", \"" << theGroupName << "\")";
602       }
603     }
604   } 
605   else {
606     enfVertexEntryList = this->GetImpl()->_GetEnforcedVerticesByEntry();
607     if ( enfVertexEntryList.find(theVertexEntry) == enfVertexEntryList.end()) {
608       newValue = true;
609     }
610     else {
611       ::GHS3DPlugin_Hypothesis::TGHS3DEnforcedVertex *enfVertex = this->GetImpl()->GetEnforcedVertex(theVertexEntry);
612       if ((enfVertex->name != theVertexName) || (enfVertex->groupName != theGroupName) || (enfVertex->size != size)) {
613         newValue = true;
614       }
615     }
616
617     if (newValue) {
618       if (string(theGroupName).empty())
619         SMESH::TPythonDump() << "isDone = " << _this() << ".SetEnforcedVertexGeom(" << theVertexEntry << ", " << size << ")";
620       else
621         SMESH::TPythonDump() << "isDone = " << _this() << ".SetEnforcedVertexGeomWithGroup(" << theVertexEntry << ", " << size << ", \"" << theGroupName << "\")";
622     }
623   }
624
625   if (newValue)
626     this->GetImpl()->SetEnforcedVertex(theVertexName, theVertexEntry, theGroupName, size, x, y, z, isCompound);
627
628   return newValue;
629 }
630
631 //=======================================================================
632 //function : GetEnforcedVertex
633 //=======================================================================
634
635 CORBA::Double GHS3DPlugin_Hypothesis_i::GetEnforcedVertex(CORBA::Double x, CORBA::Double y, CORBA::Double z)
636   throw (SALOME::SALOME_Exception)
637 {
638   ASSERT(myBaseImpl);
639   try {
640     bool isDone = this->GetImpl()->GetEnforcedVertex(x,y,z)->size;
641     SMESH::TPythonDump() << "aSize = " << _this() << ".GetEnforcedVertex(" << x << ", " << y << ", " << z << ")";
642     return isDone;
643   }
644   catch (const std::invalid_argument& ex) {
645     THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
646   }
647   catch (SALOME_Exception& ex) {
648     THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
649   }
650 }
651
652 //=======================================================================
653 //function : GetEnforcedVertex
654 //=======================================================================
655
656 CORBA::Double GHS3DPlugin_Hypothesis_i::GetEnforcedVertexGeom(GEOM::GEOM_Object_ptr theVertex)
657   throw (SALOME::SALOME_Exception)
658 {
659   ASSERT(myBaseImpl);
660   
661   if ((theVertex->GetShapeType() != GEOM::VERTEX) && (theVertex->GetShapeType() != GEOM::COMPOUND)) {
662     THROW_SALOME_CORBA_EXCEPTION("theVertex shape type is not VERTEX or COMPOUND", SALOME::BAD_PARAM);
663   }
664   
665   string theVertexEntry = theVertex->GetStudyEntry();
666   if (theVertexEntry.empty()) {
667     GEOM::GEOM_Gen_ptr geomGen = SMESH_Gen_i::GetGeomEngine();
668     string aName;
669     if (theVertex->GetShapeType() == GEOM::VERTEX)
670       aName = "Vertex_";
671     if (theVertex->GetShapeType() == GEOM::COMPOUND)
672       aName = "Compound_";
673     aName += theVertex->GetEntry();
674     SALOMEDS::SObject_ptr theSVertex = geomGen->PublishInStudy(NULL, theVertex, aName.c_str());
675     if (!theSVertex->_is_nil())
676       theVertexEntry = theSVertex->GetID();
677   }
678   if (theVertexEntry.empty())
679     THROW_SALOME_CORBA_EXCEPTION( "Geom object is not published in study" ,SALOME::BAD_PARAM );
680
681   string theVertexName = theVertex->GetName();
682   
683   try {
684     bool isDone = this->GetImpl()->GetEnforcedVertex(theVertexName)->size;
685     SMESH::TPythonDump() << "aSize = " << _this() << ".GetEnforcedVertexGeom(" << theVertex << ")";
686     return isDone;
687   }
688   catch (const std::invalid_argument& ex) {
689     THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
690   }
691   catch (SALOME_Exception& ex) {
692     THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
693   }
694 }
695
696 //=======================================================================
697 //function : GetEnforcedVertices
698 //=======================================================================
699
700 GHS3DPlugin::GHS3DEnforcedVertexList* GHS3DPlugin_Hypothesis_i::GetEnforcedVertices()
701 {
702   ASSERT(myBaseImpl);
703   GHS3DPlugin::GHS3DEnforcedVertexList_var result = new GHS3DPlugin::GHS3DEnforcedVertexList();
704
705   const ::GHS3DPlugin_Hypothesis::TGHS3DEnforcedVertexList enfVertexList = this->GetImpl()->_GetEnforcedVertices();
706   result->length( enfVertexList.size() );
707
708   ::GHS3DPlugin_Hypothesis::TGHS3DEnforcedVertexList::const_iterator it = enfVertexList.begin();
709
710   for (int i = 0 ; it != enfVertexList.end(); ++it, ++i ) {
711     ::GHS3DPlugin_Hypothesis::TGHS3DEnforcedVertex* currentVertex = (*it);
712     GHS3DPlugin::GHS3DEnforcedVertex_var enfVertex = new GHS3DPlugin::GHS3DEnforcedVertex();
713     // Name
714     enfVertex->name = CORBA::string_dup(currentVertex->name.c_str());
715     // Geom Vertex Entry
716     enfVertex->geomEntry = CORBA::string_dup(currentVertex->geomEntry.c_str());
717     // Coords
718     GHS3DPlugin::TCoords_var coords = new GHS3DPlugin::TCoords();
719     coords->length(currentVertex->coords.size());
720     for ( size_t ind = 0; ind < currentVertex->coords.size(); ind++)
721       coords[ind] = currentVertex->coords[ind];
722     enfVertex->coords = coords;
723     // Group Name
724     enfVertex->groupName = CORBA::string_dup(currentVertex->groupName.c_str());
725     // Size
726     enfVertex->size = currentVertex->size;
727     // isCompound
728     enfVertex->isCompound = currentVertex->isCompound;
729     
730     result[i]=enfVertex;
731   }
732   
733   //   SMESH::TPythonDump() << "allEnforcedVertices = " << _this() << ".GetEnforcedVertices()";
734
735   return result._retn();
736 }
737
738 //=======================================================================
739 //function : RemoveEnforcedVertex
740 //=======================================================================
741
742 bool GHS3DPlugin_Hypothesis_i::RemoveEnforcedVertex(CORBA::Double x, CORBA::Double y, CORBA::Double z)
743   throw (SALOME::SALOME_Exception)
744 {
745   ASSERT(myBaseImpl);
746   try {
747     bool res = this->GetImpl()->RemoveEnforcedVertex(x,y,z);
748     SMESH::TPythonDump() << " isDone = " << _this() << ".RemoveEnforcedVertex( " << x << ", " << y << ", " << z << " )";
749     return res;
750   }
751   catch (const std::invalid_argument& ex) {
752     THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
753   }
754   catch (SALOME_Exception& ex) {
755     THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
756   }
757 }
758
759 bool GHS3DPlugin_Hypothesis_i::RemoveEnforcedVertexGeom(GEOM::GEOM_Object_ptr theVertex)
760   throw (SALOME::SALOME_Exception)
761 {
762   ASSERT(myBaseImpl);
763   
764   if ((theVertex->GetShapeType() != GEOM::VERTEX) && (theVertex->GetShapeType() != GEOM::COMPOUND)) {
765     THROW_SALOME_CORBA_EXCEPTION("theVertex shape type is not VERTEX or COMPOUND", SALOME::BAD_PARAM);
766   }
767   
768   string theVertexEntry = theVertex->GetStudyEntry();
769   if (theVertexEntry.empty()) {
770     GEOM::GEOM_Gen_ptr geomGen = SMESH_Gen_i::GetGeomEngine();
771     string aName;
772     if (theVertex->GetShapeType() == GEOM::VERTEX)
773       aName = "Vertex_";
774     if (theVertex->GetShapeType() == GEOM::COMPOUND)
775       aName = "Compound_";
776     aName += theVertex->GetEntry();
777     SALOMEDS::SObject_ptr theSVertex = geomGen->PublishInStudy(NULL, theVertex, aName.c_str());
778     if (!theSVertex->_is_nil())
779       theVertexEntry = theSVertex->GetID();
780   }
781   if (theVertexEntry.empty())
782     THROW_SALOME_CORBA_EXCEPTION( "Geom object is not published in study" ,SALOME::BAD_PARAM );
783   
784   try {
785     bool res = this->GetImpl()->RemoveEnforcedVertex(0,0,0, theVertexEntry.c_str());
786     SMESH::TPythonDump() << "isDone = " << _this() << ".RemoveEnforcedVertexGeom( " << theVertexEntry.c_str() << " )";
787     return res;
788   }
789   catch (const std::invalid_argument& ex) {
790     THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
791   }
792   catch (SALOME_Exception& ex) {
793     THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
794   }
795 }
796
797 //=======================================================================
798 //function : ClearEnforcedVertices
799 //=======================================================================
800
801 void GHS3DPlugin_Hypothesis_i::ClearEnforcedVertices()
802 {
803   ASSERT(myBaseImpl);
804   this->GetImpl()->ClearEnforcedVertices();
805   SMESH::TPythonDump () << _this() << ".ClearEnforcedVertices() ";
806 }
807
808 //=======================================================================
809 //function : ClearEnforcedMeshes
810 //=======================================================================
811
812 void GHS3DPlugin_Hypothesis_i::ClearEnforcedMeshes()
813 {
814   ASSERT(myBaseImpl);
815   this->GetImpl()->ClearEnforcedMeshes();
816   SMESH::TPythonDump () << _this() << ".ClearEnforcedMeshes() ";
817 }
818
819 //=======================================================================
820 //function : GetEnforcedMeshes
821 //=======================================================================
822
823 GHS3DPlugin::GHS3DEnforcedMeshList* GHS3DPlugin_Hypothesis_i::GetEnforcedMeshes()
824 {
825   ASSERT(myBaseImpl);
826   GHS3DPlugin::GHS3DEnforcedMeshList_var result = new GHS3DPlugin::GHS3DEnforcedMeshList();
827
828   const ::GHS3DPlugin_Hypothesis::TGHS3DEnforcedMeshList enfMeshList = this->GetImpl()->_GetEnforcedMeshes();
829   result->length( enfMeshList.size() );
830
831   ::GHS3DPlugin_Hypothesis::TGHS3DEnforcedMeshList::const_iterator it = enfMeshList.begin();
832
833   for (int i = 0 ; it != enfMeshList.end(); ++it, ++i ) {
834     ::GHS3DPlugin_Hypothesis::TGHS3DEnforcedMesh* currentMesh = (*it);
835     GHS3DPlugin::GHS3DEnforcedMesh_var enfMesh = new GHS3DPlugin::GHS3DEnforcedMesh();
836     // Name
837     enfMesh->name = CORBA::string_dup(currentMesh->name.c_str());
838     // Mesh Entry
839     enfMesh->entry = CORBA::string_dup(currentMesh->entry.c_str());
840     // isCompound
841     enfMesh->elementType = currentMesh->elementType;
842     // Group Name
843     enfMesh->groupName = CORBA::string_dup(currentMesh->groupName.c_str());
844     
845     result[i]=enfMesh;
846   }
847   
848   //   SMESH::TPythonDump() << "allEnforcedVertices = " << _this() << ".GetEnforcedVertices()";
849
850   return result._retn();
851 }
852
853 /*!
854  * \brief Adds enforced elements of type elementType using another mesh/sub-mesh/mesh group theSource. The elements will be grouped in theGroupName.
855  */
856 bool GHS3DPlugin_Hypothesis_i::SetEnforcedMeshWithGroup(SMESH::SMESH_IDSource_ptr theSource, SMESH::ElementType theType, const char* theGroupName)
857   throw (SALOME::SALOME_Exception)
858 {
859   return p_SetEnforcedMesh(theSource, theType, "", theGroupName);
860 }
861
862 /*!
863  * \brief Adds enforced elements of type elementType using another mesh/sub-mesh/mesh group theSource.
864  */
865 bool GHS3DPlugin_Hypothesis_i::SetEnforcedMesh(SMESH::SMESH_IDSource_ptr theSource, SMESH::ElementType theType)
866   throw (SALOME::SALOME_Exception)
867 {
868   return p_SetEnforcedMesh(theSource, theType);
869 }
870
871 /*!
872  * \brief OBSOLETE FUNCTION - Adds enforced elements of type elementType using another mesh/sub-mesh/mesh group theSource and a size. The elements will be grouped in theGroupName.
873  */
874 bool GHS3DPlugin_Hypothesis_i::SetEnforcedMeshSizeWithGroup(SMESH::SMESH_IDSource_ptr theSource, SMESH::ElementType theType, double theSize, const char* theGroupName)
875   throw (SALOME::SALOME_Exception)
876 {
877   return p_SetEnforcedMesh(theSource, theType, "", theGroupName);
878 }
879
880 /*!
881  * \brief OBSOLETE FUNCTION - Adds enforced elements of type elementType using another mesh/sub-mesh/mesh group theSource and a size.
882  */
883 bool GHS3DPlugin_Hypothesis_i::SetEnforcedMeshSize(SMESH::SMESH_IDSource_ptr theSource, SMESH::ElementType theType, double theSize)
884   throw (SALOME::SALOME_Exception)
885 {
886   return p_SetEnforcedMesh(theSource, theType);
887 }
888
889 bool GHS3DPlugin_Hypothesis_i::p_SetEnforcedMesh(SMESH::SMESH_IDSource_ptr theSource,
890                                                  SMESH::ElementType        theType,
891                                                  const char*               theName,
892                                                  const char*               theGroupName)
893   throw (SALOME::SALOME_Exception)
894 {
895   ASSERT(myBaseImpl);
896
897   if (CORBA::is_nil( theSource ))
898     THROW_SALOME_CORBA_EXCEPTION( "The source mesh CORBA object is NULL" ,SALOME::BAD_PARAM );
899
900   switch (theType) {
901   case SMESH::NODE:
902   case SMESH::EDGE:
903   case SMESH::FACE: break;
904   default:
905     return false;
906   }
907   SMESH::array_of_ElementType_var types = theSource->GetTypes();
908   if ( types->length() >= 1 && types[types->length()-1] <  theType)
909   {
910     return false;
911   }
912
913   SMESH_Gen_i *smeshGen = SMESH_Gen_i::GetSMESHGen();
914   SALOMEDS::SObject_ptr SObj = smeshGen->ObjectToSObject(theSource);
915
916   SMESH_Mesh_i* theMesh_i = SMESH::DownCast<SMESH_Mesh_i*>( theSource);
917   SMESH_Group_i* theGroup_i = SMESH::DownCast<SMESH_Group_i*>( theSource);
918   SMESH_GroupOnGeom_i* theGroupOnGeom_i = SMESH::DownCast<SMESH_GroupOnGeom_i*>( theSource);
919
920   string enfMeshName = theName;
921   if (enfMeshName.empty())
922     enfMeshName = SObj->GetName();
923
924   if (theMesh_i)
925   {
926     try {
927       bool res = this->GetImpl()->SetEnforcedMesh(theMesh_i->GetImpl(), theType, enfMeshName , SObj->GetID(), theGroupName);
928       if (theGroupName && theGroupName[0] ) {
929         SMESH::TPythonDump () << "isDone = " << _this() << ".SetEnforcedMeshWithGroup( "
930                               << theSource << ".GetMesh(), " << theType << ", \"" << theGroupName << "\" )";
931       }
932       else {
933         SMESH::TPythonDump () << "isDone = " << _this() << ".SetEnforcedMesh( "
934                               << theSource << ".GetMesh(), " << theType << " )";
935       }
936
937       return res;
938     }
939     catch (const std::invalid_argument& ex) {
940       SALOME::ExceptionStruct ExDescription;
941       ExDescription.text = ex.what();
942       ExDescription.type = SALOME::BAD_PARAM;
943       ExDescription.sourceFile = "GHS3DPlugin_Hypothesis_i.cxx";
944       ExDescription.lineNumber = 840;
945       throw SALOME::SALOME_Exception(ExDescription);
946     }
947     catch (SALOME_Exception& ex) {
948       THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
949     }
950   }
951   else if (theGroup_i)// && types->length() == 1 && types[0] == theType)
952   {
953     try {
954       bool res = this->GetImpl()->SetEnforcedGroup(theGroup_i->GetGroupDS()->GetMesh(), theGroup_i->GetListOfID(), theType, enfMeshName , SObj->GetID(), theGroupName);
955       if ( theGroupName && theGroupName[0] ) {
956         SMESH::TPythonDump () << "isDone = " << _this() << ".SetEnforcedMeshWithGroup( "
957                               << theSource << ", " << theType << ", \"" << theGroupName << "\" )";
958       }
959       else {
960         SMESH::TPythonDump () << "isDone = " << _this() << ".SetEnforcedMesh( "
961                               << theSource << ", " << theType << " )";
962       }
963       return res;
964     }
965     catch (const std::invalid_argument& ex) {
966       SALOME::ExceptionStruct ExDescription;
967       ExDescription.text = ex.what();
968       ExDescription.type = SALOME::BAD_PARAM;
969       ExDescription.sourceFile = "GHS3DPlugin_Hypothesis_i.cxx";
970       ExDescription.lineNumber = 840;
971       throw SALOME::SALOME_Exception(ExDescription);
972     }
973     catch (SALOME_Exception& ex) {
974       THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
975     }
976   }
977   else if (theGroupOnGeom_i)// && types->length() == 1 && types[0] == theType)
978   {
979     try {
980       bool res = this->GetImpl()->SetEnforcedGroup(theGroupOnGeom_i->GetGroupDS()->GetMesh(),theGroupOnGeom_i->GetListOfID(), theType, enfMeshName , SObj->GetID(), theGroupName);
981       if ( theGroupName && theGroupName[0] ) {
982         SMESH::TPythonDump () << "isDone = " << _this() << ".SetEnforcedMeshWithGroup( "
983                               << theSource << ", " << theType << ", \"" << theGroupName << "\" )";
984       }
985       else {
986         SMESH::TPythonDump () << "isDone = " << _this() << ".SetEnforcedMesh( "
987                               << theSource << ", " << theType << " )";
988       }
989       return res;
990     }
991     catch (const std::invalid_argument& ex) {
992       SALOME::ExceptionStruct ExDescription;
993       ExDescription.text = ex.what();
994       ExDescription.type = SALOME::BAD_PARAM;
995       ExDescription.sourceFile = "GHS3DPlugin_Hypothesis_i.cxx";
996       ExDescription.lineNumber = 840;
997       throw SALOME::SALOME_Exception(ExDescription);
998     }
999     catch (SALOME_Exception& ex) {
1000       THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM );
1001     }
1002   }
1003   return false;
1004 }
1005 //=============================================================================
1006 /*!
1007  *  Get implementation
1008  */
1009 //=============================================================================
1010
1011 ::GHS3DPlugin_Hypothesis* GHS3DPlugin_Hypothesis_i::GetImpl()
1012 {
1013   return (::GHS3DPlugin_Hypothesis*)myBaseImpl;
1014 }
1015
1016 //================================================================================
1017 /*!
1018  * \brief Verify whether hypothesis supports given entity type 
1019  */
1020 //================================================================================  
1021
1022 CORBA::Boolean GHS3DPlugin_Hypothesis_i::IsDimSupported( SMESH::Dimension type )
1023 {
1024   return type == SMESH::DIM_3D;
1025 }
1026
1027
1028 //================================================================================
1029 /*!
1030  * \brief Return geometry this hypothesis depends on. Return false if there is no geometry parameter
1031  */
1032 //================================================================================
1033
1034 bool
1035 GHS3DPlugin_Hypothesis_i::getObjectsDependOn( std::vector< std::string > & entryArray,
1036                                               std::vector< int >         & subIDArray ) const
1037 {
1038   typedef ::GHS3DPlugin_Hypothesis THyp;
1039   const THyp* h = static_cast< const THyp*>( myBaseImpl );
1040
1041   {
1042     const THyp::TGHS3DEnforcedVertexList& enfVertexList = h->_GetEnforcedVertices();
1043     THyp::TGHS3DEnforcedVertexList::const_iterator evIt = enfVertexList.begin();
1044     for ( ; evIt != enfVertexList.end(); ++evIt )
1045     {
1046       const THyp::TGHS3DEnforcedVertex* ev = *evIt;
1047       entryArray.push_back( ev->geomEntry );
1048     }
1049   }
1050   {
1051     const THyp::TGHS3DEnforcedVertexEntryValues&
1052       enfVertexEntrySizeList = h->_GetEnforcedVerticesEntrySize();
1053     THyp::TGHS3DEnforcedVertexEntryValues::const_iterator entry2size;
1054     for ( entry2size =  enfVertexEntrySizeList.cbegin();
1055           entry2size != enfVertexEntrySizeList.cend();
1056           entry2size++ )
1057     {
1058       entryArray.push_back( entry2size->first );
1059     }
1060   }
1061   {
1062     const THyp::TCoordsGHS3DEnforcedVertexMap&
1063       coordsEnfVertexMap = h->_GetEnforcedVerticesByCoords();
1064     THyp::TCoordsGHS3DEnforcedVertexMap::const_iterator size2ev = coordsEnfVertexMap.cbegin();
1065     for ( ; size2ev != coordsEnfVertexMap.cend(); ++size2ev )
1066     {
1067       const THyp::TGHS3DEnforcedVertex* ev = size2ev->second;
1068       entryArray.push_back( ev->geomEntry );
1069     }
1070   }
1071   {
1072     const THyp::TGeomEntryGHS3DEnforcedVertexMap&
1073       geomEntryEnfVertexMap = h->_GetEnforcedVerticesByEntry();
1074     THyp::TGeomEntryGHS3DEnforcedVertexMap::const_iterator entry2ev;
1075     for ( entry2ev =  geomEntryEnfVertexMap.cbegin();
1076           entry2ev != geomEntryEnfVertexMap.cend();
1077           entry2ev++ )
1078     {
1079       entryArray.push_back( entry2ev->first );
1080
1081       const THyp::TGHS3DEnforcedVertex* ev = entry2ev->second;
1082       entryArray.push_back( ev->geomEntry );
1083     }
1084   }
1085
1086   return entryArray.size() > 0;
1087 }
1088
1089 //================================================================================
1090 /*!
1091  * \brief Set new geometry instead of that returned by getObjectsDependOn()
1092  */
1093 //================================================================================
1094
1095 bool
1096 GHS3DPlugin_Hypothesis_i::setObjectsDependOn( std::vector< std::string > & entryArray,
1097                                               std::vector< int >         & subIDArray )
1098 {
1099   typedef ::GHS3DPlugin_Hypothesis THyp;
1100   THyp* h = static_cast< THyp*>( myBaseImpl );
1101
1102   size_t iEnt = 0;
1103   {
1104     THyp::TGHS3DEnforcedVertexList& enfVertexList =
1105       const_cast<THyp::TGHS3DEnforcedVertexList& >( h->_GetEnforcedVertices() );
1106     THyp::TGHS3DEnforcedVertexList::iterator evIt = enfVertexList.begin();
1107     for ( ; evIt != enfVertexList.end(); ++evIt )
1108     {
1109       THyp::TGHS3DEnforcedVertex* ev = *evIt;
1110       ev->geomEntry = entryArray[ iEnt++ ];
1111     }
1112   }
1113   {
1114     THyp::TGHS3DEnforcedVertexEntryValues& enfVertexEntrySizeListNew =
1115       const_cast< THyp::TGHS3DEnforcedVertexEntryValues& > ( h->_GetEnforcedVerticesEntrySize() );
1116     THyp::TGHS3DEnforcedVertexEntryValues enfVertexEntrySizeList;
1117     enfVertexEntrySizeList.swap( enfVertexEntrySizeListNew );
1118     THyp::TGHS3DEnforcedVertexEntryValues::const_iterator entry2size;
1119     for ( entry2size =  enfVertexEntrySizeList.cbegin();
1120           entry2size != enfVertexEntrySizeList.cend();
1121           entry2size++, ++iEnt )
1122     {
1123       if ( entry2size->first.empty() == entryArray[ iEnt ].empty() )
1124         enfVertexEntrySizeListNew[ entryArray[ iEnt ]] = entry2size->second;
1125     }
1126   }
1127   {
1128     THyp::TCoordsGHS3DEnforcedVertexMap& coordsEnfVertexMap =
1129       const_cast< THyp::TCoordsGHS3DEnforcedVertexMap& > ( h->_GetEnforcedVerticesByCoords() );
1130     THyp::TCoordsGHS3DEnforcedVertexMap::iterator size2ev = coordsEnfVertexMap.begin();
1131     for ( ; size2ev != coordsEnfVertexMap.end(); ++size2ev )
1132     {
1133       THyp::TGHS3DEnforcedVertex* ev = size2ev->second;
1134       ev->geomEntry = entryArray[ iEnt++ ];
1135     }
1136   }
1137   {
1138     THyp::TGeomEntryGHS3DEnforcedVertexMap& geomEntryEnfVertexMapNew =
1139       const_cast< THyp::TGeomEntryGHS3DEnforcedVertexMap& > ( h->_GetEnforcedVerticesByEntry() );
1140     THyp::TGeomEntryGHS3DEnforcedVertexMap geomEntryEnfVertexMap;
1141     geomEntryEnfVertexMap.swap( geomEntryEnfVertexMapNew );
1142     THyp::TGeomEntryGHS3DEnforcedVertexMap::iterator entry2ev;
1143     for ( entry2ev =  geomEntryEnfVertexMap.begin();
1144           entry2ev != geomEntryEnfVertexMap.end();
1145           entry2ev++ )
1146     {
1147       const std::string& entry = entryArray[ iEnt++ ];
1148       THyp::TGHS3DEnforcedVertex* ev = entry2ev->second;
1149       ev->geomEntry = entryArray[ iEnt++ ];
1150
1151       geomEntryEnfVertexMapNew[ entry ] = ev;
1152     }
1153   }
1154
1155   return iEnt == entryArray.size();
1156 }