Salome HOME
Merge branch 'occ/shaper2smesh'
[modules/smesh.git] / src / SMESH_I / SMESH_Gen_i.cxx
1 // Copyright (C) 2007-2019  CEA/DEN, EDF R&D, 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.cxx
23 //  Author : Paul RASCLE, EDF
24 //  Module : SMESH
25
26 #include <BRepPrimAPI_MakeBox.hxx>
27 #include <BRepPrimAPI_MakeCylinder.hxx>
28 #include <BRepPrimAPI_MakeSphere.hxx>
29 #include <BRep_Tool.hxx>
30 #include <OSD.hxx>
31 #include <TColStd_MapOfAsciiString.hxx>
32 #include <TCollection_AsciiString.hxx>
33 #include <TopExp.hxx>
34 #include <TopExp_Explorer.hxx>
35 #include <TopTools_IndexedMapOfShape.hxx>
36 #include <TopTools_ListIteratorOfListOfShape.hxx>
37 #include <TopTools_ListOfShape.hxx>
38 #include <TopTools_MapOfShape.hxx>
39 #include <TopoDS.hxx>
40 #include <TopoDS_CompSolid.hxx>
41 #include <TopoDS_Compound.hxx>
42 #include <TopoDS_Edge.hxx>
43 #include <TopoDS_Face.hxx>
44 #include <TopoDS_Iterator.hxx>
45 #include <TopoDS_Shape.hxx>
46 #include <TopoDS_Shell.hxx>
47 #include <TopoDS_Solid.hxx>
48 #include <TopoDS_Vertex.hxx>
49 #include <TopoDS_Wire.hxx>
50 #include <gp_Pnt.hxx>
51
52
53 #ifdef WIN32
54  #include <windows.h>
55  #include <process.h>
56 #else
57  #include <dlfcn.h>
58  #include <libgen.h> // for basename function
59 #endif
60
61 #ifdef WIN32
62  #define LibHandle HMODULE
63  #define LoadLib( name ) LoadLibrary( name )
64  #define GetProc GetProcAddress
65  #define UnLoadLib( handle ) FreeLibrary( handle );
66 #else // WIN32
67  #define LibHandle void*
68  #ifdef DYNLOAD_LOCAL
69   #define LoadLib( name ) dlopen( name, RTLD_LAZY | RTLD_LOCAL )
70  #else // DYNLOAD_LOCAL
71   #define LoadLib( name ) dlopen( name, RTLD_LAZY | RTLD_GLOBAL )
72  #endif // DYNLOAD_LOCAL
73  #define GetProc dlsym
74  #define UnLoadLib( handle ) dlclose( handle );
75 #endif // WIN32
76
77 #include "SMESH_Gen_i.hxx"
78 #include "SMESH_version.h"
79
80 #include "DriverMED_W_SMESHDS_Mesh.h"
81 #include "DriverMED_R_SMESHDS_Mesh.h"
82 #ifdef WITH_CGNS
83 #include "DriverCGNS_Read.hxx"
84 #endif
85 #include "MED_Factory.hxx"
86 #include "SMDS_EdgePosition.hxx"
87 #include "SMDS_FacePosition.hxx"
88 #include "SMDS_SetIterator.hxx"
89 #include "SMDS_SpacePosition.hxx"
90 #include "SMDS_VertexPosition.hxx"
91 #include "SMESHDS_Document.hxx"
92 #include "SMESHDS_Group.hxx"
93 #include "SMESHDS_GroupOnGeom.hxx"
94 #include "SMESH_Algo_i.hxx"
95 #include "SMESH_File.hxx"
96 #include "SMESH_Group.hxx"
97 #include "SMESH_Group_i.hxx"
98 #include "SMESH_Hypothesis.hxx"
99 #include "SMESH_Hypothesis_i.hxx"
100 #include "SMESH_Mesh.hxx"
101 #include "SMESH_MeshEditor.hxx"
102 #include "SMESH_Mesh_i.hxx"
103 #include "SMESH_PreMeshInfo.hxx"
104 #include "SMESH_PythonDump.hxx"
105 #include "SMESH_ControlsDef.hxx"
106
107 // to pass CORBA exception through SMESH_TRY
108 #define SMY_OWN_CATCH catch( SALOME::SALOME_Exception& se ) { throw se; }
109 #include "SMESH_TryCatch.hxx" // to include after OCC headers!
110
111 #include CORBA_SERVER_HEADER(SMESH_Group)
112 #include CORBA_SERVER_HEADER(SMESH_Filter)
113 #include CORBA_SERVER_HEADER(SMESH_MeshEditor)
114
115
116 #include <GEOMImpl_Types.hxx>
117 #include <GEOM_Client.hxx>
118
119 #include <Basics_Utils.hxx>
120 #include <Basics_DirUtils.hxx>
121 #include <HDFOI.hxx>
122 #include <OpUtil.hxx>
123 #include <SALOMEDS_Tool.hxx>
124 #include <SALOME_Container_i.hxx>
125 #include <SALOME_LifeCycleCORBA.hxx>
126 #include <SALOME_NamingService.hxx>
127 #include <Utils_CorbaException.hxx>
128 #include <Utils_ExceptHandlers.hxx>
129 #include <Utils_SINGLETON.hxx>
130 #include <utilities.h>
131
132 #include CORBA_CLIENT_HEADER(SALOME_ModuleCatalog)
133 #include CORBA_CLIENT_HEADER(SALOME_Session)
134
135 // helpers about SALOME::GenericObj
136 #include <SALOMEDS_wrap.hxx>
137 #include <SALOMEDS_Attributes_wrap.hxx>
138 #include <GEOM_wrap.hxx>
139
140 #include <map>
141 #include <fstream>
142 #include <sstream>
143 #include <cstdio>
144 #include <cstdlib>
145 #include <memory>
146
147 using namespace std;
148 using SMESH::TPythonDump;
149 using SMESH::TVar;
150
151 #define NUM_TMP_FILES 2
152
153 #ifdef _DEBUG_
154 static int MYDEBUG = 0;
155 #else
156 static int MYDEBUG = 0;
157 #endif
158
159 // Static variables definition
160 GEOM::GEOM_Gen_var      SMESH_Gen_i::myGeomGen;
161 CORBA::ORB_var          SMESH_Gen_i::myOrb;
162 PortableServer::POA_var SMESH_Gen_i::myPoa;
163 SALOME_NamingService*   SMESH_Gen_i::myNS  = NULL;
164 SALOME_LifeCycleCORBA*  SMESH_Gen_i::myLCC = NULL;
165 SMESH_Gen_i*            SMESH_Gen_i::mySMESHGen = NULL;
166
167
168 const int nbElemPerDiagonal = 10;
169
170 //=============================================================================
171 /*!
172  *  GetServant [ static ]
173  *
174  *  Get servant of the CORBA object
175  */
176 //=============================================================================
177
178 PortableServer::ServantBase_var SMESH_Gen_i::GetServant( CORBA::Object_ptr theObject )
179 {
180   if( CORBA::is_nil( theObject ) || CORBA::is_nil( GetPOA() ) )
181     return NULL;
182   try {
183     PortableServer::Servant aServant = GetPOA()->reference_to_servant( theObject );
184     return aServant;
185   }
186   catch (PortableServer::POA::ObjectNotActive &ex)
187   {
188     INFOS("GetServant: ObjectNotActive");
189     return NULL;
190   }
191   catch (PortableServer::POA::WrongAdapter &ex)
192   {
193     INFOS("GetServant: WrongAdapter: OK when several servants used to build several mesh in parallel...");
194     return NULL;
195   }
196   catch (PortableServer::POA::WrongPolicy &ex)
197   {
198     INFOS("GetServant: WrongPolicy");
199     return NULL;
200   }
201   catch (...)
202   {
203     INFOS( "GetServant - Unknown exception was caught!!!" );
204     return NULL;
205   }
206 }
207
208 //=============================================================================
209 /*!
210  *  SObjectToObject [ static ]
211  *
212  *  Get CORBA object corresponding to the SALOMEDS::SObject
213  */
214 //=============================================================================
215
216 CORBA::Object_var SMESH_Gen_i::SObjectToObject( SALOMEDS::SObject_ptr theSObject )
217 {
218   SALOMEDS::GenericAttribute_wrap anAttr;
219   CORBA::Object_var anObj;
220   if ( !theSObject->_is_nil() ) {
221     try {
222       if( theSObject->FindAttribute( anAttr.inout(), "AttributeIOR" ) ) {
223         SALOMEDS::AttributeIOR_wrap anIOR  = anAttr;
224         CORBA::String_var aValue = anIOR->Value();
225         if( strcmp( aValue, "" ) != 0 )
226           anObj = GetORB()->string_to_object( aValue );
227       }
228     }
229     catch( ... ) {
230       INFOS( "SObjectToObject - Unknown exception was caught!!!" );
231     }
232   }
233   return anObj;
234 }
235
236 //=============================================================================
237 /*!
238  *  GetNS [ static ]
239  *
240  *  Get SALOME_NamingService object
241  */
242 //=============================================================================
243
244 SALOME_NamingService* SMESH_Gen_i::GetNS()
245 {
246   if ( myNS == NULL ) {
247     myNS = SINGLETON_<SALOME_NamingService>::Instance();
248     ASSERT(SINGLETON_<SALOME_NamingService>::IsAlreadyExisting());
249     myNS->init_orb( GetORB() );
250   }
251   return myNS;
252 }
253
254 //=============================================================================
255 /*!
256  *  GetLCC [ static ]
257  *
258  *  Get SALOME_LifeCycleCORBA object
259  */
260 //=============================================================================
261
262 SALOME_LifeCycleCORBA*  SMESH_Gen_i::GetLCC()
263 {
264   if ( myLCC == NULL ) {
265     myLCC = new SALOME_LifeCycleCORBA( GetNS() );
266   }
267   return myLCC;
268 }
269
270 //=============================================================================
271 /*!
272  *  GetGeomEngine [ static ]
273  *
274  *  Get GEOM::GEOM_Gen reference
275  */
276 //=============================================================================
277
278 GEOM::GEOM_Gen_var SMESH_Gen_i::GetGeomEngine( bool isShaper )
279 {
280   Engines::EngineComponent_ptr temp =
281     GetLCC()->FindOrLoad_Component( isShaper ? "FactoryServer" : "FactoryServer",
282                                     isShaper ? "SHAPERSTUDY" : "GEOM" );
283   myGeomGen = GEOM::GEOM_Gen::_narrow( temp );
284
285   return myGeomGen;
286 }
287
288 //=============================================================================
289 /*!
290  *  GetGeomEngine [ static ]
291  *
292  *  Get GEOM::GEOM_Gen reference
293  */
294 //=============================================================================
295
296 GEOM::GEOM_Gen_var SMESH_Gen_i::GetGeomEngine( GEOM::GEOM_Object_ptr go )
297 {
298   GEOM::GEOM_Gen_ptr gen;
299   if ( !CORBA::is_nil( go ))
300     gen = go->GetGen();
301   return gen;
302 }
303
304 //=============================================================================
305 /*!
306  *  SMESH_Gen_i::SMESH_Gen_i
307  *
308  *  Default constructor: not for use
309  */
310 //=============================================================================
311
312 SMESH_Gen_i::SMESH_Gen_i()
313 {
314 }
315
316 //=============================================================================
317 /*!
318  *  SMESH_Gen_i::SMESH_Gen_i
319  *
320  *  Standard constructor, used with Container
321  */
322 //=============================================================================
323
324 SMESH_Gen_i::SMESH_Gen_i( CORBA::ORB_ptr            orb,
325                           PortableServer::POA_ptr   poa,
326                           PortableServer::ObjectId* contId,
327                           const char*               instanceName,
328                           const char*               interfaceName )
329   : Engines_Component_i( orb, poa, contId, instanceName, interfaceName )
330 {
331
332   myOrb = CORBA::ORB::_duplicate(orb);
333   myPoa = PortableServer::POA::_duplicate(poa);
334
335   _thisObj = this ;
336   _id = myPoa->activate_object( _thisObj );
337
338   myStudyContext = new StudyContext;
339
340   myIsEmbeddedMode = false;
341   myIsEnablePublish = true;
342   myShapeReader = NULL;  // shape reader
343   mySMESHGen = this;
344   myIsHistoricalPythonDump = true;
345   myToForgetMeshDataOnHypModif = false;
346
347   // set it in standalone mode only
348   //OSD::SetSignal( true );
349
350   // 0020605: EDF 1190 SMESH: Display performance. 80 seconds for 52000 cells.
351   // find out mode (embedded or standalone) here else
352   // meshes created before calling SMESH_Client::GetSMESHGen(), which calls
353   // SMESH_Gen_i::SetEmbeddedMode(), have wrong IsEmbeddedMode flag
354   if ( SALOME_NamingService* ns = GetNS() )
355   {
356     CORBA::Object_var obj = ns->Resolve( "/Kernel/Session" );
357     SALOME::Session_var session = SALOME::Session::_narrow( obj ) ;
358     if ( !session->_is_nil() )
359     {
360       CORBA::String_var str_host = session->getHostname();
361       CORBA::Long        s_pid = session->getPID();
362       string my_host = Kernel_Utils::GetHostname();
363 #ifdef WIN32
364       long    my_pid = (long)_getpid();
365 #else
366       long    my_pid = (long) getpid();
367 #endif
368       SetEmbeddedMode( s_pid == my_pid && my_host == str_host.in() );
369     }
370   }
371 }
372
373 //=============================================================================
374 /*!
375  *  SMESH_Gen_i::~SMESH_Gen_i
376  *
377  *  Destructor
378  */
379 //=============================================================================
380
381 SMESH_Gen_i::~SMESH_Gen_i()
382 {
383   // delete hypothesis creators
384   map<string, GenericHypothesisCreator_i*>::iterator itHyp, itHyp2;
385   for (itHyp = myHypCreatorMap.begin(); itHyp != myHypCreatorMap.end(); itHyp++)
386   {
387     // same creator can be mapped under different names
388     GenericHypothesisCreator_i* creator = (*itHyp).second;
389     if ( !creator )
390       continue;
391     delete creator;
392     for (itHyp2 = itHyp; itHyp2 != myHypCreatorMap.end(); itHyp2++)
393       if ( creator == (*itHyp2).second )
394         (*itHyp2).second = 0;
395   }
396   myHypCreatorMap.clear();
397
398   // Clear study contexts data
399   delete myStudyContext;
400
401   // delete shape reader
402   if ( myShapeReader )
403     delete myShapeReader;
404 }
405 //=============================================================================
406 /*!
407  *  SMESH_Gen_i::getHypothesisCreator
408  *
409  *  Get hypothesis creator
410  */
411 //=============================================================================
412 GenericHypothesisCreator_i* SMESH_Gen_i::getHypothesisCreator(const char* theHypName,
413                                                               const char* theLibName,
414                                                               std::string& thePlatformLibName)
415   throw (SALOME::SALOME_Exception)
416 {
417   std::string aPlatformLibName;
418   /* It's Need to translate lib name for WIN32 or X platform */
419   if ( theLibName && theLibName[0] != '\0'  )
420   {
421     int libNameLen = strlen(theLibName);
422     //check for old format "libXXXXXXX.so"
423     if (libNameLen > 7 &&
424         !strncmp( theLibName, "lib", 3 ) &&
425         !strcmp( theLibName+libNameLen-3, ".so" ))
426     {
427       //the old format
428 #if defined(WIN32)
429       aPlatformLibName = std::string( theLibName+3, libNameLen-6 ) + ".dll";
430 #elif defined(__APPLE__)
431       aPlatformLibName = std::string( theLibName, libNameLen-3 ) + ".dylib";
432 #else
433       aPlatformLibName = theLibName;
434 #endif
435     }
436     else
437     {
438       //try to use new format
439 #if defined(WIN32)
440       aPlatformLibName = theLibName;
441       aPlatformLibName += ".dll";
442 #elif defined(__APPLE__)
443       aPlatformLibName = std::string( "lib" ) + std::string( theLibName ) + ".dylib";
444 #else
445       aPlatformLibName = std::string( "lib" ) + std::string( theLibName ) + ".so";
446 #endif
447     }
448   }
449   thePlatformLibName = aPlatformLibName;
450
451   Unexpect aCatch(SALOME_SalomeException);
452   if(MYDEBUG) MESSAGE( "Create Hypothesis <" << theHypName << "> from " << aPlatformLibName);
453
454   typedef GenericHypothesisCreator_i* (*GetHypothesisCreator)(const char* );
455   GenericHypothesisCreator_i* aCreator;
456   try
457   {
458     // check, if creator for this hypothesis type already exists
459     if (myHypCreatorMap.find(string(theHypName)) == myHypCreatorMap.end())
460     {
461       // load plugin library
462       if(MYDEBUG) MESSAGE("Loading server meshers plugin library ...");
463 #ifdef WIN32
464 #ifdef UNICODE
465       const wchar_t* path = Kernel_Utils::decode_s(aPlatformLibName);
466 #else
467       const char* path = aPlatformLibName.c_str();
468 #endif
469 #else
470       const char* path = aPlatformLibName.c_str();
471 #endif
472       LibHandle libHandle = LoadLib( path );
473 #if defined(WIN32) && defined(UNICODE)
474       delete path;
475 #endif
476       if (!libHandle)
477       {
478         // report any error, if occurred
479 #ifndef WIN32
480         const char* anError = dlerror();
481         throw(SALOME_Exception( anError ));
482 #else
483         throw(SALOME_Exception ( SMESH_Comment("Can't load meshers plugin library " )
484                                  << aPlatformLibName));
485 #endif
486       }
487
488       // get method, returning hypothesis creator
489       if(MYDEBUG) MESSAGE("Find GetHypothesisCreator() method ...");
490       GetHypothesisCreator procHandle =
491         (GetHypothesisCreator)GetProc( libHandle, "GetHypothesisCreator" );
492       if (!procHandle)
493       {
494         throw(SALOME_Exception(SMESH_Comment("bad hypothesis plugin library")
495                                << aPlatformLibName ));
496         UnLoadLib(libHandle);
497       }
498
499       // get hypothesis creator
500       if(MYDEBUG) MESSAGE("Get Hypothesis Creator for " << theHypName);
501       aCreator = procHandle(theHypName);
502       if (!aCreator)
503       {
504         throw(SALOME_Exception( SMESH_Comment( theHypName ) << " is missing from "
505                                 << aPlatformLibName));
506       }
507       // map hypothesis creator to a hypothesis name
508       myHypCreatorMap[string(theHypName)] = aCreator;
509       return aCreator;
510     }
511     else
512     {
513       return myHypCreatorMap[string(theHypName)];
514     }
515   }
516   catch (SALOME_Exception& S_ex)
517   {
518     THROW_SALOME_CORBA_EXCEPTION(S_ex.what(), SALOME::BAD_PARAM);
519   }
520   return aCreator;
521 }
522
523 //=============================================================================
524 /*!
525  *  SMESH_Gen_i::createHypothesis
526  *
527  *  Create hypothesis of given type
528  */
529 //=============================================================================
530 SMESH::SMESH_Hypothesis_ptr SMESH_Gen_i::createHypothesis(const char* theHypName,
531                                                           const char* theLibName)
532 {
533   SMESH_Hypothesis_i* myHypothesis_i = 0;
534   SMESH::SMESH_Hypothesis_var hypothesis_i;
535   std::string aPlatformLibName;
536   GenericHypothesisCreator_i* aCreator =
537     getHypothesisCreator(theHypName, theLibName, aPlatformLibName);
538
539   // create a new hypothesis object, store its ref. in studyContext
540   myHypothesis_i = aCreator->Create(myPoa, &myGen);
541   if (myHypothesis_i)
542   {
543     myHypothesis_i->SetLibName( aPlatformLibName.c_str() ); // for persistency assurance
544     CORBA::String_var hypName = myHypothesis_i->GetName();
545     myHypCreatorMap[ hypName.in() ] = aCreator;
546
547     // activate the CORBA servant of hypothesis
548     hypothesis_i = myHypothesis_i->_this();
549     int nextId = RegisterObject( hypothesis_i );
550     if(MYDEBUG) { MESSAGE( "Add hypo to map with id = "<< nextId ); }
551     else        { nextId = 0; } // avoid "unused variable" warning in release mode
552   }
553   return hypothesis_i._retn();
554 }
555
556 //=============================================================================
557 /*!
558  *  SMESH_Gen_i::createMesh
559  *
560  *  Create empty mesh on shape
561  */
562 //=============================================================================
563 SMESH::SMESH_Mesh_ptr SMESH_Gen_i::createMesh()
564   throw ( SALOME::SALOME_Exception )
565 {
566   Unexpect aCatch(SALOME_SalomeException);
567   if(MYDEBUG) MESSAGE( "SMESH_Gen_i::createMesh" );
568
569   // Get or create the GEOM_Client instance
570   try {
571     // create a new mesh object servant, store it in a map in study context
572     SMESH_Mesh_i* meshServant = new SMESH_Mesh_i( GetPOA(), this );
573     // create a new mesh object
574     if(MYDEBUG) MESSAGE("myIsEmbeddedMode " << myIsEmbeddedMode);
575     meshServant->SetImpl( myGen.CreateMesh( myIsEmbeddedMode ));
576
577     // activate the CORBA servant of Mesh
578     SMESH::SMESH_Mesh_var mesh = SMESH::SMESH_Mesh::_narrow( meshServant->_this() );
579     int nextId = RegisterObject( mesh );
580     if(MYDEBUG) { MESSAGE( "Add mesh to map with id = "<< nextId); }
581     else        { nextId = 0; } // avoid "unused variable" warning in release mode
582     return mesh._retn();
583   }
584   catch (SALOME_Exception& S_ex) {
585     THROW_SALOME_CORBA_EXCEPTION( S_ex.what(), SALOME::BAD_PARAM );
586   }
587   return SMESH::SMESH_Mesh::_nil();
588 }
589
590 //=============================================================================
591 /*!
592  *  SMESH_Gen_i::GetShapeReader
593  *
594  *  Get shape reader
595  */
596 //=============================================================================
597 GEOM_Client* SMESH_Gen_i::GetShapeReader()
598 {
599   // create shape reader if necessary
600   if ( !myShapeReader )
601     myShapeReader = new GEOM_Client(GetContainerRef());
602   ASSERT( myShapeReader );
603   return myShapeReader;
604 }
605
606 //=============================================================================
607 /*!
608  *  SMESH_Gen_i::SetGeomEngine
609  *
610  *  Set GEOM::GEOM_Gen reference
611  */
612 //=============================================================================
613 //GEOM::GEOM_Gen_ptr SMESH_Gen_i::SetGeomEngine( const char* containerLoc )
614 void SMESH_Gen_i::SetGeomEngine( GEOM::GEOM_Gen_ptr geomcompo )
615 {
616   //Engines::Component_ptr temp=GetLCC()->FindOrLoad_Component(containerLoc,"GEOM");
617   //myGeomGen=GEOM::GEOM_Gen::_narrow(temp);
618   myGeomGen=GEOM::GEOM_Gen::_duplicate(geomcompo);
619   //return myGeomGen;
620 }
621
622 //=============================================================================
623 /*!
624  *  SMESH_Gen_i::SetEmbeddedMode
625  *
626  *  Set current mode
627  */
628 //=============================================================================
629
630 void SMESH_Gen_i::SetEmbeddedMode( CORBA::Boolean theMode )
631 {
632   myIsEmbeddedMode = theMode;
633
634   if ( !myIsEmbeddedMode ) {
635     //PAL10867: disable signals catching with "noexcepthandler" option
636     char* envNoCatchSignals = getenv("NOT_INTERCEPT_SIGNALS");
637     if (!envNoCatchSignals || !atoi(envNoCatchSignals))
638     {
639       bool raiseFPE;
640 #ifdef _DEBUG_
641       raiseFPE = true;
642       char* envDisableFPE = getenv("DISABLE_FPE");
643       if (envDisableFPE && atoi(envDisableFPE))
644         raiseFPE = false;
645 #else
646       raiseFPE = false;
647 #endif
648       OSD::SetSignal( raiseFPE );
649     }
650     // else OSD::SetSignal() is called in GUI
651   }
652 }
653
654 //=============================================================================
655 /*!
656  *  SMESH_Gen_i::IsEmbeddedMode
657  *
658  *  Get current mode
659  */
660 //=============================================================================
661
662 CORBA::Boolean SMESH_Gen_i::IsEmbeddedMode()
663 {
664   return myIsEmbeddedMode;
665 }
666
667 //=============================================================================
668 /*!
669  *  SMESH_Gen_i::SetEnablePublish
670  *
671  *  Set enable publishing in the study
672  */
673 //=============================================================================
674 void SMESH_Gen_i::SetEnablePublish( CORBA::Boolean theIsEnablePublish )
675 {
676   myIsEnablePublish = theIsEnablePublish;
677 }
678
679 //=============================================================================
680 /*!
681  *  SMESH_Gen_i::IsEnablePublish
682  *
683  *  Check enable publishing
684  */
685 //=============================================================================
686
687 CORBA::Boolean SMESH_Gen_i::IsEnablePublish()
688 {
689   return myIsEnablePublish;
690 }
691
692 //=============================================================================
693 /*!
694  *  SMESH_Gen_i::UpdateStudy
695  *
696  *  Update study (needed at switching GEOM->SMESH)
697  */
698 //=============================================================================
699
700 void SMESH_Gen_i::UpdateStudy()
701 {
702   if ( !myStudyContext )
703     myStudyContext = new StudyContext;
704
705   SALOMEDS::Study_var aStudy = getStudyServant();
706   if ( !CORBA::is_nil( aStudy ) )
707   {
708     SALOMEDS::StudyBuilder_var aStudyBuilder = aStudy->NewBuilder();
709
710     SALOMEDS::SComponent_wrap GEOM_var = aStudy->FindComponent( "GEOM" );
711     if( !GEOM_var->_is_nil() )
712       aStudyBuilder->LoadWith( GEOM_var, GetGeomEngine( /*isShaper=*/false ) );
713
714     GEOM_var = aStudy->FindComponent( "SHAPERSTUDY" );
715     if( !GEOM_var->_is_nil() )
716       aStudyBuilder->LoadWith( GEOM_var, GetGeomEngine( /*isShaper=*/true ) );
717
718     // NPAL16168, issue 0020210
719     // Let meshes update their data depending on GEOM groups that could change
720     CORBA::String_var compDataType = ComponentDataType();
721     SALOMEDS::SComponent_wrap me = aStudy->FindComponent( compDataType.in() );
722     if ( !me->_is_nil() ) {
723       SALOMEDS::ChildIterator_wrap anIter = aStudy->NewChildIterator( me );
724       for ( ; anIter->More(); anIter->Next() ) {
725         SALOMEDS::SObject_wrap so = anIter->Value();
726         CORBA::Object_var     ior = SObjectToObject( so );
727         if ( SMESH_Mesh_i*   mesh = SMESH::DownCast<SMESH_Mesh_i*>( ior ))
728           mesh->CheckGeomModif();
729       }
730     }
731   }
732 }
733
734 //================================================================================
735 /*!
736  * \brief Return true if mesh has ICON_SMESH_TREE_GEOM_MODIF icon
737  */
738 //================================================================================
739
740 bool SMESH_Gen_i::isGeomModifIcon( SMESH::SMESH_Mesh_ptr mesh )
741 {
742   SALOMEDS::SObject_wrap so = ObjectToSObject( mesh );
743   SALOMEDS::GenericAttribute_wrap attr;
744   if ( ! so->_is_nil() && so->FindAttribute( attr.inout(), "AttributePixMap" ))
745   {
746     SALOMEDS::AttributePixMap_wrap pm = attr;
747     CORBA::String_var             ico = pm->GetPixMap();
748     return ( strcmp( ico.in(), "ICON_SMESH_TREE_GEOM_MODIF" ) == 0 );
749   }
750   return false;
751 }
752
753 //=================================================================================
754 // function : hasObjectInfo()
755 // purpose  : shows if module provides information for its objects
756 //=================================================================================
757
758 bool SMESH_Gen_i::hasObjectInfo()
759 {
760   return true;
761 }
762
763 //=================================================================================
764 // function : getObjectInfo()
765 // purpose  : returns an information for a given object by its entry
766 //=================================================================================
767
768 char* SMESH_Gen_i::getObjectInfo( const char* entry )
769 {
770   // for a mesh with icon == ICON_SMESH_TREE_GEOM_MODIF show a warning;
771   // for the rest, "module 'SMESH', ID=0:1:2:*"
772
773   SMESH_Comment txt;
774
775   SALOMEDS::SObject_wrap  so = getStudyServant()->FindObjectID( entry );
776   CORBA::Object_var      obj = SObjectToObject( so );
777   SMESH::SMESH_Mesh_var mesh = SMESH::SMESH_Mesh::_narrow( obj );
778   if ( isGeomModifIcon( mesh ))
779   {
780     txt << "The geometry was changed and the mesh needs to be recomputed";
781   }
782
783   if ( txt.empty() )
784   {
785     CORBA::String_var compType = ComponentDataType();
786     txt << "module '" << compType << "', ID=" << entry;
787   }
788   return CORBA::string_dup( txt );
789 }
790
791 //=============================================================================
792 /*!
793  *  SMESH_Gen_i::GetStudyContext
794  *
795  *  Get study context
796  */
797 //=============================================================================
798 StudyContext* SMESH_Gen_i::GetStudyContext()
799 {
800   return myStudyContext;
801 }
802
803 //=============================================================================
804 /*!
805  *  SMESH_Gen_i::CreateHypothesis
806  *
807  *  Create hypothesis/algorithm of given type and publish it in the study
808  */
809 //=============================================================================
810
811 SMESH::SMESH_Hypothesis_ptr SMESH_Gen_i::CreateHypothesis( const char* theHypName,
812                                                            const char* theLibName )
813   throw ( SALOME::SALOME_Exception )
814 {
815   Unexpect aCatch(SALOME_SalomeException);
816   // Create hypothesis/algorithm
817   SMESH::SMESH_Hypothesis_var hyp = this->createHypothesis( theHypName, theLibName );
818
819   // Publish hypothesis/algorithm in the study
820   if ( CanPublishInStudy( hyp ) ) {
821     SALOMEDS::SObject_wrap aSO = PublishHypothesis( hyp );
822     if ( !aSO->_is_nil() ) {
823       // Update Python script
824       TPythonDump() << aSO << " = " << this << ".CreateHypothesis('"
825                     << theHypName << "', '" << theLibName << "')";
826     }
827   }
828
829   return hyp._retn();
830 }
831
832 //================================================================================
833 /*!
834  * \brief Return a hypothesis initialized by given average length.
835  *  \param theHypType - hypothesis type name
836  *  \param theLibName - plugin library name
837  *  \param theAverageLength - average length
838  *  \param theQuadDominated - is quad-dominated flag
839  *  \retval SMESH::SMESH_Hypothesis_ptr - the new hypothesis
840  */
841 //================================================================================
842
843 SMESH::SMESH_Hypothesis_ptr
844 SMESH_Gen_i::CreateHypothesisByAverageLength( const char*    theHypType,
845                                               const char*    theLibName,
846                                               CORBA::Double  theAverageLength,
847                                               CORBA::Boolean theQuadDominated)
848   throw ( SALOME::SALOME_Exception )
849 {
850   SMESH::HypInitParams initParams = { ::SMESH_Hypothesis::BY_AVERAGE_LENGTH,
851                                       theAverageLength, theQuadDominated };
852
853   SMESH::SMESH_Hypothesis_var hyp =
854     GetHypothesisParameterValues( theHypType, theLibName,
855                                   SMESH::SMESH_Mesh::_nil(),
856                                   GEOM::GEOM_Object::_nil(),
857                                   initParams );
858   SALOMEDS::SObject_wrap so = PublishHypothesis( hyp );
859
860   TPythonDump() << hyp << " = " << this << ".CreateHypothesisByAverageLength( '"
861                 << theHypType << "', '"
862                 << theLibName << "', "
863                 << theAverageLength << ", "
864                 << theQuadDominated << " )";
865
866   return hyp._retn();
867 }
868
869 //================================================================================
870 /*!
871  * \brief Return a hypothesis holding parameter values corresponding either to the mesh
872  * existing on the given geometry or to size of the geometry.
873  *  \param theHypType - hypothesis type name
874  *  \param theLibName - plugin library name
875  *  \param theMesh - The mesh of interest
876  *  \param theGeom - The shape to get parameter values from
877  *  \retval SMESH::SMESH_Hypothesis_ptr - The returned hypothesis may be the one existing
878  *     in a study and used to compute the mesh, or a temporary one created just to pass
879  *     parameter values
880  */
881 //================================================================================
882
883 SMESH::SMESH_Hypothesis_ptr
884 SMESH_Gen_i::GetHypothesisParameterValues( const char*                 theHypType,
885                                            const char*                 theLibName,
886                                            SMESH::SMESH_Mesh_ptr       theMesh,
887                                            GEOM::GEOM_Object_ptr       theGeom,
888                                            const SMESH::HypInitParams& theParams)
889   throw ( SALOME::SALOME_Exception )
890 {
891   Unexpect aCatch(SALOME_SalomeException);
892
893   const bool byMesh = ( theParams.way == ::SMESH_Hypothesis::BY_MESH );
894   if ( byMesh && CORBA::is_nil( theMesh ) )
895     return SMESH::SMESH_Hypothesis::_nil();
896   if ( byMesh && CORBA::is_nil( theGeom ) )
897     return SMESH::SMESH_Hypothesis::_nil();
898
899   // -----------------------------------------------
900   // find hypothesis used to mesh theGeom
901   // -----------------------------------------------
902
903   // get mesh and shape
904   SMESH_Mesh_i* meshServant = SMESH::DownCast<SMESH_Mesh_i*>( theMesh );
905   TopoDS_Shape shape = GeomObjectToShape( theGeom );
906   if ( byMesh && ( !meshServant || meshServant->NbNodes()==0 || shape.IsNull() ))
907     return SMESH::SMESH_Hypothesis::_nil();
908   ::SMESH_Mesh* mesh = meshServant ? &meshServant->GetImpl() : (::SMESH_Mesh*)0;
909
910   // create a temporary hypothesis to know its dimension
911   SMESH::SMESH_Hypothesis_var tmpHyp = this->createHypothesis( theHypType, theLibName );
912   SMESH_Hypothesis_i* hypServant = SMESH::DownCast<SMESH_Hypothesis_i*>( tmpHyp );
913   if ( !hypServant )
914     return SMESH::SMESH_Hypothesis::_nil();
915   ::SMESH_Hypothesis* hyp = hypServant->GetImpl();
916
917   if ( byMesh ) {
918     // look for a hypothesis of theHypType used to mesh the shape
919     if ( myGen.GetShapeDim( shape ) == hyp->GetDim() )
920     {
921       // check local shape
922       SMESH::ListOfHypothesis_var aHypList = theMesh->GetHypothesisList( theGeom );
923       int nbLocalHyps = aHypList->length();
924       for ( int i = 0; i < nbLocalHyps; i++ ) {
925         CORBA::String_var hypName = aHypList[i]->GetName();
926         if ( strcmp( theHypType, hypName.in() ) == 0 ) // FOUND local!
927           return SMESH::SMESH_Hypothesis::_duplicate( aHypList[i] );
928       }
929       // check super shapes
930       TopTools_ListIteratorOfListOfShape itShape( mesh->GetAncestors( shape ));
931       while ( nbLocalHyps == 0 && itShape.More() ) {
932         GEOM::GEOM_Object_ptr geomObj = ShapeToGeomObject( itShape.Value() );
933         if ( ! CORBA::is_nil( geomObj )) {
934           SMESH::ListOfHypothesis_var aHypList = theMesh->GetHypothesisList( geomObj );
935           nbLocalHyps = aHypList->length();
936           for ( int i = 0; i < nbLocalHyps; i++ )
937             if ( strcmp( theHypType, aHypList[i]->GetName() ) == 0 ) // FOUND global!
938               return SMESH::SMESH_Hypothesis::_duplicate( aHypList[i] );
939         }
940         itShape.Next();
941       }
942     }
943
944     // let the temporary hypothesis find out somehow parameter values by mesh
945     if ( hyp->SetParametersByMesh( mesh, shape ))
946       return SMESH::SMESH_Hypothesis::_duplicate( tmpHyp );
947   }
948   else
949   {
950     ::SMESH_Hypothesis::TDefaults dflts;
951     dflts._way           = ( ::SMESH_Hypothesis::InitWay) theParams.way;
952     dflts._nbSegments    = myGen.GetDefaultNbSegments();
953     dflts._elemLength    = theParams.averageLength;
954     dflts._quadDominated = theParams.quadDominated;
955     if ( theParams.way == ::SMESH_Hypothesis::BY_GEOM )
956     {
957       if ( mesh )
958         dflts._diagonal  = mesh->GetShapeDiagonalSize();
959       else
960         dflts._diagonal  = ::SMESH_Mesh::GetShapeDiagonalSize( shape );
961       dflts._elemLength  = dflts._diagonal / myGen.GetBoundaryBoxSegmentation();
962       dflts._shape       = &shape;
963     }
964
965     // let the hypothesis initialize it's values
966     if ( hyp->SetParametersByDefaults( dflts, mesh ))
967       return SMESH::SMESH_Hypothesis::_duplicate( tmpHyp );
968   }
969
970   return SMESH::SMESH_Hypothesis::_nil();
971 }
972
973 //=============================================================================
974 /*!
975  * Returns \c True if a hypothesis is assigned to a sole sub-mesh in a current Study
976  *  \param [in] theHyp - the hypothesis of interest
977  *  \param [out] theMesh - the sole mesh using \a theHyp
978  *  \param [out] theShape - the sole geometry \a theHyp is assigned to
979  *  \return boolean - \c True if \a theMesh and \a theShape are sole using \a theHyp
980  *
981  * If two meshes on same shape have theHyp assigned to the same sub-shape, they are
982  * considered as SAME sub-mesh => result is \c true.
983  * This method ids used to initialize SMESHGUI_GenericHypothesisCreator with
984  * a shape to which an hyp being edited is assigned.
985  */
986 //=============================================================================
987
988 CORBA::Boolean SMESH_Gen_i::GetSoleSubMeshUsingHyp( SMESH::SMESH_Hypothesis_ptr theHyp,
989                                                     SMESH::SMESH_Mesh_out       theMesh,
990                                                     GEOM::GEOM_Object_out       theShape)
991 {
992   if ( CORBA::is_nil( theHyp ))
993     return false;
994
995   // get Mesh component SO
996   CORBA::String_var compDataType = ComponentDataType();
997   SALOMEDS::SComponent_wrap comp = getStudyServant()->FindComponent( compDataType.in() );
998   if ( CORBA::is_nil( comp ))
999     return false;
1000
1001   // look for child SO of meshes
1002   SMESH::SMESH_Mesh_var foundMesh;
1003   TopoDS_Shape          foundShape;
1004   bool                  isSole = true;
1005   SALOMEDS::ChildIterator_wrap meshIter = getStudyServant()->NewChildIterator( comp );
1006   for ( ; meshIter->More() && isSole; meshIter->Next() )
1007   {
1008     SALOMEDS::SObject_wrap curSO = meshIter->Value();
1009     CORBA::Object_var        obj = SObjectToObject( curSO );
1010     SMESH_Mesh_i*         mesh_i = SMESH::DownCast< SMESH_Mesh_i* >( obj );
1011     if ( ! mesh_i )
1012       continue;
1013
1014     // look for a sole shape where theHyp is assigned
1015     bool isHypFound = false;
1016     const ShapeToHypothesis & s2hyps = mesh_i->GetImpl().GetMeshDS()->GetHypotheses();
1017     ShapeToHypothesis::Iterator s2hypsIt( s2hyps );
1018     for ( ; s2hypsIt.More() && isSole; s2hypsIt.Next() )
1019     {
1020       const THypList& hyps = s2hypsIt.Value();
1021       THypList::const_iterator h = hyps.begin();
1022       for ( ; h != hyps.end(); ++h )
1023         if ( (*h)->GetID() == theHyp->GetId() )
1024           break;
1025       if ( h != hyps.end()) // theHyp found
1026       {
1027         isHypFound = true;
1028         if ( ! foundShape.IsNull() &&
1029              ! foundShape.IsSame( s2hypsIt.Key() )) // not a sole sub-shape
1030         {
1031           foundShape.Nullify();
1032           isSole = false;
1033           break;
1034         }
1035         foundShape = s2hypsIt.Key();
1036       }
1037     } // loop on assigned hyps
1038
1039     if ( isHypFound && !foundShape.IsNull() ) // a mesh using theHyp is found
1040     {
1041       if ( !foundMesh->_is_nil() ) // not a sole mesh
1042       {
1043         if ( !foundMesh->HasShapeToMesh() ||
1044              !mesh_i   ->HasShapeToMesh() )
1045         {
1046           isSole = ( foundMesh->HasShapeToMesh() == mesh_i->HasShapeToMesh() );
1047         }
1048         else
1049         {
1050           GEOM::GEOM_Object_var s1 = mesh_i   ->GetShapeToMesh();
1051           GEOM::GEOM_Object_var s2 = foundMesh->GetShapeToMesh();
1052           isSole = s1->IsSame( s2 );
1053         }
1054       }
1055       foundMesh = SMESH::SMESH_Mesh::_narrow( obj );
1056     }
1057
1058   } // loop on meshes
1059
1060   if ( isSole &&
1061        ! foundMesh->_is_nil() &&
1062        ! foundShape.IsNull() )
1063   {
1064     theMesh  = foundMesh._retn();
1065     theShape = ShapeToGeomObject( foundShape );
1066     return ( !theMesh->_is_nil() && !theShape->_is_nil() );
1067   }
1068   return false;
1069 }
1070
1071 //=============================================================================
1072 /*!
1073  * Sets number of segments per diagonal of boundary box of geometry by which
1074  * default segment length of appropriate 1D hypotheses is defined
1075  */
1076 //=============================================================================
1077
1078 void SMESH_Gen_i::SetBoundaryBoxSegmentation( CORBA::Long theNbSegments )
1079   throw ( SALOME::SALOME_Exception )
1080 {
1081   if ( theNbSegments > 0 )
1082     myGen.SetBoundaryBoxSegmentation( int( theNbSegments ));
1083   else
1084     THROW_SALOME_CORBA_EXCEPTION( "non-positive number of segments", SALOME::BAD_PARAM );
1085 }
1086 //=============================================================================
1087   /*!
1088    * \brief Sets default number of segments per edge
1089    */
1090 //=============================================================================
1091 void SMESH_Gen_i::SetDefaultNbSegments(CORBA::Long theNbSegments)
1092   throw ( SALOME::SALOME_Exception )
1093 {
1094   if ( theNbSegments > 0 )
1095     myGen.SetDefaultNbSegments( int(theNbSegments) );
1096   else
1097     THROW_SALOME_CORBA_EXCEPTION( "non-positive number of segments", SALOME::BAD_PARAM );
1098 }
1099
1100 //=============================================================================
1101 /*!
1102   Set an option value
1103 */
1104 //=============================================================================
1105
1106 void SMESH_Gen_i::SetOption(const char* name, const char* value)
1107 {
1108   if ( name && value && strlen( value ) > 0 )
1109   {
1110     string msgToGUI;
1111     if ( strcmp(name, "historical_python_dump") == 0 )
1112     {
1113       myIsHistoricalPythonDump = ( value[0] == '1' || toupper(value[0]) == 'T' ); // 1 || true
1114       msgToGUI = "preferences/SMESH/historical_python_dump/";
1115       msgToGUI += myIsHistoricalPythonDump ? "true" : "false";
1116     }
1117     else if ( strcmp(name, "forget_mesh_on_hyp_modif") == 0 )
1118     {
1119       myToForgetMeshDataOnHypModif = ( value[0] == '1' || toupper(value[0]) == 'T' ); // 1 || true
1120       msgToGUI = "preferences/SMESH/forget_mesh_on_hyp_modif/";
1121       msgToGUI += myToForgetMeshDataOnHypModif ? "true" : "false";
1122     }
1123     else if ( strcmp(name, "default_grp_color") == 0 )
1124     {
1125       vector<int> color;
1126       string str = value;
1127       // color must be presented as a string of following form:
1128       if ( str.at(0) == '#' && str.length() == 7 ) { // hexadecimal color ("#ffaa00", for example)
1129         str = str.substr(1);
1130         for ( size_t i = 0; i < str.length()/2; i++ )
1131           if ( str.at(i*2) >= '0' && str.at(i*2) <= 'f' && str.at(i*2+1) >= '0' && str.at(i*2+1) <= 'f' )
1132             color.push_back( strtol( str.substr( i*2, 2 ).c_str(), NULL, 16 ) );
1133       }
1134       else if ( value ) { // rgb color ("255,170,0", for example)
1135         string tempValue( value );
1136         char* colorValue = strtok( &tempValue[0], "," );
1137         while ( colorValue != NULL ) {
1138           int c_value = atoi( colorValue );
1139           if ( c_value >= 0 && c_value <= 255 )
1140             color.push_back( c_value );
1141           colorValue = strtok( NULL, "," );
1142         }
1143       }
1144       if ( color.size() == 3 ) { // color must have three valid component
1145         SMESHDS_GroupBase::SetDefaultColor( Quantity_Color( color[0]/255., color[1]/255., color[2]/255., Quantity_TOC_RGB ) );
1146         myDefaultGroupColor = value;
1147         msgToGUI = "preferences/SMESH/default_grp_color/";
1148         msgToGUI += value;
1149       }
1150     }
1151
1152     // update preferences in case if SetOption() is invoked from python console
1153     if ( !msgToGUI.empty() )
1154     {
1155       CORBA::Object_var obj = SMESH_Gen_i::GetNS()->Resolve( "/Kernel/Session" );
1156       SALOME::Session_var session = SALOME::Session::_narrow( obj );
1157       if ( !CORBA::is_nil( session ) )
1158         session->emitMessageOneWay(msgToGUI.c_str());
1159     }
1160   }
1161 }
1162
1163 //=============================================================================
1164 /*!
1165   Return an option value
1166 */
1167 //=============================================================================
1168
1169 char* SMESH_Gen_i::GetOption(const char* name)
1170 {
1171   if ( name )
1172   {
1173     if ( strcmp(name, "historical_python_dump") == 0 )
1174     {
1175       return CORBA::string_dup( myIsHistoricalPythonDump ? "true" : "false" );
1176     }
1177     if ( strcmp(name, "forget_mesh_on_hyp_modif") == 0 )
1178     {
1179       return CORBA::string_dup( myToForgetMeshDataOnHypModif ? "true" : "false" );
1180     }
1181     if ( strcmp(name, "default_grp_color") == 0 )
1182     {
1183       return CORBA::string_dup( myDefaultGroupColor.c_str() );
1184     }
1185   }
1186   return CORBA::string_dup( "" );
1187 }
1188
1189 //=============================================================================
1190 /*!
1191  *  SMESH_Gen_i::CreateMesh
1192  *
1193  *  Create empty mesh on a shape and publish it in the study
1194  */
1195 //=============================================================================
1196
1197 SMESH::SMESH_Mesh_ptr SMESH_Gen_i::CreateMesh( GEOM::GEOM_Object_ptr theShapeObject )
1198      throw ( SALOME::SALOME_Exception )
1199 {
1200   Unexpect aCatch(SALOME_SalomeException);
1201   if(MYDEBUG) MESSAGE( "SMESH_Gen_i::CreateMesh" );
1202   // create mesh
1203   SMESH::SMESH_Mesh_var mesh = this->createMesh();
1204   // set shape
1205   SMESH_Mesh_i* meshServant = SMESH::DownCast<SMESH_Mesh_i*>( mesh );
1206   ASSERT( meshServant );
1207   meshServant->SetShape( theShapeObject );
1208
1209   // publish mesh in the study
1210   if ( CanPublishInStudy( mesh ) ) {
1211     SALOMEDS::StudyBuilder_var aStudyBuilder = getStudyServant()->NewBuilder();
1212     aStudyBuilder->NewCommand();  // There is a transaction
1213     SALOMEDS::SObject_wrap aSO = PublishMesh( mesh.in() );
1214     aStudyBuilder->CommitCommand();
1215     if ( !aSO->_is_nil() ) {
1216       // Update Python script
1217       TPythonDump() << aSO << " = " << this << ".CreateMesh(" << theShapeObject << ")";
1218     }
1219   }
1220
1221   return mesh._retn();
1222 }
1223
1224 //=============================================================================
1225 /*!
1226  *  SMESH_Gen_i::CreateEmptyMesh
1227  *
1228  *  Create empty mesh
1229  */
1230 //=============================================================================
1231
1232 SMESH::SMESH_Mesh_ptr SMESH_Gen_i::CreateEmptyMesh()
1233      throw ( SALOME::SALOME_Exception )
1234 {
1235   Unexpect aCatch(SALOME_SalomeException);
1236   if(MYDEBUG) MESSAGE( "SMESH_Gen_i::CreateMesh" );
1237   // create mesh
1238   SMESH::SMESH_Mesh_var mesh = this->createMesh();
1239
1240   // publish mesh in the study
1241   if ( CanPublishInStudy( mesh ) ) {
1242     SALOMEDS::StudyBuilder_var aStudyBuilder = getStudyServant()->NewBuilder();
1243     aStudyBuilder->NewCommand();  // There is a transaction
1244     SALOMEDS::SObject_wrap aSO = PublishMesh( mesh.in() );
1245     aStudyBuilder->CommitCommand();
1246     if ( !aSO->_is_nil() ) {
1247       // Update Python script
1248       TPythonDump() << aSO << " = " << this << ".CreateEmptyMesh()";
1249     }
1250   }
1251
1252   return mesh._retn();
1253 }
1254
1255 namespace
1256 {
1257   //================================================================================
1258   /*!
1259    * \brief Throws an exception in case if the file can't be read
1260    */
1261   //================================================================================
1262
1263   void checkFileReadable( const char* theFileName ) throw ( SALOME::SALOME_Exception )
1264   {
1265     SMESH_File f ( theFileName );
1266     if ( !f )
1267     {
1268       if ( !f.error().empty() )
1269         THROW_SALOME_CORBA_EXCEPTION( f.error().c_str(), SALOME::BAD_PARAM);
1270
1271       THROW_SALOME_CORBA_EXCEPTION
1272         (( SMESH_Comment("Can't open for reading the file ") << theFileName ).c_str(),
1273          SALOME::BAD_PARAM );
1274     }
1275   }
1276 }
1277
1278 //=============================================================================
1279 /*!
1280  *  SMESH_Gen_i::CreateMeshFromUNV
1281  *
1282  *  Create mesh and import data from UNV file
1283  */
1284 //=============================================================================
1285
1286 SMESH::SMESH_Mesh_ptr SMESH_Gen_i::CreateMeshesFromUNV( const char* theFileName )
1287   throw ( SALOME::SALOME_Exception )
1288 {
1289   Unexpect aCatch(SALOME_SalomeException);
1290
1291   checkFileReadable( theFileName );
1292
1293   SMESH::SMESH_Mesh_var aMesh = createMesh();
1294   string aFileName;
1295   // publish mesh in the study
1296   if ( CanPublishInStudy( aMesh ) ) {
1297     SALOMEDS::StudyBuilder_var aStudyBuilder = getStudyServant()->NewBuilder();
1298     aStudyBuilder->NewCommand();  // There is a transaction
1299     SALOMEDS::SObject_wrap aSO = PublishMesh( aMesh.in(), aFileName.c_str() );
1300     aStudyBuilder->CommitCommand();
1301     if ( !aSO->_is_nil() ) {
1302       // Update Python script
1303       TPythonDump() << aSO << " = " << this << ".CreateMeshesFromUNV(r'" << theFileName << "')";
1304     }
1305   }
1306
1307   SMESH_Mesh_i* aServant = dynamic_cast<SMESH_Mesh_i*>( GetServant( aMesh ).in() );
1308   ASSERT( aServant );
1309   aServant->ImportUNVFile( theFileName );
1310
1311   // Dump creation of groups
1312   SMESH::ListOfGroups_var groups = aServant->GetGroups();
1313
1314   aServant->GetImpl().GetMeshDS()->Modified();
1315   return aMesh._retn();
1316 }
1317
1318 //=============================================================================
1319 /*!
1320  *  SMESH_Gen_i::CreateMeshFromMED
1321  *
1322  *  Create mesh and import data from MED file
1323  */
1324 //=============================================================================
1325
1326 SMESH::mesh_array* SMESH_Gen_i::CreateMeshesFromMEDorSAUV( const char* theFileName,
1327                                                            SMESH::DriverMED_ReadStatus& theStatus,
1328                                                            const char* theCommandNameForPython,
1329                                                            const char* theFileNameForPython)
1330 {
1331 #ifdef WIN32
1332   char bname[ _MAX_FNAME ];
1333   _splitpath( theFileNameForPython, NULL, NULL, bname, NULL );
1334   string aFileName = bname;
1335 #else
1336   string aFileName = basename( const_cast<char *>(theFileNameForPython) );
1337 #endif
1338   // Retrieve mesh names from the file
1339   DriverMED_R_SMESHDS_Mesh myReader;
1340   myReader.SetFile( theFileName );
1341   myReader.SetMeshId( -1 );
1342   Driver_Mesh::Status aStatus;
1343   list<string> aNames = myReader.GetMeshNames(aStatus);
1344   SMESH::mesh_array_var aResult = new SMESH::mesh_array();
1345   theStatus = (SMESH::DriverMED_ReadStatus)aStatus;
1346
1347   { // open a new scope to make aPythonDump die before PythonDump in SMESH_Mesh::GetGroups()
1348
1349   // Python Dump
1350   TPythonDump aPythonDump;
1351   aPythonDump << "([";
1352
1353   if (theStatus == SMESH::DRS_OK) {
1354     SALOMEDS::StudyBuilder_var aStudyBuilder;
1355     aStudyBuilder = getStudyServant()->NewBuilder();
1356     aStudyBuilder->NewCommand();  // There is a transaction
1357
1358     aResult->length( aNames.size() );
1359     int i = 0;
1360
1361     // Iterate through all meshes and create mesh objects
1362     for ( list<string>::iterator it = aNames.begin(); it != aNames.end(); it++ )
1363     {
1364       // Python Dump
1365       if (i > 0) aPythonDump << ", ";
1366
1367       // create mesh
1368       SMESH::SMESH_Mesh_var mesh = createMesh();
1369
1370       // publish mesh in the study
1371       SALOMEDS::SObject_wrap aSO;
1372       if ( CanPublishInStudy( mesh ) )
1373         // little trick: for MED file theFileName and theFileNameForPython are the same, but they are different for SAUV
1374         // - as names of meshes are stored in MED file, we use them for data publishing
1375         // - as mesh name is not stored in UNV file, we use file name as name of mesh when publishing data
1376         aSO = PublishMesh( mesh.in(), ( theFileName == theFileNameForPython ) ? (*it).c_str() : aFileName.c_str() );
1377
1378       // Python Dump
1379       if ( !aSO->_is_nil() ) {
1380         aPythonDump << aSO;
1381       } else {
1382         aPythonDump << "mesh_" << i;
1383       }
1384
1385       // Read mesh data (groups are published automatically by ImportMEDFile())
1386       SMESH_Mesh_i* meshServant = dynamic_cast<SMESH_Mesh_i*>( GetServant( mesh ).in() );
1387       ASSERT( meshServant );
1388       SMESH::DriverMED_ReadStatus status1 =
1389         meshServant->ImportMEDFile( theFileName, (*it).c_str() );
1390       if (status1 > theStatus)
1391         theStatus = status1;
1392
1393       aResult[i++] = SMESH::SMESH_Mesh::_duplicate( mesh );
1394       meshServant->GetImpl().GetMeshDS()->Modified();
1395     }
1396     if ( !aStudyBuilder->_is_nil() )
1397       aStudyBuilder->CommitCommand();
1398   }
1399
1400   // Update Python script
1401   aPythonDump << "], status) = " << this << "." << theCommandNameForPython << "(r'" << theFileNameForPython << "')";
1402   }
1403   // Dump creation of groups
1404   for ( CORBA::ULong  i = 0; i < aResult->length(); ++i )
1405     SMESH::ListOfGroups_var groups = aResult[ i ]->GetGroups();
1406
1407   return aResult._retn();
1408 }
1409
1410 SMESH::mesh_array* SMESH_Gen_i::CreateMeshesFromMED( const char* theFileName,
1411                                                      SMESH::DriverMED_ReadStatus& theStatus)
1412   throw ( SALOME::SALOME_Exception )
1413 {
1414   Unexpect aCatch(SALOME_SalomeException);
1415   checkFileReadable( theFileName );
1416
1417   SMESH::mesh_array* result = CreateMeshesFromMEDorSAUV(theFileName, theStatus, "CreateMeshesFromMED", theFileName);
1418   return result;
1419 }
1420
1421 //=============================================================================
1422 /*!
1423  *  SMESH_Gen_i::CreateMeshFromSAUV
1424  *
1425  *  Create mesh and import data from SAUV file
1426  */
1427 //=============================================================================
1428
1429 SMESH::mesh_array* SMESH_Gen_i::CreateMeshesFromSAUV( const char* theFileName,
1430                                                       SMESH::DriverMED_ReadStatus& theStatus)
1431      throw ( SALOME::SALOME_Exception )
1432 {
1433   Unexpect aCatch(SALOME_SalomeException);
1434   checkFileReadable( theFileName );
1435
1436   std::string sauvfilename(theFileName);
1437   std::string medfilename(theFileName);
1438   medfilename += ".med";
1439   std::string cmd;
1440 #ifdef WIN32
1441   cmd = "%PYTHONBIN% ";
1442 #else
1443   cmd = "python3 ";
1444 #endif
1445   cmd += "-c \"";
1446   cmd += "from medutilities import convert ; convert(r'" + sauvfilename + "', 'GIBI', 'MED', 1, r'" + medfilename + "')";
1447   cmd += "\"";
1448   system(cmd.c_str());
1449   SMESH::mesh_array* result = CreateMeshesFromMEDorSAUV(medfilename.c_str(), theStatus, "CreateMeshesFromSAUV", sauvfilename.c_str());
1450 #ifdef WIN32
1451   cmd = "%PYTHONBIN% ";
1452 #else
1453   cmd = "python3 ";
1454 #endif
1455   cmd += "-c \"";
1456   cmd += "from medutilities import my_remove ; my_remove(r'" + medfilename + "')";
1457   cmd += "\"";
1458   system(cmd.c_str());
1459   return result;
1460 }
1461
1462 //=============================================================================
1463 /*!
1464  *  SMESH_Gen_i::CreateMeshFromSTL
1465  *
1466  *  Create mesh and import data from STL file
1467  */
1468 //=============================================================================
1469
1470 SMESH::SMESH_Mesh_ptr SMESH_Gen_i::CreateMeshesFromSTL( const char* theFileName )
1471   throw ( SALOME::SALOME_Exception )
1472 {
1473   Unexpect aCatch(SALOME_SalomeException);
1474   checkFileReadable( theFileName );
1475
1476   SMESH::SMESH_Mesh_var aMesh = createMesh();
1477   //string aFileName;
1478 #ifdef WIN32
1479   char bname[ _MAX_FNAME ];
1480   _splitpath( theFileName, NULL, NULL, bname, NULL );
1481   string aFileName = bname;
1482 #else
1483   string aFileName = basename( const_cast<char *>(theFileName) );
1484 #endif
1485   // publish mesh in the study
1486   if ( CanPublishInStudy( aMesh ) ) {
1487     SALOMEDS::StudyBuilder_var aStudyBuilder = getStudyServant()->NewBuilder();
1488     aStudyBuilder->NewCommand();  // There is a transaction
1489     SALOMEDS::SObject_wrap aSO = PublishInStudy( SALOMEDS::SObject::_nil(), aMesh.in(), aFileName.c_str() );
1490     aStudyBuilder->CommitCommand();
1491     if ( !aSO->_is_nil() ) {
1492       // Update Python script
1493       TPythonDump() << aSO << " = " << this << ".CreateMeshesFromSTL(r'" << theFileName << "')";
1494     }
1495   }
1496
1497   SMESH_Mesh_i* aServant = dynamic_cast<SMESH_Mesh_i*>( GetServant( aMesh ).in() );
1498   ASSERT( aServant );
1499   aServant->ImportSTLFile( theFileName );
1500   aServant->GetImpl().GetMeshDS()->Modified();
1501   return aMesh._retn();
1502 }
1503
1504 //================================================================================
1505 /*!
1506  * \brief Create meshes and import data from the CGSN file
1507  */
1508 //================================================================================
1509
1510 SMESH::mesh_array* SMESH_Gen_i::CreateMeshesFromCGNS( const char* theFileName,
1511                                                       SMESH::DriverMED_ReadStatus& theStatus)
1512   throw ( SALOME::SALOME_Exception )
1513 {
1514   Unexpect aCatch(SALOME_SalomeException);
1515   checkFileReadable( theFileName );
1516
1517   SMESH::mesh_array_var aResult = new SMESH::mesh_array();
1518
1519 #ifdef WITH_CGNS
1520   // Retrieve nb meshes from the file
1521   DriverCGNS_Read myReader;
1522   myReader.SetFile( theFileName );
1523   Driver_Mesh::Status aStatus;
1524   int nbMeshes = myReader.GetNbMeshes(aStatus);
1525   theStatus = (SMESH::DriverMED_ReadStatus)aStatus;
1526
1527   aResult->length( nbMeshes );
1528
1529   { // open a new scope to make aPythonDump die before PythonDump in SMESH_Mesh::GetGroups()
1530
1531     // Python Dump
1532     TPythonDump aPythonDump;
1533     aPythonDump << "([";
1534
1535     if (theStatus == SMESH::DRS_OK)
1536     {
1537       SALOMEDS::StudyBuilder_var aStudyBuilder = getStudyServant()->NewBuilder();
1538       aStudyBuilder->NewCommand();  // There is a transaction
1539
1540       int i = 0;
1541
1542       // Iterate through all meshes and create mesh objects
1543       for ( ; i < nbMeshes; ++i )
1544       {
1545         // Python Dump
1546         if (i > 0) aPythonDump << ", ";
1547
1548         // create mesh
1549         SMESH::SMESH_Mesh_var mesh = createMesh();
1550         aResult[i] = SMESH::SMESH_Mesh::_duplicate( mesh );
1551
1552         // Read mesh data (groups are published automatically by ImportMEDFile())
1553         SMESH_Mesh_i* meshServant = dynamic_cast<SMESH_Mesh_i*>( GetServant( mesh ).in() );
1554         ASSERT( meshServant );
1555         string meshName;
1556         SMESH::DriverMED_ReadStatus status1 =
1557           meshServant->ImportCGNSFile( theFileName, i, meshName );
1558         if (status1 > theStatus)
1559           theStatus = status1;
1560
1561         meshServant->GetImpl().GetMeshDS()->Modified();
1562         // publish mesh in the study
1563         SALOMEDS::SObject_wrap aSO;
1564         if ( CanPublishInStudy( mesh ) )
1565           aSO = PublishMesh( mesh.in(), meshName.c_str() );
1566
1567         // Python Dump
1568         if ( !aSO->_is_nil() ) {
1569           aPythonDump << aSO;
1570         }
1571         else {
1572           aPythonDump << "mesh_" << i;
1573         }
1574       }
1575       aStudyBuilder->CommitCommand();
1576     }
1577
1578     aPythonDump << "], status) = " << this << ".CreateMeshesFromCGNS(r'" << theFileName << "')";
1579   }
1580   // Dump creation of groups
1581   for ( CORBA::ULong i = 0; i < aResult->length(); ++i )
1582     SMESH::ListOfGroups_var groups = aResult[ i ]->GetGroups();
1583 #else
1584   THROW_SALOME_CORBA_EXCEPTION("CGNS library is unavailable", SALOME::INTERNAL_ERROR);
1585 #endif
1586
1587   return aResult._retn();
1588 }
1589
1590 //================================================================================
1591 /*!
1592  * \brief Create a mesh and import data from a GMF file
1593  */
1594 //================================================================================
1595
1596 SMESH::SMESH_Mesh_ptr
1597 SMESH_Gen_i::CreateMeshesFromGMF( const char*             theFileName,
1598                                   CORBA::Boolean          theMakeRequiredGroups,
1599                                   SMESH::ComputeError_out theError)
1600     throw ( SALOME::SALOME_Exception )
1601 {
1602   Unexpect aCatch(SALOME_SalomeException);
1603   checkFileReadable( theFileName );
1604
1605   SMESH::SMESH_Mesh_var aMesh = createMesh();
1606 #ifdef WIN32
1607   char bname[ _MAX_FNAME ];
1608   _splitpath( theFileName, NULL, NULL, bname, NULL );
1609   string aFileName = bname;
1610 #else
1611   string aFileName = basename( const_cast<char *>(theFileName) );
1612 #endif
1613   // publish mesh in the study
1614   if ( CanPublishInStudy( aMesh ) ) {
1615     SALOMEDS::StudyBuilder_var aStudyBuilder = getStudyServant()->NewBuilder();
1616     aStudyBuilder->NewCommand();  // There is a transaction
1617     SALOMEDS::SObject_wrap aSO = PublishInStudy( SALOMEDS::SObject::_nil(), aMesh.in(), aFileName.c_str() );
1618     aStudyBuilder->CommitCommand();
1619     if ( !aSO->_is_nil() ) {
1620       // Update Python script
1621       TPythonDump() << "("<< aSO << ", error) = " << this << ".CreateMeshesFromGMF(r'"
1622                     << theFileName << "', "
1623                     << theMakeRequiredGroups << " )";
1624     }
1625   }
1626   SMESH_Mesh_i* aServant = dynamic_cast<SMESH_Mesh_i*>( GetServant( aMesh ).in() );
1627   ASSERT( aServant );
1628   theError = aServant->ImportGMFFile( theFileName, theMakeRequiredGroups );
1629   aServant->GetImpl().GetMeshDS()->Modified();
1630   return aMesh._retn();
1631 }
1632
1633
1634 //=============================================================================
1635 /*!
1636  *  SMESH_Gen_i::IsReadyToCompute
1637  *
1638  *  Returns true if mesh contains enough data to be computed
1639  */
1640 //=============================================================================
1641
1642 CORBA::Boolean SMESH_Gen_i::IsReadyToCompute( SMESH::SMESH_Mesh_ptr theMesh,
1643                                               GEOM::GEOM_Object_ptr theShapeObject )
1644   throw ( SALOME::SALOME_Exception )
1645 {
1646   Unexpect aCatch(SALOME_SalomeException);
1647   if(MYDEBUG) MESSAGE( "SMESH_Gen_i::IsReadyToCompute" );
1648
1649   if ( CORBA::is_nil( theShapeObject ) )
1650     THROW_SALOME_CORBA_EXCEPTION( "bad shape object reference",
1651                                   SALOME::BAD_PARAM );
1652
1653   if ( CORBA::is_nil( theMesh ) )
1654     THROW_SALOME_CORBA_EXCEPTION( "bad Mesh reference",
1655                                   SALOME::BAD_PARAM );
1656
1657   try {
1658     // get mesh servant
1659     SMESH_Mesh_i* meshServant = dynamic_cast<SMESH_Mesh_i*>( GetServant( theMesh ).in() );
1660     ASSERT( meshServant );
1661     if ( meshServant ) {
1662       // get local TopoDS_Shape
1663       TopoDS_Shape myLocShape = GeomObjectToShape( theShapeObject );
1664       // call implementation
1665       ::SMESH_Mesh& myLocMesh = meshServant->GetImpl();
1666       return myGen.CheckAlgoState( myLocMesh, myLocShape );
1667     }
1668   }
1669   catch ( SALOME_Exception& S_ex ) {
1670     INFOS( "catch exception "<< S_ex.what() );
1671   }
1672   return false;
1673 }
1674
1675 //================================================================================
1676 /*!
1677  * \brief  Find SObject for an algo
1678  */
1679 //================================================================================
1680
1681 SALOMEDS::SObject_ptr SMESH_Gen_i::GetAlgoSO(const ::SMESH_Algo* algo)
1682 {
1683   if ( algo ) {
1684   SALOMEDS::Study_var aStudy = getStudyServant();
1685     if ( !aStudy->_is_nil() ) {
1686       // find algo in the study
1687       CORBA::String_var compDataType  = ComponentDataType();
1688       SALOMEDS::SComponent_wrap father = aStudy->FindComponent( compDataType.in() );
1689       if ( !father->_is_nil() ) {
1690         SALOMEDS::ChildIterator_wrap itBig = aStudy->NewChildIterator( father );
1691         for ( ; itBig->More(); itBig->Next() ) {
1692           SALOMEDS::SObject_wrap gotBranch = itBig->Value();
1693           if ( gotBranch->Tag() == GetAlgorithmsRootTag() ) {
1694             SALOMEDS::ChildIterator_wrap algoIt = aStudy->NewChildIterator( gotBranch );
1695             for ( ; algoIt->More(); algoIt->Next() ) {
1696               SALOMEDS::SObject_wrap algoSO = algoIt->Value();
1697               CORBA::Object_var     algoIOR = SObjectToObject( algoSO );
1698               if ( !CORBA::is_nil( algoIOR )) {
1699                 SMESH_Hypothesis_i* impl = SMESH::DownCast<SMESH_Hypothesis_i*>( algoIOR );
1700                 if ( impl && impl->GetImpl() == algo )
1701                   return algoSO._retn();
1702               }
1703             } // loop on algo SO's
1704             break;
1705           } // if algo tag
1706         } // SMESH component iterator
1707       }
1708     }
1709   }
1710   return SALOMEDS::SObject::_nil();
1711 }
1712
1713 //================================================================================
1714 /*!
1715  * \brief Return errors of mesh computation
1716  */
1717 //================================================================================
1718
1719 SMESH::compute_error_array* SMESH_Gen_i::GetComputeErrors( SMESH::SMESH_Mesh_ptr theMesh,
1720                                                            GEOM::GEOM_Object_ptr theSubObject )
1721   throw ( SALOME::SALOME_Exception )
1722 {
1723   Unexpect aCatch(SALOME_SalomeException);
1724   if(MYDEBUG) MESSAGE( "SMESH_Gen_i::GetComputeErrors()" );
1725
1726   if ( CORBA::is_nil( theSubObject ) && theMesh->HasShapeToMesh())
1727     THROW_SALOME_CORBA_EXCEPTION( "bad shape object reference", SALOME::BAD_PARAM );
1728
1729   if ( CORBA::is_nil( theMesh ) )
1730     THROW_SALOME_CORBA_EXCEPTION( "bad Mesh reference",SALOME::BAD_PARAM );
1731
1732   SMESH::compute_error_array_var error_array = new SMESH::compute_error_array;
1733   try {
1734     if ( SMESH_Mesh_i* meshServant = SMESH::DownCast<SMESH_Mesh_i*>( theMesh ))
1735     {
1736       TopoDS_Shape shape;
1737       if(theMesh->HasShapeToMesh())
1738         shape = GeomObjectToShape( theSubObject );
1739       else
1740         shape = SMESH_Mesh::PseudoShape();
1741
1742       ::SMESH_Mesh& mesh = meshServant->GetImpl();
1743
1744       error_array->length( mesh.GetMeshDS()->MaxShapeIndex() );
1745       int nbErr = 0;
1746
1747       SMESH_subMesh *sm = mesh.GetSubMesh(shape);
1748       const bool includeSelf = true, complexShapeFirst = true;
1749       SMESH_subMeshIteratorPtr smIt = sm->getDependsOnIterator(includeSelf,
1750                                                                complexShapeFirst);
1751       while ( smIt->more() )
1752       {
1753         sm = smIt->next();
1754         // if ( sm->GetSubShape().ShapeType() == TopAbs_VERTEX )
1755         //   break;
1756         SMESH_ComputeErrorPtr error = sm->GetComputeError();
1757         if ( error && !error->IsOK() )
1758         {
1759           if ( !( error->myAlgo ) &&
1760                !( error->myAlgo = sm->GetAlgo() ))
1761             continue;
1762           SMESH::ComputeError & errStruct = error_array[ nbErr++ ];
1763           errStruct.code       = -( error->myName < 0 ? error->myName + 1: error->myName ); // -1 -> 0
1764           errStruct.comment    = error->myComment.c_str();
1765           errStruct.subShapeID = sm->GetId();
1766           SALOMEDS::SObject_wrap algoSO = GetAlgoSO( error->myAlgo );
1767           if ( !algoSO->_is_nil() ) {
1768             CORBA::String_var algoName = algoSO->GetName();
1769             errStruct.algoName = algoName;
1770           }
1771           else {
1772             errStruct.algoName = error->myAlgo->GetName();
1773           }
1774           errStruct.hasBadMesh = error->HasBadElems();
1775         }
1776       }
1777       error_array->length( nbErr );
1778     }
1779   }
1780   catch ( SALOME_Exception& S_ex ) {
1781     INFOS( "catch exception "<< S_ex.what() );
1782   }
1783
1784   return error_array._retn();
1785 }
1786
1787 //================================================================================
1788 /*!
1789  * \brief Return mesh elements preventing computation of a subshape
1790  */
1791 //================================================================================
1792
1793 SMESH::MeshPreviewStruct*
1794 SMESH_Gen_i::GetBadInputElements( SMESH::SMESH_Mesh_ptr theMesh,
1795                                   CORBA::Short          theSubShapeID )
1796   throw ( SALOME::SALOME_Exception )
1797 {
1798   Unexpect aCatch(SALOME_SalomeException);
1799   if(MYDEBUG) MESSAGE( "SMESH_Gen_i::GetBadInputElements()" );
1800
1801   if ( CORBA::is_nil( theMesh ) )
1802     THROW_SALOME_CORBA_EXCEPTION( "bad Mesh reference",SALOME::BAD_PARAM );
1803
1804   SMESH::MeshPreviewStruct_var result = new SMESH::MeshPreviewStruct;
1805   try {
1806     // mesh servant
1807     if ( SMESH_Mesh_i* meshServant = SMESH::DownCast<SMESH_Mesh_i*>( theMesh ))
1808     {
1809       // mesh implementation
1810       ::SMESH_Mesh& mesh = meshServant->GetImpl();
1811       // submesh by subshape id
1812       if ( SMESH_subMesh * sm = mesh.GetSubMeshContaining( theSubShapeID ))
1813       {
1814         // compute error
1815         SMESH_ComputeErrorPtr error = sm->GetComputeError();
1816         if ( error && error->HasBadElems() )
1817         {
1818           typedef map<const SMDS_MeshElement*, int > TNode2LocalIDMap;
1819           typedef TNode2LocalIDMap::iterator         TNodeLocalID;
1820
1821           // get nodes of elements and count elements
1822           TNode2LocalIDMap mapNode2LocalID;
1823           list< TNodeLocalID > connectivity;
1824           int i, nbElements = 0, nbConnNodes = 0;
1825
1826           const list<const SMDS_MeshElement*>& badElems =
1827             static_cast<SMESH_BadInputElements*>( error.get() )->myBadElements;
1828           list<const SMDS_MeshElement*>::const_iterator elemIt  = badElems.begin();
1829           list<const SMDS_MeshElement*>::const_iterator elemEnd = badElems.end();
1830           for ( ; elemIt != elemEnd; ++elemIt, ++nbElements )
1831           {
1832             SMDS_ElemIteratorPtr nIt = (*elemIt)->nodesIterator();
1833             while ( nIt->more() )
1834               connectivity.push_back
1835                 ( mapNode2LocalID.insert( make_pair( nIt->next(), ++nbConnNodes)).first );
1836           }
1837           // fill node coords and assign local ids to the nodes
1838           int nbNodes = mapNode2LocalID.size();
1839           result->nodesXYZ.length( nbNodes );
1840           TNodeLocalID node2ID = mapNode2LocalID.begin();
1841           for ( i = 0; i < nbNodes; ++i, ++node2ID ) {
1842             node2ID->second = i;
1843             const SMDS_MeshNode* node = (const SMDS_MeshNode*) node2ID->first;
1844             result->nodesXYZ[i].x = node->X();
1845             result->nodesXYZ[i].y = node->Y();
1846             result->nodesXYZ[i].z = node->Z();
1847           }
1848           // fill connectivity
1849           result->elementConnectivities.length( nbConnNodes );
1850           list< TNodeLocalID >::iterator connIt = connectivity.begin();
1851           for ( i = 0; i < nbConnNodes; ++i, ++connIt ) {
1852             result->elementConnectivities[i] = (*connIt)->second;
1853           }
1854           // fill element types
1855           result->elementTypes.length( nbElements );
1856           for ( i = 0, elemIt = badElems.begin(); i <nbElements; ++i, ++elemIt )
1857           {
1858             const SMDS_MeshElement* elem = *elemIt;
1859             result->elementTypes[i].SMDS_ElementType = (SMESH::ElementType) elem->GetType();
1860             result->elementTypes[i].isPoly           = elem->IsPoly();
1861             result->elementTypes[i].nbNodesInElement = elem->NbNodes();
1862           }
1863         }
1864       }
1865     }
1866   }
1867   catch ( SALOME_Exception& S_ex ) {
1868     INFOS( "catch exception "<< S_ex.what() );
1869   }
1870
1871   return result._retn();
1872 }
1873
1874 //================================================================================
1875 /*!
1876  * \brief Create a group of elements preventing computation of a sub-shape
1877  */
1878 //================================================================================
1879
1880 SMESH::ListOfGroups*
1881 SMESH_Gen_i::MakeGroupsOfBadInputElements( SMESH::SMESH_Mesh_ptr theMesh,
1882                                            CORBA::Short          theSubShapeID,
1883                                            const char*           theGroupName )
1884   throw ( SALOME::SALOME_Exception )
1885 {
1886   Unexpect aCatch(SALOME_SalomeException);
1887
1888   SMESH::ListOfGroups_var groups;
1889
1890   if ( CORBA::is_nil( theMesh ) )
1891     THROW_SALOME_CORBA_EXCEPTION( "bad Mesh reference",SALOME::BAD_PARAM );
1892
1893   try {
1894     if ( SMESH_Mesh_i* meshServant = SMESH::DownCast<SMESH_Mesh_i*>( theMesh ))
1895     {
1896       groups = meshServant->MakeGroupsOfBadInputElements( theSubShapeID, theGroupName );
1897       TPythonDump() << groups << " = " << this
1898                     << ".MakeGroupsOfBadInputElements( "
1899                     << theMesh << ", " << theSubShapeID << ", '" << theGroupName << "' )";
1900     }
1901   }
1902   catch ( SALOME_Exception& S_ex ) {
1903     INFOS( "catch exception "<< S_ex.what() );
1904   }
1905   return groups._retn();
1906 }
1907
1908 //================================================================================
1909 /*!
1910  * \brief Returns errors of hypotheses definition
1911  * \param theMesh - the mesh
1912  * \param theSubObject - the main or sub- shape
1913  * \retval SMESH::algo_error_array* - sequence of errors
1914  */
1915 //================================================================================
1916
1917 SMESH::algo_error_array* SMESH_Gen_i::GetAlgoState( SMESH::SMESH_Mesh_ptr theMesh,
1918                                                     GEOM::GEOM_Object_ptr theSubObject )
1919       throw ( SALOME::SALOME_Exception )
1920 {
1921   Unexpect aCatch(SALOME_SalomeException);
1922   if(MYDEBUG) MESSAGE( "SMESH_Gen_i::GetAlgoState()" );
1923
1924   if ( CORBA::is_nil( theSubObject ) && theMesh->HasShapeToMesh())
1925     THROW_SALOME_CORBA_EXCEPTION( "bad shape object reference", SALOME::BAD_PARAM );
1926
1927   if ( CORBA::is_nil( theMesh ) )
1928     THROW_SALOME_CORBA_EXCEPTION( "bad Mesh reference",SALOME::BAD_PARAM );
1929
1930   SMESH::algo_error_array_var error_array = new SMESH::algo_error_array;
1931   try {
1932     SMESH_Mesh_i* meshServant = SMESH::DownCast<SMESH_Mesh_i*>( theMesh );
1933     ASSERT( meshServant );
1934     if ( meshServant ) {
1935       TopoDS_Shape myLocShape;
1936       if(theMesh->HasShapeToMesh())
1937         myLocShape = GeomObjectToShape( theSubObject );
1938       else
1939         myLocShape = SMESH_Mesh::PseudoShape();
1940
1941       ::SMESH_Mesh& myLocMesh = meshServant->GetImpl();
1942       list< ::SMESH_Gen::TAlgoStateError > error_list;
1943       list< ::SMESH_Gen::TAlgoStateError >::iterator error;
1944       // call ::SMESH_Gen::GetAlgoState()
1945       myGen.GetAlgoState( myLocMesh, myLocShape, error_list );
1946       error_array->length( error_list.size() );
1947       int i = 0;
1948       for ( error = error_list.begin(); error != error_list.end(); ++error )
1949       {
1950         // fill AlgoStateError structure
1951         SMESH::AlgoStateError & errStruct = error_array[ i++ ];
1952         errStruct.state        = SMESH_Mesh_i::ConvertHypothesisStatus( error->_name );
1953         errStruct.algoDim      = error->_algoDim;
1954         errStruct.isGlobalAlgo = error->_isGlobalAlgo;
1955         errStruct.algoName     = "";
1956         SALOMEDS::SObject_wrap algoSO = GetAlgoSO( error->_algo );
1957         if ( !algoSO->_is_nil() ) {
1958           CORBA::String_var algoName = algoSO->GetName();
1959           errStruct.algoName = algoName.in();
1960         }
1961       }
1962     }
1963   }
1964   catch ( SALOME_Exception& S_ex ) {
1965     INFOS( "catch exception "<< S_ex.what() );
1966   }
1967   return error_array._retn();
1968 }
1969
1970 //=============================================================================
1971 /*!
1972  *  SMESH_Gen_i::GetSubShapesId
1973  *
1974  *  Get sub-shapes unique ID's list
1975  */
1976 //=============================================================================
1977
1978 SMESH::long_array*
1979 SMESH_Gen_i::GetSubShapesId( GEOM::GEOM_Object_ptr      theMainShapeObject,
1980                              const SMESH::object_array& theListOfSubShapeObject )
1981   throw ( SALOME::SALOME_Exception )
1982 {
1983   Unexpect aCatch(SALOME_SalomeException);
1984   if(MYDEBUG) MESSAGE( "SMESH_Gen_i::GetSubShapesId" );
1985
1986   SMESH::long_array_var shapesId = new SMESH::long_array;
1987   set<int> setId;
1988
1989   if ( CORBA::is_nil( theMainShapeObject ) )
1990     THROW_SALOME_CORBA_EXCEPTION( "bad shape object reference", SALOME::BAD_PARAM );
1991
1992   try
1993   {
1994     TopoDS_Shape myMainShape = GeomObjectToShape(theMainShapeObject);
1995     TopTools_IndexedMapOfShape myIndexToShape;
1996     TopExp::MapShapes(myMainShape,myIndexToShape);
1997
1998     for ( CORBA::ULong i = 0; i < theListOfSubShapeObject.length(); i++ )
1999     {
2000       GEOM::GEOM_Object_var aShapeObject
2001         = GEOM::GEOM_Object::_narrow(theListOfSubShapeObject[i]);
2002       if ( CORBA::is_nil( aShapeObject ) )
2003         THROW_SALOME_CORBA_EXCEPTION ("bad shape object reference",     \
2004                                       SALOME::BAD_PARAM );
2005
2006       TopoDS_Shape locShape  = GeomObjectToShape(aShapeObject);
2007       for (TopExp_Explorer exp(locShape,TopAbs_FACE); exp.More(); exp.Next())
2008       {
2009         const TopoDS_Face& F = TopoDS::Face(exp.Current());
2010         setId.insert(myIndexToShape.FindIndex(F));
2011         if(MYDEBUG) SCRUTE(myIndexToShape.FindIndex(F));
2012       }
2013       for (TopExp_Explorer exp(locShape,TopAbs_EDGE); exp.More(); exp.Next())
2014       {
2015         const TopoDS_Edge& E = TopoDS::Edge(exp.Current());
2016         setId.insert(myIndexToShape.FindIndex(E));
2017         if(MYDEBUG) SCRUTE(myIndexToShape.FindIndex(E));
2018       }
2019       for (TopExp_Explorer exp(locShape,TopAbs_VERTEX); exp.More(); exp.Next())
2020       {
2021         const TopoDS_Vertex& V = TopoDS::Vertex(exp.Current());
2022         setId.insert(myIndexToShape.FindIndex(V));
2023         if(MYDEBUG) SCRUTE(myIndexToShape.FindIndex(V));
2024       }
2025     }
2026     shapesId->length(setId.size());
2027     set<int>::iterator iind;
2028     int i=0;
2029     for (iind = setId.begin(); iind != setId.end(); iind++)
2030     {
2031       if(MYDEBUG) SCRUTE((*iind));
2032       shapesId[i] = (*iind);
2033       if(MYDEBUG) SCRUTE(shapesId[i]);
2034       i++;
2035     }
2036   }
2037   catch (SALOME_Exception& S_ex)
2038   {
2039     THROW_SALOME_CORBA_EXCEPTION(S_ex.what(), SALOME::BAD_PARAM);
2040   }
2041
2042   return shapesId._retn();
2043 }
2044
2045 //=============================================================================
2046 /*!
2047  *  SMESH_Gen_i::Compute
2048  *
2049  *  Compute mesh on a shape
2050  */
2051 //=============================================================================
2052
2053 CORBA::Boolean SMESH_Gen_i::Compute( SMESH::SMESH_Mesh_ptr theMesh,
2054                                      GEOM::GEOM_Object_ptr theShapeObject )
2055      throw ( SALOME::SALOME_Exception )
2056 {
2057   //MEMOSTAT;
2058   Unexpect aCatch(SALOME_SalomeException);
2059   if(MYDEBUG) MESSAGE( "SMESH_Gen_i::Compute" );
2060
2061   if ( CORBA::is_nil( theShapeObject ) && theMesh->HasShapeToMesh())
2062     THROW_SALOME_CORBA_EXCEPTION( "bad shape object reference",
2063                                   SALOME::BAD_PARAM );
2064
2065   if ( CORBA::is_nil( theMesh ) )
2066     THROW_SALOME_CORBA_EXCEPTION( "bad Mesh reference",
2067                                   SALOME::BAD_PARAM );
2068
2069   // Update Python script
2070   TPythonDump() << "isDone = " << this << ".Compute( "
2071                 << theMesh << ", " << theShapeObject << ")";
2072
2073   try {
2074     // get mesh servant
2075     SMESH_Mesh_i* meshServant = SMESH::DownCast<SMESH_Mesh_i*>( theMesh );
2076     ASSERT( meshServant );
2077     if ( meshServant ) {
2078       if ( isGeomModifIcon( theMesh ))
2079         meshServant->Clear();
2080       else
2081         meshServant->Load();
2082       // NPAL16168: "geometrical group edition from a submesh don't modify mesh computation"
2083       meshServant->CheckGeomModif();
2084       // get local TopoDS_Shape
2085       TopoDS_Shape myLocShape;
2086       if(theMesh->HasShapeToMesh())
2087         myLocShape = GeomObjectToShape( theShapeObject );
2088       else
2089         myLocShape = SMESH_Mesh::PseudoShape();
2090       // call implementation compute
2091       ::SMESH_Mesh& myLocMesh = meshServant->GetImpl();
2092       myGen.PrepareCompute( myLocMesh, myLocShape );
2093       int how = ::SMESH_Gen::COMPACT_MESH;
2094       if ( myLocShape != myLocMesh.GetShapeToMesh() ) // compute a sub-mesh
2095         how |= ::SMESH_Gen::SHAPE_ONLY;
2096       bool ok = myGen.Compute( myLocMesh, myLocShape, how );
2097       meshServant->CreateGroupServants(); // algos can create groups (issue 0020918)
2098       myLocMesh.GetMeshDS()->Modified();
2099       UpdateIcons( theMesh );
2100       if ( ok )
2101         HighLightInvalid( theMesh, /*isInvalid=*/false );
2102       return ok;
2103     }
2104   }
2105   catch ( std::bad_alloc ) {
2106     INFOS( "Compute(): lack of memory" );
2107   }
2108   catch ( SALOME_Exception& S_ex ) {
2109     INFOS( "Compute(): catch exception "<< S_ex.what() );
2110   }
2111   catch ( ... ) {
2112     INFOS( "Compute(): unknown exception " );
2113   }
2114   return false;
2115 }
2116
2117 //=============================================================================
2118 /*!
2119  *  SMESH_Gen_i::CancelCompute
2120  *
2121  *  Cancel Compute mesh on a shape
2122  */
2123 //=============================================================================
2124
2125 void SMESH_Gen_i::CancelCompute( SMESH::SMESH_Mesh_ptr theMesh,
2126                                  GEOM::GEOM_Object_ptr theShapeObject )
2127 {
2128   if ( SMESH_Mesh_i* meshServant = dynamic_cast<SMESH_Mesh_i*>( GetServant( theMesh ).in() ))
2129   {
2130     ::SMESH_Mesh& myLocMesh = meshServant->GetImpl();
2131     TopoDS_Shape myLocShape;
2132     if(theMesh->HasShapeToMesh())
2133       myLocShape = GeomObjectToShape( theShapeObject );
2134     else
2135       myLocShape = SMESH_Mesh::PseudoShape();
2136     myGen.CancelCompute( myLocMesh, myLocShape);
2137   }
2138 }
2139
2140 //=============================================================================
2141 /*!
2142  *  SMESH_Gen_i::Precompute
2143  *
2144  *  Compute mesh as preview till indicated dimension on shape
2145  */
2146 //=============================================================================
2147
2148 SMESH::MeshPreviewStruct* SMESH_Gen_i::Precompute( SMESH::SMESH_Mesh_ptr theMesh,
2149                                                    GEOM::GEOM_Object_ptr theShapeObject,
2150                                                    SMESH::Dimension      theDimension,
2151                                                    SMESH::long_array&    theShapesId)
2152      throw ( SALOME::SALOME_Exception )
2153 {
2154   Unexpect aCatch(SALOME_SalomeException);
2155   if(MYDEBUG) MESSAGE( "SMESH_Gen_i::Precompute" );
2156
2157   if ( CORBA::is_nil( theShapeObject ) && theMesh->HasShapeToMesh())
2158     THROW_SALOME_CORBA_EXCEPTION( "bad shape object reference",
2159                                   SALOME::BAD_PARAM );
2160
2161   if ( CORBA::is_nil( theMesh ) )
2162     THROW_SALOME_CORBA_EXCEPTION( "bad Mesh reference",
2163                                   SALOME::BAD_PARAM );
2164
2165   SMESH::MeshPreviewStruct_var result = new SMESH::MeshPreviewStruct;
2166   try {
2167     // get mesh servant
2168     SMESH_Mesh_i* meshServant = dynamic_cast<SMESH_Mesh_i*>( GetServant( theMesh ).in() );
2169     meshServant->Load();
2170     ASSERT( meshServant );
2171     if ( meshServant ) {
2172       // NPAL16168: "geometrical group edition from a submesh don't modify mesh computation"
2173       meshServant->CheckGeomModif();
2174       // get local TopoDS_Shape
2175       TopoDS_Shape myLocShape;
2176       if(theMesh->HasShapeToMesh())
2177         myLocShape = GeomObjectToShape( theShapeObject );
2178       else
2179         return result._retn();;
2180
2181       // call implementation compute
2182       ::SMESH_Mesh& myLocMesh = meshServant->GetImpl();
2183       TSetOfInt shapeIds;
2184       ::MeshDimension aDim = (MeshDimension)theDimension;
2185       if ( myGen.Compute( myLocMesh, myLocShape, ::SMESH_Gen::COMPACT_MESH, aDim, &shapeIds ) )
2186       {
2187         int nbShapeId = shapeIds.size();
2188         theShapesId.length( nbShapeId );
2189         // iterates on shapes and collect mesh entities into mesh preview
2190         TSetOfInt::const_iterator idIt = shapeIds.begin();
2191         TSetOfInt::const_iterator idEnd = shapeIds.end();
2192         std::map< int, int > mapOfShIdNb;
2193         std::set< SMESH_TLink > setOfEdge;
2194         std::list< SMDSAbs_ElementType > listOfElemType;
2195         typedef map<const SMDS_MeshElement*, int > TNode2LocalIDMap;
2196         typedef TNode2LocalIDMap::iterator         TNodeLocalID;
2197         TNode2LocalIDMap mapNode2LocalID;
2198         list< TNodeLocalID > connectivity;
2199         int i, nbConnNodes = 0;
2200         std::set< const SMESH_subMesh* > setOfVSubMesh;
2201         // iterates on shapes
2202         for ( ; idIt != idEnd; idIt++ )
2203         {
2204           if ( mapOfShIdNb.find( *idIt ) != mapOfShIdNb.end() )
2205             continue;
2206           SMESH_subMesh* sm = myLocMesh.GetSubMeshContaining(*idIt);
2207           if ( !sm || !sm->IsMeshComputed() )
2208             continue;
2209
2210           const TopoDS_Shape& aSh = sm->GetSubShape();
2211           const int shDim = myGen.GetShapeDim( aSh );
2212           if ( shDim < 1 || shDim > theDimension )
2213             continue;
2214
2215           mapOfShIdNb[ *idIt ] = 0;
2216           theShapesId[ mapOfShIdNb.size() - 1 ] = *idIt;
2217
2218           SMESHDS_SubMesh* smDS = sm->GetSubMeshDS();
2219           if ( !smDS ) continue;
2220
2221           if ( theDimension == SMESH::DIM_2D )
2222           {
2223             SMDS_ElemIteratorPtr faceIt = smDS->GetElements();
2224             while ( faceIt->more() )
2225             {
2226               const SMDS_MeshElement* face = faceIt->next();
2227               int aNbNode = face->NbNodes();
2228               if ( aNbNode > 4 )
2229                 aNbNode /= 2; // do not take into account additional middle nodes
2230
2231               SMDS_MeshNode* node1 = (SMDS_MeshNode*)face->GetNode( 0 );
2232               for ( int nIndx = 0; nIndx < aNbNode; nIndx++ )
2233               {
2234                 SMDS_MeshNode* node2 = (SMDS_MeshNode*)face->GetNode( nIndx+1 < aNbNode ? nIndx+1 : 0 );
2235                 if ( setOfEdge.insert( SMESH_TLink ( node1, node2 ) ).second )
2236                 {
2237                   listOfElemType.push_back( SMDSAbs_Edge );
2238                   connectivity.push_back
2239                     ( mapNode2LocalID.insert( make_pair( node1, ++nbConnNodes)).first );
2240                   connectivity.push_back
2241                     ( mapNode2LocalID.insert( make_pair( node2, ++nbConnNodes)).first );
2242                 }
2243                 node1 = node2;
2244               }
2245             }
2246           }
2247           else if ( theDimension == SMESH::DIM_1D )
2248           {
2249             SMDS_NodeIteratorPtr nodeIt = smDS->GetNodes();
2250             while ( nodeIt->more() )
2251             {
2252               listOfElemType.push_back( SMDSAbs_Node );
2253               connectivity.push_back
2254                 ( mapNode2LocalID.insert( make_pair( nodeIt->next(), ++nbConnNodes)).first );
2255             }
2256             // add corner nodes by first vertex from edge
2257             SMESH_subMeshIteratorPtr edgeSmIt =
2258               sm->getDependsOnIterator(/*includeSelf*/false,
2259                                        /*complexShapeFirst*/false);
2260             while ( edgeSmIt->more() )
2261             {
2262               SMESH_subMesh* vertexSM = edgeSmIt->next();
2263               // check that vertex is not already treated
2264               if ( !setOfVSubMesh.insert( vertexSM ).second )
2265                 continue;
2266               if ( vertexSM->GetSubShape().ShapeType() != TopAbs_VERTEX )
2267                 continue;
2268
2269               const SMESHDS_SubMesh* vertexSmDS = vertexSM->GetSubMeshDS();
2270               SMDS_NodeIteratorPtr nodeIt = vertexSmDS->GetNodes();
2271               while ( nodeIt->more() )
2272               {
2273                 listOfElemType.push_back( SMDSAbs_Node );
2274                 connectivity.push_back
2275                   ( mapNode2LocalID.insert( make_pair( nodeIt->next(), ++nbConnNodes)).first );
2276               }
2277             }
2278           }
2279         }
2280
2281         // fill node coords and assign local ids to the nodes
2282         int nbNodes = mapNode2LocalID.size();
2283         result->nodesXYZ.length( nbNodes );
2284         TNodeLocalID node2ID = mapNode2LocalID.begin();
2285         for ( i = 0; i < nbNodes; ++i, ++node2ID ) {
2286           node2ID->second = i;
2287           const SMDS_MeshNode* node = (const SMDS_MeshNode*) node2ID->first;
2288           result->nodesXYZ[i].x = node->X();
2289           result->nodesXYZ[i].y = node->Y();
2290           result->nodesXYZ[i].z = node->Z();
2291         }
2292         // fill connectivity
2293         result->elementConnectivities.length( nbConnNodes );
2294         list< TNodeLocalID >::iterator connIt = connectivity.begin();
2295         for ( i = 0; i < nbConnNodes; ++i, ++connIt ) {
2296           result->elementConnectivities[i] = (*connIt)->second;
2297         }
2298
2299         // fill element types
2300         result->elementTypes.length( listOfElemType.size() );
2301         std::list< SMDSAbs_ElementType >::const_iterator typeIt = listOfElemType.begin();
2302         std::list< SMDSAbs_ElementType >::const_iterator typeEnd = listOfElemType.end();
2303         for ( i = 0; typeIt != typeEnd; ++i, ++typeIt )
2304         {
2305           SMDSAbs_ElementType elemType = *typeIt;
2306           result->elementTypes[i].SMDS_ElementType = (SMESH::ElementType)elemType;
2307           result->elementTypes[i].isPoly           = false;
2308           result->elementTypes[i].nbNodesInElement = elemType == SMDSAbs_Edge ? 2 : 1;
2309         }
2310
2311         // correct number of shapes
2312         theShapesId.length( mapOfShIdNb.size() );
2313       }
2314     }
2315   }
2316   catch ( std::bad_alloc ) {
2317     INFOS( "Precompute(): lack of memory" );
2318   }
2319   catch ( SALOME_Exception& S_ex ) {
2320     INFOS( "Precompute(): catch exception "<< S_ex.what() );
2321   }
2322   catch ( ... ) {
2323     INFOS( "Precompute(): unknown exception " );
2324   }
2325   return result._retn();
2326 }
2327
2328
2329 //=============================================================================
2330 /*!
2331  *  SMESH_Gen_i::Evaluate
2332  *
2333  *  Evaluate mesh on a shape
2334  */
2335 //=============================================================================
2336
2337 SMESH::long_array* SMESH_Gen_i::Evaluate(SMESH::SMESH_Mesh_ptr theMesh,
2338                                          GEOM::GEOM_Object_ptr theShapeObject)
2339 //                                     SMESH::long_array& theNbElems)
2340      throw ( SALOME::SALOME_Exception )
2341 {
2342   Unexpect aCatch(SALOME_SalomeException);
2343   if(MYDEBUG) MESSAGE( "SMESH_Gen_i::Evaluate" );
2344
2345   if ( CORBA::is_nil( theShapeObject ) && theMesh->HasShapeToMesh())
2346     THROW_SALOME_CORBA_EXCEPTION( "bad shape object reference",
2347                                   SALOME::BAD_PARAM );
2348
2349   if ( CORBA::is_nil( theMesh ) )
2350     THROW_SALOME_CORBA_EXCEPTION( "bad Mesh reference",
2351                                   SALOME::BAD_PARAM );
2352
2353   SMESH::long_array_var nbels = new SMESH::long_array;
2354   nbels->length(SMESH::Entity_Last);
2355   int i = SMESH::Entity_Node;
2356   for (; i < SMESH::Entity_Last; i++)
2357     nbels[i] = 0;
2358
2359   // Update Python script
2360   TPythonDump() << "theNbElems = " << this << ".Evaluate( "
2361                 << theMesh << ", " << theShapeObject << ")";
2362
2363   try {
2364     // get mesh servant
2365     SMESH_Mesh_i* meshServant = dynamic_cast<SMESH_Mesh_i*>( GetServant( theMesh ).in() );
2366     ASSERT( meshServant );
2367     if ( meshServant ) {
2368       meshServant->Load();
2369       // NPAL16168: "geometrical group edition from a submesh don't modify mesh computation"
2370       meshServant->CheckGeomModif();
2371       // get local TopoDS_Shape
2372       TopoDS_Shape myLocShape;
2373       if(theMesh->HasShapeToMesh())
2374         myLocShape = GeomObjectToShape( theShapeObject );
2375       else
2376         myLocShape = SMESH_Mesh::PseudoShape();
2377       // call implementation compute
2378       ::SMESH_Mesh& myLocMesh = meshServant->GetImpl();
2379       MapShapeNbElems aResMap;
2380       /*CORBA::Boolean ret =*/ myGen.Evaluate( myLocMesh, myLocShape, aResMap);
2381       MapShapeNbElemsItr anIt = aResMap.begin();
2382       for(; anIt!=aResMap.end(); anIt++) {
2383         const vector<int>& aVec = (*anIt).second;
2384         for ( i = SMESH::Entity_Node; i < (int)aVec.size(); i++ ) {
2385           int nbElem = aVec[i];
2386           if ( nbElem < 0 ) // algo failed, check that it has reported a message
2387           {
2388             SMESH_subMesh*            sm = anIt->first;
2389             SMESH_ComputeErrorPtr& error = sm->GetComputeError();
2390             const SMESH_Algo*       algo = sm->GetAlgo();
2391             if ( (algo && !error.get()) || error->IsOK() )
2392               error.reset( new SMESH_ComputeError( COMPERR_ALGO_FAILED,"Failed to evaluate",algo));
2393           }
2394           else
2395           {
2396             nbels[i] += aVec[i];
2397           }
2398         }
2399       }
2400       return nbels._retn();
2401     }
2402   }
2403   catch ( std::bad_alloc ) {
2404     INFOS( "Evaluate(): lack of memory" );
2405   }
2406   catch ( SALOME_Exception& S_ex ) {
2407     INFOS( "Evaluate(): catch exception "<< S_ex.what() );
2408   }
2409   catch ( ... ) {
2410     INFOS( "Evaluate(): unknown exception " );
2411   }
2412
2413   return nbels._retn();
2414 }
2415
2416 //================================================================================
2417 /*!
2418  * \brief Return geometrical object the given element is built on
2419  *  \param theMesh - the mesh the element is in
2420  *  \param theElementID - the element ID
2421  *  \param theGeomName - the name of the result geom object if it is not yet published
2422  *  \retval GEOM::GEOM_Object_ptr - the found or just published geom object (no need to UnRegister())
2423  */
2424 //================================================================================
2425
2426 GEOM::GEOM_Object_ptr
2427 SMESH_Gen_i::GetGeometryByMeshElement( SMESH::SMESH_Mesh_ptr  theMesh,
2428                                        CORBA::Long            theElementID,
2429                                        const char*            theGeomName)
2430   throw ( SALOME::SALOME_Exception )
2431 {
2432   Unexpect aCatch(SALOME_SalomeException);
2433
2434   GEOM::GEOM_Object_wrap geom = FindGeometryByMeshElement(theMesh, theElementID);
2435   if ( !geom->_is_nil() ) {
2436     GEOM::GEOM_Object_var mainShape = theMesh->GetShapeToMesh();
2437     GEOM::GEOM_Gen_var    geomGen   = GetGeomEngine( geom );
2438
2439     // try to find the corresponding SObject
2440     SALOMEDS::SObject_wrap SObj = ObjectToSObject( geom.in() );
2441     if ( SObj->_is_nil() ) // submesh can be not found even if published
2442     {
2443       // try to find published submesh
2444       GEOM::ListOfLong_var list = geom->GetSubShapeIndices();
2445       if ( !geom->IsMainShape() && list->length() == 1 ) {
2446         SALOMEDS::SObject_wrap mainSO = ObjectToSObject( mainShape );
2447         SALOMEDS::ChildIterator_wrap it;
2448         if ( !mainSO->_is_nil() ) {
2449           it = getStudyServant()->NewChildIterator( mainSO );
2450         }
2451         if ( !it->_is_nil() ) {
2452           for ( it->InitEx(true); it->More(); it->Next() ) {
2453             SALOMEDS::SObject_wrap      so = it->Value();
2454             CORBA::Object_var         obj = SObjectToObject( so );
2455             GEOM::GEOM_Object_var subGeom = GEOM::GEOM_Object::_narrow( obj );
2456             if ( !subGeom->_is_nil() ) {
2457               GEOM::ListOfLong_var subList = subGeom->GetSubShapeIndices();
2458               if ( subList->length() == 1 && list[0] == subList[0] ) {
2459                 SObj = so;
2460                 geom = subGeom;
2461                 break;
2462               }
2463             }
2464           }
2465         }
2466       }
2467     }
2468     if ( SObj->_is_nil() && !geomGen->_is_nil() ) // publish a new subshape
2469       SObj = geomGen->AddInStudy( geom, theGeomName, mainShape );
2470
2471     // return only published geometry
2472     if ( !SObj->_is_nil() ) {
2473       //return geom._retn(); -- servant of geom must be UnRegister()ed;
2474       CORBA::Object_var    obj = SObjectToObject( SObj );
2475       GEOM::GEOM_Object_var go = GEOM::GEOM_Object::_narrow( obj );
2476       return go._retn();
2477     }
2478   }
2479   return GEOM::GEOM_Object::_nil();
2480 }
2481
2482 //================================================================================
2483 /*!
2484  * \brief Return geometrical object the given element is built on.
2485  *  \param theMesh - the mesh the element is in
2486  *  \param theElementID - the element ID
2487  *  \retval GEOM::GEOM_Object_ptr - the found or created (UnRegister()!) geom object
2488  */
2489 //================================================================================
2490
2491 GEOM::GEOM_Object_ptr
2492 SMESH_Gen_i::FindGeometryByMeshElement( SMESH::SMESH_Mesh_ptr  theMesh,
2493                                         CORBA::Long            theElementID)
2494   throw ( SALOME::SALOME_Exception )
2495 {
2496   Unexpect aCatch(SALOME_SalomeException);
2497   if ( CORBA::is_nil( theMesh ) )
2498     THROW_SALOME_CORBA_EXCEPTION( "bad Mesh reference", SALOME::BAD_PARAM );
2499
2500   GEOM::GEOM_Object_var mainShape = theMesh->GetShapeToMesh();
2501   GEOM::GEOM_Gen_var    geomGen   = GetGeomEngine( mainShape );
2502
2503   // get a core mesh DS
2504   SMESH_Mesh_i* meshServant = SMESH::DownCast<SMESH_Mesh_i*>( theMesh );
2505   if ( meshServant && !geomGen->_is_nil() && !mainShape->_is_nil() )
2506   {
2507     ::SMESH_Mesh & mesh = meshServant->GetImpl();
2508     SMESHDS_Mesh* meshDS = mesh.GetMeshDS();
2509     // find the element in mesh
2510     if ( const SMDS_MeshElement * elem = meshDS->FindElement( theElementID ) ) {
2511       // find a shape id by the element
2512       if ( int shapeID = ::SMESH_MeshEditor( &mesh ).FindShape( elem )) {
2513         // get a geom object by the shape id
2514         GEOM::GEOM_Object_var geom = ShapeToGeomObject( meshDS->IndexToShape( shapeID ));
2515         if ( geom->_is_nil() ) {
2516           // try to find a published sub-shape
2517           SALOMEDS::SObject_wrap mainSO = ObjectToSObject( mainShape );
2518           SALOMEDS::ChildIterator_wrap it;
2519           if ( !mainSO->_is_nil() ) {
2520             it = getStudyServant()->NewChildIterator( mainSO );
2521           }
2522           if ( !it->_is_nil() ) {
2523             for ( it->InitEx(true); it->More(); it->Next() ) {
2524               SALOMEDS::SObject_wrap     so = it->Value();
2525               CORBA::Object_var         obj = SObjectToObject( so );
2526               GEOM::GEOM_Object_var subGeom = GEOM::GEOM_Object::_narrow( obj );
2527               if ( !subGeom->_is_nil() ) {
2528                 GEOM::ListOfLong_var subList = subGeom->GetSubShapeIndices();
2529                 if ( subList->length() == 1 && shapeID == subList[0] ) {
2530                   geom = subGeom;
2531                   break;
2532                 }
2533               }
2534             }
2535           }
2536         }
2537         if ( geom->_is_nil() ) {
2538           // explode
2539           GEOM::GEOM_IShapesOperations_wrap op = geomGen->GetIShapesOperations();
2540           if ( !op->_is_nil() )
2541             geom = op->GetSubShape( mainShape, shapeID );
2542         }
2543         else {
2544           geom->Register();
2545         }
2546         if ( !geom->_is_nil() ) {
2547           GeomObjectToShape( geom ); // let geom client remember the found shape
2548           return geom._retn();
2549         }
2550       }
2551     }
2552   }
2553   return GEOM::GEOM_Object::_nil();
2554 }
2555
2556 //================================================================================
2557 /*!
2558  *  SMESH_Gen_i::Concatenate
2559  *
2560  *  Concatenate the given meshes into one mesh
2561  */
2562 //================================================================================
2563
2564 SMESH::SMESH_Mesh_ptr
2565 SMESH_Gen_i::Concatenate(const SMESH::ListOfIDSources& theMeshesArray,
2566                          CORBA::Boolean                theUniteIdenticalGroups,
2567                          CORBA::Boolean                theMergeNodesAndElements,
2568                          CORBA::Double                 theMergeTolerance,
2569                          SMESH::SMESH_Mesh_ptr         theMeshToAppendTo)
2570   throw ( SALOME::SALOME_Exception )
2571 {
2572   return ConcatenateCommon(theMeshesArray,
2573                            theUniteIdenticalGroups,
2574                            theMergeNodesAndElements,
2575                            theMergeTolerance,
2576                            false,
2577                            theMeshToAppendTo);
2578 }
2579
2580 //================================================================================
2581 /*!
2582  *  SMESH_Gen_i::ConcatenateWithGroups
2583  *
2584  *  Concatenate the given meshes into one mesh
2585  *  Create the groups of all elements from initial meshes
2586  */
2587 //================================================================================
2588
2589 SMESH::SMESH_Mesh_ptr
2590 SMESH_Gen_i::ConcatenateWithGroups(const SMESH::ListOfIDSources& theMeshesArray,
2591                                    CORBA::Boolean                theUniteIdenticalGroups,
2592                                    CORBA::Boolean                theMergeNodesAndElements,
2593                                    CORBA::Double                 theMergeTolerance,
2594                                    SMESH::SMESH_Mesh_ptr         theMeshToAppendTo)
2595   throw ( SALOME::SALOME_Exception )
2596 {
2597   return ConcatenateCommon(theMeshesArray,
2598                            theUniteIdenticalGroups,
2599                            theMergeNodesAndElements,
2600                            theMergeTolerance,
2601                            true,
2602                            theMeshToAppendTo);
2603 }
2604
2605 //================================================================================
2606 /*!
2607  *  SMESH_Gen_i::ConcatenateCommon
2608  *
2609  *  Concatenate the given meshes into one mesh
2610  */
2611 //================================================================================
2612
2613 SMESH::SMESH_Mesh_ptr
2614 SMESH_Gen_i::ConcatenateCommon(const SMESH::ListOfIDSources& theMeshesArray,
2615                                CORBA::Boolean                theUniteIdenticalGroups,
2616                                CORBA::Boolean                theMergeNodesAndElements,
2617                                CORBA::Double                 theMergeTolerance,
2618                                CORBA::Boolean                theCommonGroups,
2619                                SMESH::SMESH_Mesh_ptr         theMeshToAppendTo)
2620   throw ( SALOME::SALOME_Exception )
2621 {
2622   std::unique_ptr< TPythonDump > pPythonDump( new TPythonDump );
2623   TPythonDump& pythonDump = *pPythonDump; // prevent dump of called methods
2624
2625   // create mesh if theMeshToAppendTo not provided
2626   SMESH::SMESH_Mesh_var newMesh;
2627   if ( CORBA::is_nil( theMeshToAppendTo ))
2628     newMesh = CreateEmptyMesh();
2629   else
2630     newMesh = SMESH::SMESH_Mesh::_duplicate( theMeshToAppendTo );
2631   SMESH_Mesh_i* newImpl = SMESH::DownCast<SMESH_Mesh_i*>( newMesh );
2632   if ( !newImpl ) return newMesh._retn();
2633   newImpl->Load();
2634
2635   ::SMESH_Mesh&   locMesh = newImpl->GetImpl();
2636   SMESHDS_Mesh* newMeshDS = locMesh.GetMeshDS();
2637
2638   typedef std::list<SMESH::SMESH_Group_var>          TListOfNewGroups;
2639   typedef std::pair<string, SMESH::ElementType >     TNameAndType;
2640   typedef std::map< TNameAndType, TListOfNewGroups > TGroupsMap;
2641   TGroupsMap       groupsMap;
2642   TListOfNewGroups listOfNewGroups;
2643
2644   if ( !CORBA::is_nil( theMeshToAppendTo ))
2645   {
2646     // fill groupsMap with existing groups
2647     SMESH::ListOfGroups_var groups = theMeshToAppendTo->GetGroups();
2648     for ( CORBA::ULong i = 0; i < groups->length(); ++i )
2649     {
2650       SMESH::SMESH_Group_var group = SMESH::SMESH_Group::_narrow( groups[ i ]);
2651       if ( !group->_is_nil() )
2652       {
2653         CORBA::String_var  name = group->GetName();
2654         SMESH::ElementType type = group->GetType();
2655         groupsMap[ TNameAndType( name.in(), type ) ].push_back( group );
2656       }
2657     }
2658   }
2659
2660   ::SMESH_MeshEditor               newEditor( &locMesh );
2661   ::SMESH_MeshEditor::ElemFeatures elemType;
2662
2663   // loop on sub-meshes
2664   for ( CORBA::ULong i = 0; i < theMeshesArray.length(); i++ )
2665   {
2666     if ( CORBA::is_nil( theMeshesArray[i] )) continue;
2667     SMESH::SMESH_Mesh_var initMesh = theMeshesArray[i]->GetMesh();
2668     SMESH_Mesh_i*         initImpl = SMESH::DownCast<SMESH_Mesh_i*>( initMesh );
2669     if ( !initImpl ) continue;
2670     if ( initMesh->_is_equivalent( theMeshToAppendTo ))
2671       continue;
2672     initImpl->Load();
2673
2674     // assure that IDs increment by one during iteration
2675     ::SMESH_Mesh& initLocMesh = initImpl->GetImpl();
2676     SMESHDS_Mesh*  initMeshDS = initLocMesh.GetMeshDS();
2677     if ( initMeshDS->MaxNodeID()    > initMeshDS->NbNodes() ||
2678          initMeshDS->MaxElementID() > initMeshDS->NbElements() )
2679     {
2680       initMeshDS->Modified();
2681       initMeshDS->CompactMesh();
2682     }
2683
2684     // remember nb of elements before filling in
2685     SMESH::long_array_var prevState =  newMesh->GetNbElementsByType();
2686
2687     // copy nodes
2688
2689     std::vector< const SMDS_MeshElement* > newNodes( initMeshDS->NbNodes() + 1, 0 );
2690     SMDS_ElemIteratorPtr elemIt = initImpl->GetElements( theMeshesArray[i], SMESH::NODE );
2691     while ( elemIt->more() )
2692     {
2693       SMESH_NodeXYZ node = elemIt->next();
2694       newNodes[ node->GetID() ] = newMeshDS->AddNode( node.X(), node.Y(), node.Z() );
2695     }
2696
2697     // copy elements
2698
2699     SMESH::array_of_ElementType_var srcElemTypes = theMeshesArray[i]->GetTypes();
2700     if ( srcElemTypes->length() == 1 && srcElemTypes[0] == SMESH::NODE ) // group of nodes
2701       continue;
2702     std::vector< const SMDS_MeshElement* > newElems( initMeshDS->NbElements() + 1, 0 );
2703     elemIt = initImpl->GetElements( theMeshesArray[i], SMESH::ALL );
2704     while ( elemIt->more() )
2705     {
2706       const SMDS_MeshElement* elem = elemIt->next();
2707       elemType.myNodes.resize( elem->NbNodes() );
2708
2709       SMDS_NodeIteratorPtr itNodes = elem->nodeIterator();
2710       for ( int k = 0; itNodes->more(); k++)
2711       {
2712         const SMDS_MeshNode* node = itNodes->next();
2713         elemType.myNodes[ k ] = static_cast< const SMDS_MeshNode*> ( newNodes[ node->GetID() ]);
2714       }
2715
2716       // creates a corresponding element on existent nodes in new mesh
2717       newElems[ elem->GetID() ] =
2718         newEditor.AddElement( elemType.myNodes, elemType.Init( elem, /*basicOnly=*/false ));
2719     }
2720     newEditor.ClearLastCreated(); // forget the history
2721
2722
2723     // create groups of just added elements
2724     SMESH::SMESH_Group_var newGroup;
2725     SMESH::ElementType     groupType;
2726     if ( theCommonGroups )
2727     {
2728       // type names
2729       const char* typeNames[] = { "All","Nodes","Edges","Faces","Volumes","0DElems","Balls" };
2730       { // check of typeNames: compilation failure mains that NB_ELEMENT_TYPES changed:
2731         const int nbNames = sizeof(typeNames) / sizeof(const char*);
2732         int _assert[( nbNames == SMESH::NB_ELEMENT_TYPES ) ? 2 : -1 ]; _assert[0]=_assert[1]=0;
2733       }
2734
2735       SMESH::long_array_var curState = newMesh->GetNbElementsByType();
2736
2737       for( groupType = SMESH::NODE;
2738            groupType < SMESH::NB_ELEMENT_TYPES;
2739            groupType = (SMESH::ElementType)( groupType + 1 ))
2740       {
2741         if ( curState[ groupType ] <= prevState[ groupType ])
2742           continue; // no elements of groupType added from the i-th mesh
2743
2744         // make a group name
2745         std::string groupName = "Gr";
2746         SALOMEDS::SObject_wrap meshSO = ObjectToSObject( theMeshesArray[i] );
2747         if ( meshSO ) {
2748           CORBA::String_var name = meshSO->GetName();
2749           groupName += name;
2750         }
2751         groupName += "_";
2752         groupName += typeNames[ groupType ];
2753
2754         // make and fill a group
2755         newGroup = newImpl->CreateGroup( groupType, groupName.c_str() );
2756         std::vector< const SMDS_MeshElement* > & elemVec =
2757           ( groupType == SMESH::NODE ) ? newNodes : newElems;
2758         if ( SMESH_Group_i* grp_i = SMESH::DownCast<SMESH_Group_i*>( newGroup ))
2759         {
2760           if ( SMESHDS_Group* grpDS = dynamic_cast<SMESHDS_Group*>( grp_i->GetGroupDS() ))
2761           {
2762             for ( size_t j = 0; j < elemVec.size(); ++j )
2763             {
2764               if ( elemVec[j] && elemVec[j]->GetType() == grpDS->GetType() )
2765                 grpDS->Add( elemVec[j] );
2766             }
2767           }
2768         }
2769         listOfNewGroups.clear();
2770         listOfNewGroups.push_back( newGroup );
2771         groupsMap.insert( std::make_pair( TNameAndType( groupName, groupType ),
2772                                           listOfNewGroups ));
2773       }
2774     }
2775
2776     if ( SMESH_Mesh_i* initImpl = SMESH::DownCast<SMESH_Mesh_i*>( theMeshesArray[i] ))
2777     {
2778       // copy groups
2779
2780       SMESH::SMESH_GroupBase_ptr group;
2781       CORBA::String_var          groupName;
2782       SMESH::long_array_var newIDs = new SMESH::long_array();
2783
2784       // loop on groups of a source mesh
2785       SMESH::ListOfGroups_var listOfGroups = initImpl->GetGroups();
2786       for ( CORBA::ULong iG = 0; iG < listOfGroups->length(); iG++ )
2787       {
2788         group     = listOfGroups[iG];
2789         groupType = group->GetType();
2790         groupName = group->GetName();
2791         std::string name = groupName.in();
2792
2793         // convert a list of IDs
2794         newIDs->length( group->Size() );
2795         std::vector< const SMDS_MeshElement* > & elemVec =
2796           ( groupType == SMESH::NODE ) ? newNodes : newElems;
2797         SMDS_ElemIteratorPtr itGrElems = initImpl->GetElements( group, SMESH::ALL );
2798         int nbElems = 0;
2799         while ( itGrElems->more() )
2800         {
2801           const SMDS_MeshElement*    elem = itGrElems->next();
2802           const SMDS_MeshElement* newElem = elemVec[ elem->GetID() ];
2803           if ( newElem )
2804             newIDs[ nbElems++ ] = newElem->GetID();
2805         }
2806         newIDs->length( nbElems );
2807
2808         // check that a current group name and type don't have identical ones in final mesh
2809         listOfNewGroups.clear();
2810         TNameAndType nameAndType( name, groupType );
2811         TGroupsMap::iterator anIter = groupsMap.find( nameAndType );
2812         if ( anIter == groupsMap.end() )
2813         {
2814           // add a new group in the mesh
2815           newGroup = newImpl->CreateGroup( groupType, groupName.in() );
2816           newGroup->Add( newIDs );
2817
2818           listOfNewGroups.push_back( newGroup );
2819           groupsMap.insert( std::make_pair( nameAndType, listOfNewGroups ));
2820         }
2821         else if ( theUniteIdenticalGroups )
2822         {
2823           // unite identical groups
2824           TListOfNewGroups& aNewGroups = anIter->second;
2825           aNewGroups.front()->Add( newIDs );
2826         }
2827         else
2828         {
2829           // rename identical groups
2830           newGroup = newImpl->CreateGroup( groupType, groupName );
2831           newGroup->Add( newIDs );
2832
2833           TListOfNewGroups& newGroups = anIter->second;
2834           std::string newGroupName;
2835           if ( newGroups.size() == 1 )
2836           {
2837             newGroupName = name + "_1";
2838             newGroups.front()->SetName( newGroupName.c_str() );
2839           }
2840           newGroupName = name + "_" + SMESH_Comment( newGroups.size() + 1 );
2841           newGroup->SetName( newGroupName.c_str() );
2842           newGroups.push_back( newGroup );
2843         }
2844       } // loop on groups
2845     } // if an IDSource is a mesh
2846   } //meshes loop
2847
2848   if ( theMergeNodesAndElements ) // merge nodes
2849   {
2850     TIDSortedNodeSet meshNodes; // no input nodes == treat all
2851     SMESH_MeshEditor::TListOfListOfNodes groupsOfNodes;
2852     newEditor.FindCoincidentNodes( meshNodes, theMergeTolerance, groupsOfNodes,
2853                                    /*SeparateCornersAndMedium=*/ false );
2854     newEditor.MergeNodes( groupsOfNodes );
2855     // merge elements
2856     newEditor.MergeEqualElements();
2857   }
2858
2859   // Update Python script
2860   pythonDump << newMesh << " = " << this
2861              << "." << ( theCommonGroups ? "ConcatenateWithGroups" : "Concatenate" ) << "( "
2862              << theMeshesArray << ", "
2863              << theUniteIdenticalGroups << ", "
2864              << theMergeNodesAndElements << ", "
2865              << TVar( theMergeTolerance ) << ", "
2866              << theMeshToAppendTo << " )";
2867
2868   pPythonDump.reset(); // enable python dump from GetGroups()
2869
2870   // 0020577: EDF 1164 SMESH: Bad dump of concatenate with create common groups
2871   if ( !newMesh->_is_nil() )
2872   {
2873     SMESH::ListOfGroups_var groups = newMesh->GetGroups();
2874   }
2875
2876   // IPAL21468 Change icon of compound because it need not be computed.
2877   SALOMEDS::SObject_wrap meshSO = ObjectToSObject( newMesh );
2878   SetPixMap( meshSO, "ICON_SMESH_TREE_MESH" );
2879
2880   newMeshDS->Modified();
2881
2882   return newMesh._retn();
2883 }
2884
2885 //================================================================================
2886 /*!
2887  * \brief Create a mesh by copying a part of another mesh
2888  *  \param meshPart - a part of mesh to copy
2889  *  \param toCopyGroups - to create in the new mesh groups
2890  *                        the copied elements belongs to
2891  *  \param toKeepIDs - to preserve IDs of the copied elements or not
2892  *  \retval SMESH::SMESH_Mesh_ptr - the new mesh
2893  */
2894 //================================================================================
2895
2896 SMESH::SMESH_Mesh_ptr SMESH_Gen_i::CopyMesh(SMESH::SMESH_IDSource_ptr meshPart,
2897                                             const char*               meshName,
2898                                             CORBA::Boolean            toCopyGroups,
2899                                             CORBA::Boolean            toKeepIDs)
2900   throw ( SALOME::SALOME_Exception )
2901 {
2902   Unexpect aCatch(SALOME_SalomeException);
2903
2904   TPythonDump* pyDump = new TPythonDump; // prevent dump from CreateMesh()
2905   std::unique_ptr<TPythonDump> pyDumpDeleter( pyDump );
2906
2907   // 1. Get source mesh
2908
2909   if ( CORBA::is_nil( meshPart ))
2910     THROW_SALOME_CORBA_EXCEPTION( "bad IDSource", SALOME::BAD_PARAM );
2911
2912   SMESH::SMESH_Mesh_var srcMesh = meshPart->GetMesh();
2913   SMESH_Mesh_i*       srcMesh_i = SMESH::DownCast<SMESH_Mesh_i*>( srcMesh );
2914   if ( !srcMesh_i )
2915     THROW_SALOME_CORBA_EXCEPTION( "bad mesh of IDSource", SALOME::BAD_PARAM );
2916
2917   SMESHDS_Mesh* srcMeshDS = srcMesh_i->GetImpl().GetMeshDS();
2918
2919   // 2. Make a new mesh
2920
2921   SMESH::SMESH_Mesh_var newMesh = CreateMesh(GEOM::GEOM_Object::_nil());
2922   SMESH_Mesh_i*       newMesh_i = SMESH::DownCast<SMESH_Mesh_i*>( newMesh );
2923   if ( !newMesh_i )
2924     THROW_SALOME_CORBA_EXCEPTION( "can't create a mesh", SALOME::INTERNAL_ERROR );
2925   SALOMEDS::SObject_wrap meshSO = ObjectToSObject( newMesh );
2926   if ( !meshSO->_is_nil() )
2927   {
2928     SetName( meshSO, meshName, "Mesh" );
2929     SetPixMap( meshSO, "ICON_SMESH_TREE_MESH_IMPORTED");
2930   }
2931   SMESHDS_Mesh* newMeshDS = newMesh_i->GetImpl().GetMeshDS();
2932   ::SMESH_MeshEditor editor( &newMesh_i->GetImpl() );
2933   ::SMESH_MeshEditor::ElemFeatures elemType;
2934
2935   // 3. Get elements to copy
2936
2937   SMDS_ElemIteratorPtr srcElemIt; SMDS_NodeIteratorPtr srcNodeIt;
2938   TIDSortedElemSet srcElems;
2939   SMESH::array_of_ElementType_var srcElemTypes = meshPart->GetTypes();
2940   if ( SMESH::DownCast<SMESH_Mesh_i*>( meshPart ))
2941   {
2942     srcMesh_i->Load();
2943     srcElemIt = srcMeshDS->elementsIterator();
2944     srcNodeIt = srcMeshDS->nodesIterator();
2945   }
2946   else
2947   {
2948     SMESH::long_array_var ids = meshPart->GetIDs();
2949     if ( srcElemTypes->length() == 1 && srcElemTypes[0] == SMESH::NODE ) // group of nodes
2950     {
2951       for ( CORBA::ULong i=0; i < ids->length(); i++ )
2952         if ( const SMDS_MeshElement * elem = srcMeshDS->FindNode( ids[i] ))
2953           srcElems.insert( elem );
2954     }
2955     else
2956     {
2957       for ( CORBA::ULong i = 0; i < ids->length(); i++ )
2958         if ( const SMDS_MeshElement * elem = srcMeshDS->FindElement( ids[i] ))
2959           srcElems.insert( elem );
2960     }
2961     if ( srcElems.empty() )
2962       return newMesh._retn();
2963
2964     typedef SMDS_SetIterator< SMDS_pElement, TIDSortedElemSet::const_iterator > ElIter;
2965     srcElemIt = SMDS_ElemIteratorPtr( new ElIter( srcElems.begin(), srcElems.end() ));
2966   }
2967
2968   // 4. Copy elements
2969
2970   typedef map<SMDS_pElement, SMDS_pElement, TIDCompare> TE2EMap;
2971   TE2EMap e2eMapByType[ SMDSAbs_NbElementTypes ];
2972   TE2EMap& n2nMap = e2eMapByType[ SMDSAbs_Node ];
2973   int iN;
2974   const SMDS_MeshNode *nSrc, *nTgt;
2975   vector< const SMDS_MeshNode* > nodes;
2976   while ( srcElemIt->more() )
2977   {
2978     const SMDS_MeshElement * elem = srcElemIt->next();
2979     // find / add nodes
2980     nodes.resize( elem->NbNodes());
2981     SMDS_ElemIteratorPtr nIt = elem->nodesIterator();
2982     if ( toKeepIDs ) {
2983       for ( iN = 0; nIt->more(); ++iN )
2984       {
2985         nSrc = static_cast<const SMDS_MeshNode*>( nIt->next() );
2986         nTgt = newMeshDS->FindNode( nSrc->GetID());
2987         if ( !nTgt )
2988           nTgt = newMeshDS->AddNodeWithID( nSrc->X(), nSrc->Y(), nSrc->Z(), nSrc->GetID());
2989         nodes[ iN ] = nTgt;
2990       }
2991     }
2992     else {
2993       for ( iN = 0; nIt->more(); ++iN )
2994       {
2995         nSrc = static_cast<const SMDS_MeshNode*>( nIt->next() );
2996         TE2EMap::iterator n2n = n2nMap.insert( make_pair( nSrc, SMDS_pNode(0) )).first;
2997         if ( !n2n->second )
2998           n2n->second = newMeshDS->AddNode( nSrc->X(), nSrc->Y(), nSrc->Z() );
2999         nodes[ iN ] = (const SMDS_MeshNode*) n2n->second;
3000       }
3001     }
3002     // add elements
3003     if ( elem->GetType() != SMDSAbs_Node )
3004     {
3005       elemType.Init( elem, /*basicOnly=*/false );
3006       if ( toKeepIDs ) elemType.SetID( elem->GetID() );
3007
3008       const SMDS_MeshElement * newElem = editor.AddElement( nodes, elemType );
3009       if ( toCopyGroups && !toKeepIDs )
3010         e2eMapByType[ elem->GetType() ].insert( make_pair( elem, newElem ));
3011     }
3012   } // while ( srcElemIt->more() )
3013
3014   // 4(b). Copy free nodes
3015
3016   if ( srcNodeIt && srcMeshDS->NbNodes() != newMeshDS->NbNodes() )
3017   {
3018     while ( srcNodeIt->more() )
3019     {
3020       nSrc = srcNodeIt->next();
3021       if ( nSrc->NbInverseElements() == 0 )
3022       {
3023         if ( toKeepIDs )
3024           nTgt = newMeshDS->AddNodeWithID( nSrc->X(), nSrc->Y(), nSrc->Z(), nSrc->GetID());
3025         else
3026           n2nMap[ nSrc ] = newMeshDS->AddNode( nSrc->X(), nSrc->Y(), nSrc->Z() );
3027       }
3028     }
3029   }
3030
3031   // 5. Copy groups
3032
3033   int nbNewGroups = 0;
3034   if ( toCopyGroups )
3035   {
3036     SMESH_Mesh::GroupIteratorPtr gIt = srcMesh_i->GetImpl().GetGroups();
3037     while ( gIt->more() )
3038     {
3039       SMESH_Group* group = gIt->next();
3040       const SMESHDS_GroupBase* groupDS = group->GetGroupDS();
3041
3042       // Check group type. We copy nodal groups containing nodes of copied element
3043       SMDSAbs_ElementType groupType = groupDS->GetType();
3044       if ( groupType != SMDSAbs_Node &&
3045            newMeshDS->GetMeshInfo().NbElements( groupType ) == 0 )
3046         continue; // group type differs from types of meshPart
3047
3048       // Find copied elements in the group
3049       vector< const SMDS_MeshElement* > groupElems;
3050       SMDS_ElemIteratorPtr eIt = groupDS->GetElements();
3051       if ( toKeepIDs )
3052       {
3053         const SMDS_MeshElement* foundElem;
3054         if ( groupType == SMDSAbs_Node )
3055         {
3056           while ( eIt->more() )
3057             if (( foundElem = newMeshDS->FindNode( eIt->next()->GetID() )))
3058               groupElems.push_back( foundElem );
3059         }
3060         else
3061         {
3062           while ( eIt->more() )
3063             if (( foundElem = newMeshDS->FindElement( eIt->next()->GetID() )))
3064               groupElems.push_back( foundElem );
3065         }
3066       }
3067       else
3068       {
3069         TE2EMap & e2eMap = e2eMapByType[ groupDS->GetType() ];
3070         if ( e2eMap.empty() ) continue;
3071         int minID = e2eMap.begin()->first->GetID();
3072         int maxID = e2eMap.rbegin()->first->GetID();
3073         TE2EMap::iterator e2e;
3074         while ( eIt->more() && groupElems.size() < e2eMap.size())
3075         {
3076           const SMDS_MeshElement* e = eIt->next();
3077           if ( e->GetID() < minID || e->GetID() > maxID ) continue;
3078           if ((e2e = e2eMap.find( e )) != e2eMap.end())
3079             groupElems.push_back( e2e->second );
3080         }
3081       }
3082       // Make a new group
3083       if ( !groupElems.empty() )
3084       {
3085         SMESH::SMESH_Group_var newGroupObj =
3086           newMesh->CreateGroup( SMESH::ElementType(groupType), group->GetName() );
3087         if ( SMESH_GroupBase_i* newGroup_i = SMESH::DownCast<SMESH_GroupBase_i*>( newGroupObj))
3088         {
3089           SMESHDS_GroupBase * newGroupDS = newGroup_i->GetGroupDS();
3090           SMDS_MeshGroup& smdsGroup = ((SMESHDS_Group*)newGroupDS)->SMDSGroup();
3091           for ( unsigned i = 0; i < groupElems.size(); ++i )
3092             smdsGroup.Add( groupElems[i] );
3093
3094           nbNewGroups++;
3095         }
3096       }
3097     }
3098   }
3099
3100   newMeshDS->Modified();
3101
3102   *pyDump << newMesh << " = " << this
3103           << ".CopyMesh( " << meshPart << ", "
3104           << "'" << meshName << "', "
3105           << toCopyGroups << ", "
3106           << toKeepIDs << ")";
3107
3108   pyDumpDeleter.reset(); // allow dump in GetGroups()
3109
3110   if ( nbNewGroups > 0 ) // dump created groups
3111     SMESH::ListOfGroups_var groups = newMesh->GetGroups();
3112
3113   return newMesh._retn();
3114 }
3115
3116
3117 namespace // utils for CopyMeshWithGeom()
3118 {
3119   typedef std::map< std::string, std::string >             TStr2StrMap;
3120   typedef std::map< std::string, std::set< std::string > > TStr2StrSetMap;
3121   typedef std::map< std::set<int>, int >                   TIdSet2IndexMap;
3122   typedef std::map< std::string, int >                     TName2IndexMap;
3123
3124   //================================================================================
3125   /*!
3126    * \brief Return a new sub-shape corresponding to an old one
3127    */
3128   //================================================================================
3129
3130   struct ShapeMapper
3131   {
3132     SMESH_Mesh_i* mySrcMesh_i;
3133     SMESH_Mesh_i* myNewMesh_i;
3134     SMESH_Gen_i*  myGen_i;
3135     bool          myToPublish;
3136     bool        &