Version: 9.12.0
SMESH_Gen_i.hxx
Go to the documentation of this file.
1 // Copyright (C) 2007-2023 CEA, EDF, OPEN CASCADE
2 //
3 // Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
5 //
6 // This library is free software; you can redistribute it and/or
7 // modify it under the terms of the GNU Lesser General Public
8 // License as published by the Free Software Foundation; either
9 // version 2.1 of the License, or (at your option) any later version.
10 //
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 // Lesser General Public License for more details.
15 //
16 // You should have received a copy of the GNU Lesser General Public
17 // License along with this library; if not, write to the Free Software
18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 //
20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
21 //
22 // File : SMESH_Gen_i.hxx
23 // Author : Paul RASCLE, EDF
24 // Module : SMESH
25 
26 #ifndef _SMESH_GEN_I_HXX_
27 #define _SMESH_GEN_I_HXX_
28 
29 #include "SMESH.hxx"
30 
31 #include <SALOMEconfig.h>
32 #include CORBA_SERVER_HEADER(SMESH_Gen)
33 #include CORBA_SERVER_HEADER(SMESH_Mesh)
34 #include CORBA_SERVER_HEADER(SMESH_Hypothesis)
35 #include CORBA_CLIENT_HEADER(GEOM_Gen)
36 #include CORBA_CLIENT_HEADER(SALOMEDS)
37 #include CORBA_CLIENT_HEADER(SALOMEDS_Attributes)
38 #include CORBA_CLIENT_HEADER(SALOME_ModuleCatalog)
39 
40 #include "SMESH_Gen.hxx"
41 #include "SMESH_Mesh_i.hxx"
42 #include "SMESH_Hypothesis_i.hxx"
43 
44 #include <SALOME_Component_i.hxx>
45 #include <SALOME_NamingService.hxx>
46 #include <Utils_CorbaException.hxx>
47 
48 #include <GEOM_Client.hxx>
49 #include <smIdType.hxx>
50 
51 #include <TCollection_AsciiString.hxx>
52 #include <Resource_DataMapOfAsciiStringAsciiString.hxx>
53 #include <TColStd_HSequenceOfAsciiString.hxx>
54 #include <NCollection_DataMap.hxx>
55 
56 #include <map>
57 #include <sstream>
58 
59 class SMESH_Mesh_i;
60 class SALOME_LifeCycleCORBA;
61 
62 // ===========================================================
63 // Study context - store study-connected objects references
64 // ==========================================================
66 {
67  typedef NCollection_DataMap< int, std::string > TInt2StringMap;
68  typedef NCollection_DataMap< int, int > TInt2IntMap;
69 public:
70  // constructor
72  // register object in the internal map and return its id
73  int addObject( const std::string& theIOR );
74  // find the object id in the internal map by the IOR
75  int findId( const std::string& theIOR );
76  // get object's IOR by id
77  std::string getIORbyId( const int theId );
78  // get object's IOR by old id
79  std::string getIORbyOldId( const int theOldId );
80  // maps old object id to the new one (used when restoring data)
81  void mapOldToNew( const int oldId, const int newId );
82  // get old id by a new one
83  int getOldId( const int newId );
84  // clear data
85  void Clear();
86 
87 private:
88  // get next free object identifier
89  int getNextId() { return mapIdToIOR.Extent() + 1; }
90 
91  TInt2StringMap mapIdToIOR; // persistent-to-transient map
92  TInt2IntMap mapIdToId; // to translate object from persistent to transient form
93 };
94 
95 // ===========================================================
96 // SMESH module's engine
97 // ==========================================================
98 class SMESH_I_EXPORT SMESH_Gen_i : public POA_SMESH::SMESH_Gen, public Engines_Component_i
99 {
100 public:
101  // Get last created instance of the class
102  static SMESH_Gen_i* GetSMESHGen() { return mySMESHGen;}
103  // Get ORB object
104  static CORBA::ORB_var GetORB() { return myOrb;}
105  // Get SMESH module's POA object
106  static PortableServer::POA_var GetPOA() { return myPoa;}
107  // Set Naming Service object
108  static void SetNS(SALOME_NamingService_Abstract *ns);
109  // Get Naming Service object
110  static SALOME_NamingService_Abstract* GetNS();
111  // Get SALOME_LifeCycleCORBA object
112  static SALOME_LifeCycleCORBA* GetLCC();
113  // Retrieve and get GEOM engine reference
114  static GEOM::GEOM_Gen_var GetGeomEngine( GEOM::GEOM_Object_ptr );
115  // Retrieve Study depending on Session / Standalone mode
116  virtual GEOM::GEOM_Gen_var GetGeomEngine( bool isShaper ) = 0;
117  SALOMEDS::Study_var getStudyServant() const { return this->getStudyServantVirtual(); }
118  virtual SALOMEDS::Study_var getStudyServantVirtual() const = 0 ;
119  virtual SALOME_ModuleCatalog::ModuleCatalog_var getModuleCatalog() const = 0;
120  SALOMEDS::SObject_ptr publish(CORBA::Object_ptr theIOR,
121  SALOMEDS::SObject_ptr theFatherObject,
122  const int theTag = 0,
123  const char* thePixMap = 0,
124  const bool theSelectable = true);
125  // Get object of the CORBA reference
126  static PortableServer::ServantBase_var GetServant( CORBA::Object_ptr theObject );
127  // Get CORBA object corresponding to the SALOMEDS::SObject
128  static CORBA::Object_var SObjectToObject( SALOMEDS::SObject_ptr theSObject );
129  // Get the SALOMEDS::SObject corresponding to a CORBA object
130  SALOMEDS::SObject_ptr ObjectToSObject( CORBA::Object_ptr theObject );
131  // Get GEOM Object corresponding to TopoDS_Shape
132  static GEOM::GEOM_Object_ptr ShapeToGeomObject( const TopoDS_Shape& theShape );
133  // Get TopoDS_Shape corresponding to GEOM_Object
134  static TopoDS_Shape GeomObjectToShape( GEOM::GEOM_Object_ptr theGeomObject );
135  // Get GEOM Object by its study entry
136  static GEOM::GEOM_Object_ptr GetGeomObjectByEntry( const std::string& entry );
137 
138  // Default constructor
139  SMESH_Gen_i();
140  // Standard constructor
141  SMESH_Gen_i( CORBA::ORB_ptr orb,
142  PortableServer::POA_ptr poa,
143  PortableServer::ObjectId* contId,
144  const char* instanceName,
145  const char* interfaceName,
146  bool checkNS = true);
147  // Destructor
148  virtual ~SMESH_Gen_i();
149 
150  // *****************************************
151  // Interface methods
152  // *****************************************
153  // Set a new Mesh object name
154  void SetName(const char* theIOR,
155  const char* theName);
156 
157  //GEOM::GEOM_Gen_ptr SetGeomEngine( const char* containerLoc );
158  void SetGeomEngine( GEOM::GEOM_Gen_ptr geomcompo );
159 
160  // Set embedded mode
161  void SetEmbeddedMode( CORBA::Boolean theMode );
162  // Check embedded mode
163  CORBA::Boolean IsEmbeddedMode();
164 
165  // Set enable publishing in the study
166  void SetEnablePublish( CORBA::Boolean theIsEnablePublish );
167 
168  // Check enable publishing
169  CORBA::Boolean IsEnablePublish();
170 
171  // Update study
172  void UpdateStudy();
173 
174  // Do provide info on objects
175  bool hasObjectInfo();
176 
177  // Return an information for a given object
178  char* getObjectInfo(const char* entry);
179 
180  // Create hypothesis/algorithm of given type
181  SMESH::SMESH_Hypothesis_ptr CreateHypothesis (const char* theHypType,
182  const char* theLibName);
183 
184  SMESH::SMESH_Hypothesis_ptr CreateHypothesisByAverageLength( const char* theHypType,
185  const char* theLibName,
186  CORBA::Double theAverageLength,
187  CORBA::Boolean theQuadDominated);
188 
189  // Return hypothesis of given type holding parameter values of the existing mesh
190  SMESH::SMESH_Hypothesis_ptr
191  GetHypothesisParameterValues (const char* theHypType,
192  const char* theLibName,
193  SMESH::SMESH_Mesh_ptr theMesh,
194  GEOM::GEOM_Object_ptr theGeom,
195  const SMESH::HypInitParams& theWay);
196 
197  /*
198  * Returns True if a hypothesis is assigned to a sole sub-mesh in a current Study
199  */
200  CORBA::Boolean GetSoleSubMeshUsingHyp( SMESH::SMESH_Hypothesis_ptr theHyp,
201  SMESH::SMESH_Mesh_out theMesh,
202  GEOM::GEOM_Object_out theShape);
203 
204  // Preferences
205  // ------------
210  void SetBoundaryBoxSegmentation( CORBA::Long theNbSegments );
214  void SetDefaultNbSegments(CORBA::Long theNbSegments);
215 
219  virtual void SetOption(const char*, const char*);
223  virtual char* GetOption(const char*);
224 
228  bool ToForgetMeshDataOnHypModif() const { return myToForgetMeshDataOnHypModif; }
229 
230 
231  // Create empty mesh on a shape
232  SMESH::SMESH_Mesh_ptr CreateMesh( GEOM::GEOM_Object_ptr theShapeObject );
233 
234  // Create empty parallel mesh on a shape
235  SMESH::SMESH_ParallelMesh_ptr CreateParallelMesh( GEOM::GEOM_Object_ptr theShapeObject );
236 
237  // Create empty mesh
238  SMESH::SMESH_Mesh_ptr CreateEmptyMesh();
239 
240  // Create a mesh and import data from an UNV file
241  SMESH::SMESH_Mesh_ptr CreateMeshesFromUNV( const char* theFileName );
242 
243  // Create mesh(es) and import data from MED file
244  SMESH::mesh_array* CreateMeshesFromMED( const char* theFileName,
245  SMESH::DriverMED_ReadStatus& theStatus );
246 
247  // Create a mesh and import data from a STL file
248  SMESH::SMESH_Mesh_ptr CreateMeshesFromSTL( const char* theFileName );
249 
250  // Create mesh(es) and import data from CGNS file
251  SMESH::mesh_array* CreateMeshesFromCGNS( const char* theFileName,
252  SMESH::DriverMED_ReadStatus& theStatus );
253 
254  // Create a mesh and import data from a GMF file
255  SMESH::SMESH_Mesh_ptr CreateMeshesFromGMF( const char* theFileName,
256  CORBA::Boolean theMakeRequiredGroups,
257  SMESH::ComputeError_out theError);
258 
259  // Create dual mesh of a tetrahedron mesh
260  SMESH::SMESH_Mesh_ptr CreateDualMesh(SMESH::SMESH_IDSource_ptr meshPart,
261  const char* meshName,
262  CORBA::Boolean adapt_to_shape);
263 
264  // Copy a part of mesh
265  SMESH::SMESH_Mesh_ptr CopyMesh(SMESH::SMESH_IDSource_ptr meshPart,
266  const char* meshName,
267  CORBA::Boolean toCopyGroups,
268  CORBA::Boolean toKeepIDs);
269 
270  // Create a mesh by copying definitions of another mesh to a given geometry
271  CORBA::Boolean CopyMeshWithGeom( SMESH::SMESH_Mesh_ptr sourceMesh,
272  GEOM::GEOM_Object_ptr newGeometry,
273  const char* meshName,
274  CORBA::Boolean toCopyGroups,
275  CORBA::Boolean toReuseHypotheses,
276  CORBA::Boolean toCopyElements,
277  SMESH::SMESH_Mesh_out newMesh,
278  SMESH::ListOfGroups_out newGroups,
279  SMESH::submesh_array_out newSubmeshes,
280  SMESH::ListOfHypothesis_out newHypotheses,
281  SMESH::string_array_out invalidEntries);
282 
283  // Compute mesh on a shape
284  CORBA::Boolean Compute( SMESH::SMESH_Mesh_ptr theMesh,
285  GEOM::GEOM_Object_ptr theShapeObject );
286 
287  // Cancel Compute mesh on a shape
288  void CancelCompute( SMESH::SMESH_Mesh_ptr theMesh,
289  GEOM::GEOM_Object_ptr theShapeObject );
290 
294  SMESH::compute_error_array* GetComputeErrors(SMESH::SMESH_Mesh_ptr theMesh,
295  GEOM::GEOM_Object_ptr theShapeObject );
296 
302  SMESH::smIdType_array* Evaluate(SMESH::SMESH_Mesh_ptr theMesh,
303  GEOM::GEOM_Object_ptr theShapeObject);
304 
305  // Returns true if mesh contains enough data to be computed
306  CORBA::Boolean IsReadyToCompute( SMESH::SMESH_Mesh_ptr theMesh,
307  GEOM::GEOM_Object_ptr theShapeObject );
308 
314  SMESH::MeshPreviewStruct* Precompute( SMESH::SMESH_Mesh_ptr theMesh,
315  GEOM::GEOM_Object_ptr theSubObject,
316  SMESH::Dimension theDimension,
317  SMESH::long_array& theShapesId );
318 
319  // Returns errors of hypotheses definition
320  SMESH::algo_error_array* GetAlgoState( SMESH::SMESH_Mesh_ptr theMesh,
321  GEOM::GEOM_Object_ptr theSubObject );
322 
323  // Return mesh elements preventing computation of a subshape
324  SMESH::MeshPreviewStruct* GetBadInputElements( SMESH::SMESH_Mesh_ptr theMesh,
325  CORBA::Short theSubShapeID );
326 
327  // Create groups of elements preventing computation of a sub-shape
328  SMESH::ListOfGroups* MakeGroupsOfBadInputElements( SMESH::SMESH_Mesh_ptr theMesh,
329  CORBA::Short theSubShapeID,
330  const char* theGroupName);
331 
332  // Get sub-shapes unique ID's list
333  SMESH::long_array* GetSubShapesId( GEOM::GEOM_Object_ptr theMainShapeObject,
334  const SMESH::object_array& theListOfSubShape );
335 
336  // Return geometrical object the given element is built on. Publish it in study.
337  GEOM::GEOM_Object_ptr GetGeometryByMeshElement( SMESH::SMESH_Mesh_ptr theMesh,
338  SMESH::smIdType theElementID,
339  const char* theGeomName);
340 
341  // Return geometrical object the given element is built on. Don't publish it in study.
342  GEOM::GEOM_Object_ptr FindGeometryByMeshElement( SMESH::SMESH_Mesh_ptr theMesh,
343  SMESH::smIdType theElementID);
344 
345  // Concatenate the given meshes into one mesh
346  SMESH::SMESH_Mesh_ptr ConcatenateCommon(const SMESH::ListOfIDSources& meshesArray,
347  CORBA::Boolean uniteIdenticalGroups,
348  CORBA::Boolean mergeNodesAndElements,
349  CORBA::Double mergeTolerance,
350  CORBA::Boolean commonGroups,
351  SMESH::SMESH_Mesh_ptr meshToAppendTo);
352 
353  // Concatenate the given meshes into one mesh
354  SMESH::SMESH_Mesh_ptr Concatenate(const SMESH::ListOfIDSources& meshesArray,
355  CORBA::Boolean uniteIdenticalGroups,
356  CORBA::Boolean mergeNodesAndElements,
357  CORBA::Double mergeTolerance,
358  SMESH::SMESH_Mesh_ptr meshToAppendTo);
359 
360  // Concatenate the given meshes into one mesh
361  // Create the groups of all elements from initial meshes
362  SMESH::SMESH_Mesh_ptr ConcatenateWithGroups(const SMESH::ListOfIDSources& meshesArray,
363  CORBA::Boolean uniteIdenticalGroups,
364  CORBA::Boolean mergeNodesAndElements,
365  CORBA::Double mergeTolerance,
366  SMESH::SMESH_Mesh_ptr meshToAppendTo);
367 
368  // Get version of MED format being used.
369  char* GetMEDFileVersion();
370 
371  // Get MED version of the file by its name
372  char* GetMEDVersion(const char* theFileName);
373 
374  // Check compatibility of file with MED format being used, read only.
375  CORBA::Boolean CheckCompatibility(const char* theFileName);
376 
377  // Check compatibility of file with MED format being used, for append on write.
378  CORBA::Boolean CheckWriteCompatibility(const char* theFileName);
379 
380  // Get names of meshes defined in file with the specified name
381  SMESH::string_array* GetMeshNames(const char* theFileName);
382 
383  // ****************************************************
384  // Interface inherited methods (from SALOMEDS::Driver)
385  // ****************************************************
386 
387  // Save SMESH data
388  SALOMEDS::TMPFile* Save( SALOMEDS::SComponent_ptr theComponent,
389  const char* theURL,
390  bool isMultiFile );
391  // Load SMESH data
392  bool Load( SALOMEDS::SComponent_ptr theComponent,
393  const SALOMEDS::TMPFile& theStream,
394  const char* theURL,
395  bool isMultiFile );
396  // Save SMESH data in ASCII format
397  SALOMEDS::TMPFile* SaveASCII( SALOMEDS::SComponent_ptr theComponent,
398  const char* theURL,
399  bool isMultiFile );
400  // Load SMESH data in ASCII format
401  bool LoadASCII( SALOMEDS::SComponent_ptr theComponent,
402  const SALOMEDS::TMPFile& theStream,
403  const char* theURL,
404  bool isMultiFile );
405 
406  // Create filter manager
407  SMESH::FilterManager_ptr CreateFilterManager();
408 
409  // Return a pattern mesher
410  SMESH::SMESH_Pattern_ptr GetPattern();
411 
412  // Create measurement instance
413  SMESH::Measurements_ptr CreateMeasurements();
414 
415  // Clears study-connected data when it is closed
416  void Close( SALOMEDS::SComponent_ptr theComponent );
417 
418  // Get component data type
419  char* ComponentDataType();
420 
421  // Transform data from transient form to persistent
422  char* IORToLocalPersistentID( SALOMEDS::SObject_ptr theSObject,
423  const char* IORString,
424  CORBA::Boolean isMultiFile,
425  CORBA::Boolean isASCII );
426  // Transform data from persistent form to transient
427  char* LocalPersistentIDToIOR( SALOMEDS::SObject_ptr theSObject,
428  const char* aLocalPersistentID,
429  CORBA::Boolean isMultiFile,
430  CORBA::Boolean isASCII );
431 
432  // Returns true if object can be published in the study
433  bool CanPublishInStudy( CORBA::Object_ptr theIOR );
434  // Publish object in the study
435  SALOMEDS::SObject_ptr PublishInStudy( SALOMEDS::SObject_ptr theSObject,
436  CORBA::Object_ptr theObject,
437  const char* theName );
438 
439  // Copy-paste methods - returns true if object can be copied to the clipboard
440  CORBA::Boolean CanCopy( SALOMEDS::SObject_ptr /*theObject*/ ) { return false; }
441  // Copy-paste methods - copy object to the clipboard
442  SALOMEDS::TMPFile* CopyFrom( SALOMEDS::SObject_ptr /*theObject*/, CORBA::Long& /*theObjectID*/ ) { return NULL; }
443  // Copy-paste methods - returns true if object can be pasted from the clipboard
444  CORBA::Boolean CanPaste( const char* /*theComponentName*/, CORBA::Long /*theObjectID*/ ) { return false; }
445  // Copy-paste methods - paste object from the clipboard
446  SALOMEDS::SObject_ptr PasteInto( const SALOMEDS::TMPFile& /*theStream*/,
447  CORBA::Long /*theObjectID*/,
448  SALOMEDS::SObject_ptr /*theObject*/ ) {
449  SALOMEDS::SObject_var aResultSO;
450  return aResultSO._retn();
451  }
452 
453  // ============
454  // Version information
455  // ============
456 
457  virtual char* getVersion();
458 
459  // ============
460  // Dump python
461  // ============
462 
463  virtual Engines::TMPFile* DumpPython(CORBA::Boolean isPublished,
464  CORBA::Boolean isMultiFile,
465  CORBA::Boolean& isValidScript);
466 
467  void AddToPythonScript (const TCollection_AsciiString& theString);
468 
469  void RemoveLastFromPythonScript();
470 
471  void SavePython();
472 
473  TCollection_AsciiString DumpPython_impl (Resource_DataMapOfAsciiStringAsciiString& theObjectNames,
474  Resource_DataMapOfAsciiStringAsciiString& theNames,
475  bool isPublished,
476  bool isMultiFile,
477  bool isHistoricalDump,
478  bool& aValidScript,
479  TCollection_AsciiString& theSavedTrace);
480 
481  TCollection_AsciiString GetNewPythonLines();
482 
483  void CleanPythonTrace();
484 
485  int CountInPyDump(const TCollection_AsciiString& text);
486 
487  SMESH::MG_ADAPT_ptr CreateMG_ADAPT();
488  SMESHHOMARD::HOMARD_Gen_ptr CreateHOMARD_ADAPT();
489  SMESH::MG_ADAPT_ptr CreateAdaptationHypothesis();
490  //SMESH::MG_ADAPT_OBJECT_ptr Adaptation( const char* adaptationType);
491  SALOME::GenericObj_ptr Adaptation( const char* adaptationType);
492 
493  // *****************************************
494  // Internal methods
495  // *****************************************
496 public:
497  // Get shape reader
498  GEOM_Client* GetShapeReader();
499 
500  // Tags definition
501  static long GetHypothesisRootTag();
502  static long GetAlgorithmsRootTag();
503  static long GetRefOnShapeTag();
504  static long GetRefOnAppliedHypothesisTag();
505  static long GetRefOnAppliedAlgorithmsTag();
506  static long GetSubMeshOnVertexTag();
507  static long GetSubMeshOnEdgeTag();
508  static long GetSubMeshOnFaceTag();
509  static long GetSubMeshOnSolidTag();
510  static long GetSubMeshOnCompoundTag();
511  static long GetSubMeshOnWireTag();
512  static long GetSubMeshOnShellTag();
513  static long GetNodeGroupsTag();
514  static long GetEdgeGroupsTag();
515  static long GetFaceGroupsTag();
516  static long GetVolumeGroupsTag();
517  static long Get0DElementsGroupsTag();
518  static long GetBallElementsGroupsTag();
519 
520  // publishing methods
521  SALOMEDS::SComponent_ptr PublishComponent();
522  SALOMEDS::SObject_ptr PublishMesh (SMESH::SMESH_Mesh_ptr theMesh,
523  const char* theName = 0);
524  SALOMEDS::SObject_ptr PublishHypothesis (SMESH::SMESH_Hypothesis_ptr theHyp,
525  const char* theName = 0);
526  SALOMEDS::SObject_ptr PublishSubMesh (SMESH::SMESH_Mesh_ptr theMesh,
527  SMESH::SMESH_subMesh_ptr theSubMesh,
528  GEOM::GEOM_Object_ptr theShapeObject,
529  const char* theName = 0);
530  SALOMEDS::SObject_ptr PublishGroup (SMESH::SMESH_Mesh_ptr theMesh,
531  SMESH::SMESH_GroupBase_ptr theGroup,
532  GEOM::GEOM_Object_ptr theShapeObject,
533  const char* theName = 0);
534  void UpdateIcons(SMESH::SMESH_Mesh_ptr theMesh);
535  void HighLightInvalid(CORBA::Object_ptr theObject, bool isInvalid);
536  bool IsInvalid(SALOMEDS::SObject_ptr theObject);
537  bool AddHypothesisToShape(SMESH::SMESH_Mesh_ptr theMesh,
538  GEOM::GEOM_Object_ptr theShapeObject,
539  SMESH::SMESH_Hypothesis_ptr theHyp);
540  bool RemoveHypothesisFromShape(SMESH::SMESH_Mesh_ptr theMesh,
541  GEOM::GEOM_Object_ptr theShapeObject,
542  SMESH::SMESH_Hypothesis_ptr theHyp);
543  SALOMEDS::SObject_ptr GetMeshOrSubmeshByShape (SMESH::SMESH_Mesh_ptr theMesh,
544  GEOM::GEOM_Object_ptr theShape);
545  void SetName(SALOMEDS::SObject_ptr theSObject,
546  const char* theName,
547  const char* theDefaultName = 0);
548 
549  void SetPixMap(SALOMEDS::SObject_ptr theSObject, const char *thePixMap);
550  void addReference (SALOMEDS::SObject_ptr theSObject, CORBA::Object_ptr theToObject, int theTag = 0);
551 
552  // Get study context
553  StudyContext* GetStudyContext();
554 
555  // Register an object in a StudyContext; return object id
556  int RegisterObject(CORBA::Object_ptr theObject);
557 
558  // Return id of registered object
559  CORBA::Long GetObjectId(CORBA::Object_ptr theObject);
560 
561  // Return an object that previously had an oldID
562  template<class TInterface>
563  typename TInterface::_var_type GetObjectByOldId( const int oldID )
564  {
565  if ( myStudyContext ) {
566  std::string ior = myStudyContext->getIORbyOldId( oldID );
567  if ( !ior.empty() )
568  return TInterface::_narrow(GetORB()->string_to_object( ior.c_str() ));
569  }
570  return TInterface::_nil();
571  }
572 
576  SALOMEDS::SObject_ptr GetAlgoSO(const ::SMESH_Algo* algo);
577 
578  void UpdateParameters(CORBA::Object_ptr theObject, const char* theParameters);
579  char* GetParameters(CORBA::Object_ptr theObject);
580  //char* ParseParameters(const char* theParameters);
581  const std::vector< int >& GetLastParamIndices() const { return myLastParamIndex; }
582  const std::vector< std::string >& GetLastParameters() const { return myLastParameters; }
583  const std::string & GetLastObjEntry() const { return myLastObj; }
584  std::vector< std::string > GetAllParameters(const std::string& theObjectEntry) const;
585 
586  // Move objects to the specified position
587  void Move( const SMESH::sobject_list& what,
588  SALOMEDS::SObject_ptr where,
589  CORBA::Long row );
590 
591  CORBA::Boolean IsApplicable ( const char* theAlgoType,
592  const char* theLibName,
593  GEOM::GEOM_Object_ptr theShapeObject,
594  CORBA::Boolean toCheckAll);
595 
596  SMESH::long_array* GetInsideSphere( SMESH::SMESH_IDSource_ptr meshPart,
597  SMESH::ElementType theElemType,
598  CORBA::Double theX,
599  CORBA::Double theY,
600  CORBA::Double theZ,
601  CORBA::Double theR);
602 
603  SMESH::long_array* GetInsideBox( SMESH::SMESH_IDSource_ptr meshPart,
604  SMESH::ElementType theElemType,
605  CORBA::Double theX1,
606  CORBA::Double theY1,
607  CORBA::Double theZ1,
608  CORBA::Double theX2,
609  CORBA::Double theY2,
610  CORBA::Double theZ2);
611 
612  SMESH::long_array* GetInsideCylinder( SMESH::SMESH_IDSource_ptr meshPart,
613  SMESH::ElementType theElemType,
614  CORBA::Double theX,
615  CORBA::Double theY,
616  CORBA::Double theZ,
617  CORBA::Double theDX,
618  CORBA::Double theDY,
619  CORBA::Double theDZ,
620  CORBA::Double theH,
621  CORBA::Double theR );
622 
623  SMESH::long_array* GetInside( SMESH::SMESH_IDSource_ptr meshPart,
624  SMESH::ElementType theElemType,
625  GEOM::GEOM_Object_ptr theGeom,
626  CORBA::Double theTolerance );
627 
628 private:
629  // Get hypothesis creator
630  GenericHypothesisCreator_i* getHypothesisCreator( const char* theHypName,
631  const char* theLibName,
632  std::string& thePlatformLibName);
633  // Create hypothesis of given type
634  SMESH::SMESH_Hypothesis_ptr createHypothesis( const char* theHypName,
635  const char* theLibName);
636  // Create empty mesh on shape
637  SMESH::SMESH_Mesh_ptr createMesh();
638  SMESH::SMESH_ParallelMesh_ptr createParallelMesh();
639 
640  // Check mesh icon
641  bool isGeomModifIcon( SMESH::SMESH_Mesh_ptr mesh );
642 
643  // Create a sub-mesh on a geometry that is not a sub-shape of the main shape
644  // for the case where a valid sub-shape not found by CopyMeshWithGeom()
645  SMESH::SMESH_subMesh_ptr createInvalidSubMesh( SMESH::SMESH_Mesh_ptr mesh,
646  GEOM::GEOM_Object_ptr strangerGeom,
647  const char* name );
648 
649  void highLightInvalid( SALOMEDS::SObject_ptr theSObject, bool isInvalid );
650 
651  std::vector<long> _GetInside(SMESH::SMESH_IDSource_ptr meshPart,
652  SMESH::ElementType ElemType,
653  const TopoDS_Shape& Shape,
654  double* Tolerance = NULL);
655 
656 protected:
657  static GEOM::GEOM_Gen_var myGeomGen;
658  static SALOME_NamingService_Abstract* myNS; // Naming Service
659 private:
660  static CORBA::ORB_var myOrb; // ORB reference
661  static PortableServer::POA_var myPoa; // POA reference
662  static SALOME_LifeCycleCORBA* myLCC; // Life Cycle CORBA
663  static SMESH_Gen_i* mySMESHGen; // Point to last created instance of the class
664  ::SMESH_Gen myGen; // SMESH_Gen local implementation
665 
666  // hypotheses managing
667  std::map<std::string, GenericHypothesisCreator_i*> myHypCreatorMap;
668 
669  StudyContext* myStudyContext; // study context
670 
671  GEOM_Client* myShapeReader; // Shape reader
672  CORBA::Boolean myIsEmbeddedMode; // Current mode
673  CORBA::Boolean myIsEnablePublish; // Enable publishing
674 
675  // Default color of groups
676  std::string myDefaultGroupColor;
677 
678  // To load full mesh data from study at hyp modification or not
680 
681  // Dump Python: trace of API methods calls
682  Handle(TColStd_HSequenceOfAsciiString) myPythonScript;
684  std::vector< int > myLastParamIndex;
685  std::vector< std::string > myLastParameters;
686  std::string myLastObj;
687 };
688 
689 
690 namespace SMESH
691 {
692  template<class T>
693  T
694  DownCast(CORBA::Object_ptr theArg)
695  {
696  return dynamic_cast<T>(SMESH_Gen_i::GetServant(theArg).in());
697  }
698 
703  inline void throwCorbaException(const char* excText)
704  {
705  THROW_SALOME_CORBA_EXCEPTION( excText, SALOME::INTERNAL_ERROR );
706  }
707 }
708 
709 
710 #endif
#define SMESH_I_EXPORT
Definition: SMESH.hxx:39
Definition: SMESH_Hypothesis_i.hxx:144
Definition: SMESH_Gen_i.hxx:99
::SMESH_Gen myGen
Definition: SMESH_Gen_i.hxx:664
std::string myLastObj
Definition: SMESH_Gen_i.hxx:686
virtual SALOME_ModuleCatalog::ModuleCatalog_var getModuleCatalog() const =0
CORBA::Boolean myIsEnablePublish
Definition: SMESH_Gen_i.hxx:673
static PortableServer::POA_var myPoa
Definition: SMESH_Gen_i.hxx:661
static PortableServer::POA_var GetPOA()
Definition: SMESH_Gen_i.hxx:106
const std::vector< std::string > & GetLastParameters() const
Definition: SMESH_Gen_i.hxx:582
CORBA::Boolean CanPaste(const char *, CORBA::Long)
Definition: SMESH_Gen_i.hxx:444
SALOMEDS::Study_var getStudyServant() const
Definition: SMESH_Gen_i.hxx:117
Handle(TColStd_HSequenceOfAsciiString) myPythonScript
StudyContext * myStudyContext
Definition: SMESH_Gen_i.hxx:669
bool ToForgetMeshDataOnHypModif() const
To load full mesh data from study at hyp modification or not.
Definition: SMESH_Gen_i.hxx:228
static CORBA::ORB_var GetORB()
Definition: SMESH_Gen_i.hxx:104
virtual GEOM::GEOM_Gen_var GetGeomEngine(bool isShaper)=0
static SMESH_Gen_i * GetSMESHGen()
Definition: SMESH_Gen_i.hxx:102
const std::string & GetLastObjEntry() const
Definition: SMESH_Gen_i.hxx:583
CORBA::Boolean myIsEmbeddedMode
Definition: SMESH_Gen_i.hxx:672
CORBA::Boolean CanCopy(SALOMEDS::SObject_ptr)
Definition: SMESH_Gen_i.hxx:440
std::map< std::string, GenericHypothesisCreator_i * > myHypCreatorMap
Definition: SMESH_Gen_i.hxx:667
static SMESH_Gen_i * mySMESHGen
Definition: SMESH_Gen_i.hxx:663
bool myToForgetMeshDataOnHypModif
Definition: SMESH_Gen_i.hxx:679
std::vector< int > myLastParamIndex
Definition: SMESH_Gen_i.hxx:684
static SALOME_NamingService_Abstract * myNS
Definition: SMESH_Gen_i.hxx:658
TInterface::_var_type GetObjectByOldId(const int oldID)
Definition: SMESH_Gen_i.hxx:563
static CORBA::ORB_var myOrb
Definition: SMESH_Gen_i.hxx:660
static GEOM::GEOM_Gen_var myGeomGen
Definition: SMESH_Gen_i.hxx:657
GEOM_Client * myShapeReader
Definition: SMESH_Gen_i.hxx:671
static SALOME_LifeCycleCORBA * myLCC
Definition: SMESH_Gen_i.hxx:662
std::vector< std::string > myLastParameters
Definition: SMESH_Gen_i.hxx:685
const std::vector< int > & GetLastParamIndices() const
Definition: SMESH_Gen_i.hxx:581
static PortableServer::ServantBase_var GetServant(CORBA::Object_ptr theObject)
GetServant [ static ].
Definition: SMESH_Gen_i.cxx:188
std::string myDefaultGroupColor
Definition: SMESH_Gen_i.hxx:676
virtual SALOMEDS::Study_var getStudyServantVirtual() const =0
SALOMEDS::SObject_ptr PasteInto(const SALOMEDS::TMPFile &, CORBA::Long, SALOMEDS::SObject_ptr)
Definition: SMESH_Gen_i.hxx:446
bool myIsHistoricalPythonDump
Definition: SMESH_Gen_i.hxx:683
SALOMEDS::TMPFile * CopyFrom(SALOMEDS::SObject_ptr, CORBA::Long &)
Definition: SMESH_Gen_i.hxx:442
Definition: SMESH_Gen.hxx:68
Definition: SMESH_Mesh_i.hxx:57
Definition: SMESH_Gen_i.hxx:66
NCollection_DataMap< int, int > TInt2IntMap
Definition: SMESH_Gen_i.hxx:68
TInt2StringMap mapIdToIOR
Definition: SMESH_Gen_i.hxx:91
int getNextId()
Definition: SMESH_Gen_i.hxx:89
NCollection_DataMap< int, std::string > TInt2StringMap
Definition: SMESH_Gen_i.hxx:67
StudyContext()
Definition: SMESH_Gen_i.hxx:71
TInt2IntMap mapIdToId
Definition: SMESH_Gen_i.hxx:92
bool CheckCompatibility(const std::string &fileName, bool isForAppend)
: Check read or write(append) Compatibility of a med file
Definition: MED_Factory.cxx:114
bool GetMEDVersion(const std::string &fileName, int &major, int &minor, int &release)
Definition: MED_Factory.cxx:150
Definition: SMESH_ControlsDef.hxx:64
T DownCast(CORBA::Object_ptr theArg)
Definition: SMESH_Gen_i.hxx:694
sequence< AlgoStateError > algo_error_array
Definition: SMESH_Gen.idl:96
bool IsApplicable(const QString &aHypType, GEOM::GEOM_Object_ptr theGeomObject, const bool toCheckAll)
Definition: SMESHGUI_HypothesesUtils.cxx:617
sequence< GEOM::GEOM_Object > object_array
Definition: SMESH_Gen.idl:46
SMESH::SMESH_Pattern_var GetPattern()
Definition: SMESHGUI_PatternUtils.cxx:34
sequence< SMESH_IDSource > ListOfIDSources
Definition: SMESH_Mesh.idl:40
sequence< ComputeError > compute_error_array
Definition: SMESH_Gen.idl:125
sequence< smIdType > smIdType_array
Definition: SMESH_Mesh.idl:45
Dimension
Definition: SMESH_Hypothesis.idl:35
void throwCorbaException(const char *excText)
Function used in SMESH_CATCH to convert a caught exception to SALOME::SALOME_Exception.
Definition: SMESH_Gen_i.hxx:703
ElementType
Enumeration for element type, like in SMDS.
Definition: SMESH_Mesh.idl:128
sequence< string > string_array
Definition: SMESH_Mesh.idl:46
sequence< SMESH_GroupBase > ListOfGroups
Definition: SMESH_Mesh.idl:38
sequence< SMESH_Mesh > mesh_array
Definition: SMESH_Gen.idl:47
CORBA::Object_var SObjectToObject(_PTR(SObject) theSObject)
Definition: SMESHGUI_Utils.cxx:180
sequence< SALOMEDS::SObject > sobject_list
Definition: SMESH_Gen.idl:45
SMESH::SMESH_Hypothesis_ptr CreateHypothesis(const QString &aHypType, const QString &aHypName, const bool)
Definition: SMESHGUI_HypothesesUtils.cxx:588
void SetName(_PTR(SObject) theSObject, const QString &theName)
Definition: SMESHGUI_Utils.cxx:134
DriverMED_ReadStatus
Enumeration for mesh read status (used by SMESH_Gen::CreateMeshesFrom*() methods)
Definition: SMESH_Mesh.idl:231
sequence< long > long_array
Definition: SMESH_Mesh.idl:44
Way to initialize hypothesis.
Definition: SMESH_Gen.idl:131
Structure containing mesh edit preview data.
Definition: SMESH_Mesh.idl:279