src/SMESHClient/SMESH_Client.cxx

   1 // Copyright (C) 2007-2022  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_Client.cxx
  23 //  Author : Pavel TELKOV
  24 //  Module : SMESH
  25
  26 #include "SMESH_Client.hxx"
  27
  28 #include "SMESHDS_Mesh.hxx"
  29 #include "SMESHDS_Script.hxx"
  30 #include "SMESH_Mesh.hxx"
  31
  32 #include "SALOME_NamingService.hxx"
  33 #include "SALOME_Fake_NamingService.hxx"
  34 #include "SALOME_LifeCycleCORBA.hxx"
  35
  36 #include <SALOMEconfig.h>
  37 #include <smIdType.hxx>
  38 #include CORBA_SERVER_HEADER(SALOME_Component)
  39 #include CORBA_SERVER_HEADER(SALOME_Exception)
  40
  41 #include "Basics_Utils.hxx"
  42 #include "KernelBasis.hxx"
  43 #include "utilities.h"
  44
  45 #ifdef WIN32
  46 #include <process.h>
  47 #else
  48 #include <unistd.h>
  49 #endif
  50
  51 #include <stdexcept>
  52 #include <memory>
  53
  54 #ifndef EXCEPTION
  55 #define EXCEPTION(TYPE, MSG) {\
  56   std::ostringstream aStream;\
  57   aStream<<__FILE__<<"["<<__LINE__<<"]::"<<MSG;\
  58   throw TYPE(aStream.str());\
  59 }
  60 #endif
  61
  62 #ifdef _DEBUG_
  63 static int MYDEBUG = 0;
  64 #else
  65 static int MYDEBUG = 0;
  66 #endif
  67
  68 namespace
  69 {
  70   using std::runtime_error;
  71
  72   //=======================================================================
  73   //function : FindNode
  74   //=======================================================================
  75   inline const SMDS_MeshNode* FindNode(const SMDS_Mesh* theMesh, int theId){
  76     if(const SMDS_MeshNode* anElem = theMesh->FindNode(theId)) return anElem;
  77     EXCEPTION(runtime_error,"SMDS_Mesh::FindNode - cannot find a SMDS_MeshNode for ID = "<<theId);
  78   }
  79
  80
  81   //=======================================================================
  82   //function : FindElement
  83   //=======================================================================
  84   inline const SMDS_MeshElement* FindElement(const SMDS_Mesh* theMesh, int theId){
  85     if(const SMDS_MeshElement* anElem = theMesh->FindElement(theId)) return anElem;
  86     EXCEPTION(runtime_error,"SMDS_Mesh::FindElement - cannot find a SMDS_MeshElement for ID = "<<theId);
  87   }
  88
  89
  90   //=======================================================================
  91   //function : AddNodesWithID
  92   //=======================================================================
  93   inline void AddNodesWithID(SMDS_Mesh* theMesh,
  94                              SMESH::log_array_var& theSeq,
  95                              SMESH::smIdType theId)
  96   {
  97     const SMESH::double_array& aCoords = theSeq[theId].coords;
  98     const SMESH::long_array& anIndexes = theSeq[theId].indexes;
  99     SMESH::smIdType anElemId = 0, aNbElems = theSeq[theId].number;
 100     if(3*aNbElems != (SMESH::smIdType) aCoords.length())
 101       EXCEPTION(runtime_error,"AddNodesWithID - 3*aNbElems != aCoords.length()");
 102     for(SMESH::smIdType aCoordId = 0; anElemId < aNbElems; anElemId++, aCoordId+=3){
 103       SMDS_MeshElement* anElem = theMesh->AddNodeWithID(aCoords[aCoordId],
 104                                                         aCoords[aCoordId+1],
 105                                                         aCoords[aCoordId+2],
 106                                                         anIndexes[anElemId]);
 107       if(!anElem)
 108         EXCEPTION(runtime_error,"SMDS_Mesh::FindElement - cannot AddNodeWithID for ID = "<<anElemId);
 109     }
 110   }
 111
 112
 113   //=======================================================================
 114   //function : Add0DElementsWithID
 115   //=======================================================================
 116   inline void Add0DElementsWithID(SMDS_Mesh* theMesh,
 117                                   SMESH::log_array_var& theSeq,
 118                                   SMESH::smIdType theId)
 119   {
 120     const SMESH::long_array& anIndexes = theSeq[theId].indexes;
 121     SMESH::smIdType anElemId = 0, aNbElems = theSeq[theId].number;
 122     if (2*aNbElems != (SMESH::smIdType) anIndexes.length())
 123       EXCEPTION(runtime_error,"AddEdgeWithID - 2*aNbElems != aCoords.length()");
 124     SMESH::smIdType anIndexId = 0;
 125     for (; anElemId < aNbElems; anElemId++, anIndexId+=2)
 126     {
 127       SMDS_MeshElement* anElem = theMesh->Add0DElementWithID(anIndexes[anIndexId+1],
 128                                                              anIndexes[anIndexId]);
 129       if (!anElem)
 130         EXCEPTION(runtime_error,"SMDS_Mesh::FindElement - cannot Add0DElementWithID for ID = "<<anElemId);
 131     }
 132   }
 133
 134
 135   //=======================================================================
 136   //function : AddBallsWithID
 137   //=======================================================================
 138   inline void AddBallsWithID(SMDS_Mesh*            theMesh,
 139                              SMESH::log_array_var& theSeq,
 140                              SMESH::smIdType       theId)
 141   {
 142     const SMESH::double_array& aDiameter = theSeq[theId].coords;
 143     const SMESH::long_array& anIndexes   = theSeq[theId].indexes;
 144     SMESH::smIdType anElemId = 0, aNbElems   = theSeq[theId].number;
 145     if (2*aNbElems != (SMESH::smIdType) anIndexes.length() )
 146       EXCEPTION(runtime_error,"AddEdgeWithID - 2*aNbElems != anIndexes.length()");
 147     if (aNbElems != (SMESH::smIdType) aDiameter.length())
 148       EXCEPTION(runtime_error,"AddEdgeWithID - aNbElems != aDiameter.length()");
 149     SMESH::smIdType anIndexId = 0;
 150     for (; anElemId < aNbElems; anElemId++, anIndexId+=2)
 151     {
 152       SMDS_MeshElement* anElem = theMesh->AddBallWithID(anIndexes[anIndexId+1],
 153                                                         aDiameter[anElemId],
 154                                                         anIndexes[anIndexId]);
 155       if (!anElem)
 156         EXCEPTION(runtime_error,"cannot SMDS_Mesh::AddBallsWithID for ID = "<<anElemId);
 157     }
 158   }
 159
 160
 161   //=======================================================================
 162   //function : AddEdgesWithID
 163   //=======================================================================
 164   inline void AddEdgesWithID(SMDS_Mesh* theMesh,
 165                              SMESH::log_array_var& theSeq,
 166                              SMESH::smIdType theId)
 167   {
 168     const SMESH::long_array& anIndexes = theSeq[theId].indexes;
 169     SMESH::smIdType anElemId = 0, aNbElems = theSeq[theId].number;
 170     if(3*aNbElems != (SMESH::smIdType) anIndexes.length())
 171       EXCEPTION(runtime_error,"AddEdgeWithID - 3*aNbElems != aCoords.length()");
 172     for(SMESH::smIdType anIndexId = 0; anElemId < aNbElems; anElemId++, anIndexId+=3){
 173       SMDS_MeshElement* anElem = theMesh->AddEdgeWithID(anIndexes[anIndexId+1],
 174                                                         anIndexes[anIndexId+2],
 175                                                         anIndexes[anIndexId]);
 176       if(!anElem)
 177         EXCEPTION(runtime_error,"SMDS_Mesh::FindElement - cannot AddEdgeWithID for ID = "<<anElemId);
 178     }
 179   }
 180
 181
 182   //=======================================================================
 183   //function : AddTriasWithID
 184   //=======================================================================
 185   inline void AddTriasWithID(SMDS_Mesh* theMesh,
 186                              SMESH::log_array_var& theSeq,
 187                              SMESH::smIdType theId)
 188   {
 189     const SMESH::long_array& anIndexes = theSeq[theId].indexes;
 190     SMESH::smIdType anElemId = 0, aNbElems = theSeq[theId].number;
 191     if(4*aNbElems != (SMESH::smIdType) anIndexes.length())
 192       EXCEPTION(runtime_error,"AddTriasWithID - 4*aNbElems != anIndexes.length()");
 193     for(SMESH::smIdType anIndexId = 0; anElemId < aNbElems; anElemId++, anIndexId+=4){
 194       SMDS_MeshElement* anElem = theMesh->AddFaceWithID(anIndexes[anIndexId+1],
 195                                                         anIndexes[anIndexId+2],
 196                                                         anIndexes[anIndexId+3],
 197                                                         anIndexes[anIndexId]);
 198       if(!anElem)
 199         EXCEPTION(runtime_error,"SMDS_Mesh::FindElement - cannot AddFaceWithID for ID = "<<anElemId);
 200     }
 201   }
 202
 203
 204   //=======================================================================
 205   //function : AddQuadsWithID
 206   //=======================================================================
 207   inline void AddQuadsWithID(SMDS_Mesh* theMesh,
 208                              SMESH::log_array_var theSeq,
 209                              SMESH::smIdType theId)
 210   {
 211     const SMESH::long_array& anIndexes = theSeq[theId].indexes;
 212     SMESH::smIdType anElemId = 0, aNbElems = theSeq[theId].number;
 213     if(5*aNbElems != (SMESH::smIdType) anIndexes.length())
 214       EXCEPTION(runtime_error,"AddQuadsWithID - 4*aNbElems != anIndexes.length()");
 215     for(SMESH::smIdType anIndexId = 0; anElemId < aNbElems; anElemId++, anIndexId+=5){
 216       SMDS_MeshElement* anElem = theMesh->AddFaceWithID(anIndexes[anIndexId+1],
 217                                                         anIndexes[anIndexId+2],
 218                                                         anIndexes[anIndexId+3],
 219                                                         anIndexes[anIndexId+4],
 220                                                         anIndexes[anIndexId]);
 221       if(!anElem)
 222         EXCEPTION(runtime_error,"SMDS_Mesh::FindElement - cannot AddFaceWithID for ID = "<<anElemId);
 223     }
 224   }
 225
 226
 227   //=======================================================================
 228   //function : AddPolygonsWithID
 229   //=======================================================================
 230   inline void AddPolygonsWithID(SMDS_Mesh* theMesh,
 231                                 SMESH::log_array_var& theSeq,
 232                                 SMESH::smIdType theId)
 233   {
 234     const SMESH::long_array& anIndexes = theSeq[theId].indexes;
 235     SMESH::smIdType anIndexId = 0, aNbElems = theSeq[theId].number;
 236
 237     for (SMESH::smIdType anElemId = 0; anElemId < aNbElems; anElemId++) {
 238       smIdType aFaceId = anIndexes[anIndexId++];
 239
 240       int aNbNodes = anIndexes[anIndexId++];
 241       std::vector<smIdType> nodes_ids (aNbNodes);
 242       for (int i = 0; i < aNbNodes; i++) {
 243         nodes_ids[i] = anIndexes[anIndexId++];
 244       }
 245
 246       SMDS_MeshElement* anElem = theMesh->AddPolygonalFaceWithID(nodes_ids, aFaceId);
 247       if (!anElem)
 248         EXCEPTION(runtime_error, "SMDS_Mesh::FindElement - cannot AddPolygonalFaceWithID for ID = "
 249                   << anElemId);
 250     }
 251   }
 252
 253
 254   //=======================================================================
 255   //function : AddQaudPolygonsWithID
 256   //=======================================================================
 257   inline void AddQuadPolygonsWithID(SMDS_Mesh* theMesh,
 258                                     SMESH::log_array_var& theSeq,
 259                                     SMESH::smIdType theId)
 260   {
 261     const SMESH::long_array& anIndexes = theSeq[theId].indexes;
 262     SMESH::smIdType anIndexId = 0, aNbElems = theSeq[theId].number;
 263
 264     for (SMESH::smIdType anElemId = 0; anElemId < aNbElems; anElemId++) {
 265       smIdType aFaceId = anIndexes[anIndexId++];
 266
 267       int aNbNodes = anIndexes[anIndexId++];
 268       std::vector<smIdType> nodes_ids (aNbNodes);
 269       for (int i = 0; i < aNbNodes; i++) {
 270         nodes_ids[i] = anIndexes[anIndexId++];
 271       }
 272
 273       SMDS_MeshElement* anElem = theMesh->AddQuadPolygonalFaceWithID(nodes_ids, aFaceId);
 274       if (!anElem)
 275         EXCEPTION(runtime_error, "SMDS_Mesh::FindElement - cannot AddQaudPolygonalFaceWithID for ID = "
 276                   << anElemId);
 277     }
 278   }
 279
 280
 281   //=======================================================================
 282   //function : AddTetrasWithID
 283   //=======================================================================
 284   inline void AddTetrasWithID(SMDS_Mesh* theMesh,
 285                               SMESH::log_array_var& theSeq,
 286                               SMESH::smIdType theId)
 287   {
 288     const SMESH::long_array& anIndexes = theSeq[theId].indexes;
 289     SMESH::smIdType anElemId = 0, aNbElems = theSeq[theId].number;
 290     if(5*aNbElems != (SMESH::smIdType) anIndexes.length())
 291       EXCEPTION(runtime_error,"AddTetrasWithID - 5*aNbElems != anIndexes.length()");
 292     for(SMESH::smIdType anIndexId = 0; anElemId < aNbElems; anElemId++, anIndexId+=5){
 293       SMDS_MeshElement* anElem = theMesh->AddVolumeWithID(anIndexes[anIndexId+1],
 294                                                           anIndexes[anIndexId+2],
 295                                                           anIndexes[anIndexId+3],
 296                                                           anIndexes[anIndexId+4],
 297                                                           anIndexes[anIndexId]);
 298       if(!anElem)
 299         EXCEPTION(runtime_error,"SMDS_Mesh::FindElement - cannot AddVolumeWithID for ID = "<<anElemId);
 300     }
 301   }
 302
 303
 304   //=======================================================================
 305   //function : AddPiramidsWithID
 306   //=======================================================================
 307   inline void AddPiramidsWithID(SMDS_Mesh* theMesh,
 308                                 SMESH::log_array_var& theSeq,
 309                                 SMESH::smIdType theId)
 310   {
 311     const SMESH::long_array& anIndexes = theSeq[theId].indexes;
 312     SMESH::smIdType anElemId = 0, aNbElems = theSeq[theId].number;
 313     if(6*aNbElems != (SMESH::smIdType) anIndexes.length())
 314       EXCEPTION(runtime_error,"AddPiramidsWithID - 6*aNbElems != anIndexes.length()");
 315     for(SMESH::smIdType anIndexId = 0; anElemId < aNbElems; anElemId++, anIndexId+=6){
 316       SMDS_MeshElement* anElem = theMesh->AddVolumeWithID(anIndexes[anIndexId+1],
 317                                                           anIndexes[anIndexId+2],
 318                                                           anIndexes[anIndexId+3],
 319                                                           anIndexes[anIndexId+4],
 320                                                           anIndexes[anIndexId+5],
 321                                                           anIndexes[anIndexId]);
 322       if(!anElem)
 323         EXCEPTION(runtime_error,"SMDS_Mesh::FindElement - cannot AddVolumeWithID for ID = "<<anElemId);
 324     }
 325   }
 326
 327
 328   //=======================================================================
 329   //function : AddPrismsWithID
 330   //=======================================================================
 331   inline void AddPrismsWithID(SMDS_Mesh* theMesh,
 332                               SMESH::log_array_var& theSeq,
 333                               SMESH::smIdType theId)
 334   {
 335     const SMESH::long_array& anIndexes = theSeq[theId].indexes;
 336     CORBA::Long anElemId = 0, aNbElems = theSeq[theId].number;
 337     if(7*aNbElems != (CORBA::Long) anIndexes.length())
 338       EXCEPTION(runtime_error,"AddPrismsWithID - 7*aNbElems != anIndexes.length()");
 339     for(CORBA::Long anIndexId = 0; anElemId < aNbElems; anElemId++, anIndexId+=7){
 340       SMDS_MeshElement* anElem = theMesh->AddVolumeWithID(anIndexes[anIndexId+1],
 341                                                           anIndexes[anIndexId+2],
 342                                                           anIndexes[anIndexId+3],
 343                                                           anIndexes[anIndexId+4],
 344                                                           anIndexes[anIndexId+5],
 345                                                           anIndexes[anIndexId+6],
 346                                                           anIndexes[anIndexId]);
 347       if(!anElem)
 348         EXCEPTION(runtime_error,"SMDS_Mesh::FindElement - cannot AddVolumeWithID for ID = "<<anElemId);
 349     }
 350   }
 351
 352
 353   //=======================================================================
 354   //function : AddHexasWithID
 355   //=======================================================================
 356   inline void AddHexasWithID(SMDS_Mesh* theMesh,
 357                              SMESH::log_array_var& theSeq,
 358                              CORBA::Long theId)
 359   {
 360     const SMESH::long_array& anIndexes = theSeq[theId].indexes;
 361     CORBA::Long anElemId = 0, aNbElems = theSeq[theId].number;
 362     if(9*aNbElems != (CORBA::Long) anIndexes.length())
 363       EXCEPTION(runtime_error,"AddHexasWithID - 9*aNbElems != anIndexes.length()");
 364     for(CORBA::Long anIndexId = 0; anElemId < aNbElems; anElemId++, anIndexId+=9){
 365       SMDS_MeshElement* anElem = theMesh->AddVolumeWithID(anIndexes[anIndexId+1],
 366                                                           anIndexes[anIndexId+2],
 367                                                           anIndexes[anIndexId+3],
 368                                                           anIndexes[anIndexId+4],
 369                                                           anIndexes[anIndexId+5],
 370                                                           anIndexes[anIndexId+6],
 371                                                           anIndexes[anIndexId+7],
 372                                                           anIndexes[anIndexId+8],
 373                                                           anIndexes[anIndexId]);
 374       if(!anElem)
 375         EXCEPTION(runtime_error,"SMDS_Mesh::FindElement - cannot AddVolumeWithID for ID = "<<anElemId);
 376     }
 377   }
 378
 379   //=======================================================================
 380   //function : AddHexPrismWithID
 381   //=======================================================================
 382   inline void AddHexPrismWithID(SMDS_Mesh* theMesh,
 383                                 SMESH::log_array_var& theSeq,
 384                                 CORBA::Long theId)
 385   {
 386     const SMESH::long_array& anIndexes = theSeq[theId].indexes;
 387     CORBA::Long anElemId = 0, aNbElems = theSeq[theId].number;
 388     if(13*aNbElems != (CORBA::Long) anIndexes.length())
 389       EXCEPTION(runtime_error,"AddHexPrismWithID - 13*aNbElems != anIndexes.length()");
 390     for(CORBA::Long anIndexId = 0; anElemId < aNbElems; anElemId++, anIndexId+=13){
 391       SMDS_MeshElement* anElem = theMesh->AddVolumeWithID(anIndexes[anIndexId+1],
 392                                                           anIndexes[anIndexId+2],
 393                                                           anIndexes[anIndexId+3],
 394                                                           anIndexes[anIndexId+4],
 395                                                           anIndexes[anIndexId+5],
 396                                                           anIndexes[anIndexId+6],
 397                                                           anIndexes[anIndexId+7],
 398                                                           anIndexes[anIndexId+8],
 399                                                           anIndexes[anIndexId+9],
 400                                                           anIndexes[anIndexId+10],
 401                                                           anIndexes[anIndexId+11],
 402                                                           anIndexes[anIndexId+12],
 403                                                           anIndexes[anIndexId]);
 404       if(!anElem)
 405         EXCEPTION(runtime_error,"AddHexPrismWithID - cannot AddVolumeWithID for ID = "<<anElemId);
 406     }
 407   }
 408
 409
 410   //=======================================================================
 411   //function : AddPolyhedronsWithID
 412   //=======================================================================
 413   inline void AddPolyhedronsWithID (SMDS_Mesh* theMesh,
 414                                     SMESH::log_array_var& theSeq,
 415                                     CORBA::Long theId)
 416   {
 417     const SMESH::long_array& anIndexes = theSeq[theId].indexes;
 418     CORBA::Long anIndexId = 0, aNbElems = theSeq[theId].number;
 419
 420     for (CORBA::Long anElemId = 0; anElemId < aNbElems; anElemId++) {
 421       smIdType aFaceId = anIndexes[anIndexId++];
 422
 423       int aNbNodes = anIndexes[anIndexId++];
 424       std::vector<smIdType> nodes_ids (aNbNodes);
 425       for (int i = 0; i < aNbNodes; i++) {
 426         nodes_ids[i] = anIndexes[anIndexId++];
 427       }
 428
 429       int aNbFaces = anIndexes[anIndexId++];
 430       std::vector<int> quantities (aNbFaces);
 431       for (int i = 0; i < aNbFaces; i++) {
 432         quantities[i] = anIndexes[anIndexId++];
 433       }
 434
 435       SMDS_MeshElement* anElem =
 436         theMesh->AddPolyhedralVolumeWithID(nodes_ids, quantities, aFaceId);
 437       if (!anElem)
 438         EXCEPTION(runtime_error, "SMDS_Mesh::FindElement - cannot AddPolyhedralVolumeWithID for ID = "
 439                   << anElemId);
 440     }
 441   }
 442
 443
 444   //=======================================================================
 445   //function : AddQuadEdgesWithID
 446   //=======================================================================
 447   inline void AddQuadEdgesWithID(SMDS_Mesh* theMesh,
 448                                  SMESH::log_array_var& theSeq,
 449                                  CORBA::Long theId)
 450   {
 451     const SMESH::long_array& anIndexes = theSeq[theId].indexes;
 452     CORBA::Long anElemId = 0, aNbElems = theSeq[theId].number;
 453     if(4*aNbElems != (CORBA::Long) anIndexes.length())
 454       EXCEPTION(runtime_error,"AddQuadEdgeWithID - 4*aNbElems != aCoords.length()");
 455     for(CORBA::Long anIndexId = 0; anElemId < aNbElems; anElemId++, anIndexId+=4){
 456       SMDS_MeshElement* anElem = theMesh->AddEdgeWithID(anIndexes[anIndexId+1],
 457                                                         anIndexes[anIndexId+2],
 458                                                         anIndexes[anIndexId+3],
 459                                                         anIndexes[anIndexId]);
 460       if(!anElem)
 461         EXCEPTION(runtime_error,"SMDS_Mesh::FindElement - cannot AddEdgeWithID for ID = "<<anElemId);
 462     }
 463   }
 464
 465
 466   //=======================================================================
 467   //function : AddQuadTriasWithID
 468   //=======================================================================
 469   inline void AddQuadTriasWithID(SMDS_Mesh* theMesh,
 470                                  SMESH::log_array_var& theSeq,
 471                                  CORBA::Long theId)
 472   {
 473     const SMESH::long_array& anIndexes = theSeq[theId].indexes;
 474     CORBA::Long anElemId = 0, aNbElems = theSeq[theId].number;
 475     if(7*aNbElems != (CORBA::Long) anIndexes.length())
 476       EXCEPTION(runtime_error,"AddQuadTriasWithID - 7*aNbElems != anIndexes.length()");
 477     for(CORBA::Long anIndexId = 0; anElemId < aNbElems; anElemId++, anIndexId+=7){
 478       SMDS_MeshElement* anElem = theMesh->AddFaceWithID(anIndexes[anIndexId+1],
 479                                                         anIndexes[anIndexId+2],
 480                                                         anIndexes[anIndexId+3],
 481                                                         anIndexes[anIndexId+4],
 482                                                         anIndexes[anIndexId+5],
 483                                                         anIndexes[anIndexId+6],
 484                                                         anIndexes[anIndexId]);
 485       if(!anElem)
 486         EXCEPTION(runtime_error,"SMDS_Mesh::FindElement - cannot AddFaceWithID for ID = "<<anElemId);
 487     }
 488   }
 489
 490
 491   //=======================================================================
 492   //function : AddQuadQuadsWithID
 493   //=======================================================================
 494   inline void AddQuadQuadsWithID(SMDS_Mesh* theMesh,
 495                                  SMESH::log_array_var theSeq,
 496                                  CORBA::Long theId)
 497   {
 498     const SMESH::long_array& anIndexes = theSeq[theId].indexes;
 499     CORBA::Long anElemId = 0, aNbElems = theSeq[theId].number;
 500     if(9*aNbElems != (CORBA::Long) anIndexes.length())
 501       EXCEPTION(runtime_error,"AddQuadQuadsWithID - 9*aNbElems != anIndexes.length()");
 502     for(CORBA::Long anIndexId = 0; anElemId < aNbElems; anElemId++, anIndexId+=9){
 503       SMDS_MeshElement* anElem = theMesh->AddFaceWithID(anIndexes[anIndexId+1],
 504                                                         anIndexes[anIndexId+2],
 505                                                         anIndexes[anIndexId+3],
 506                                                         anIndexes[anIndexId+4],
 507                                                         anIndexes[anIndexId+5],
 508                                                         anIndexes[anIndexId+6],
 509                                                         anIndexes[anIndexId+7],
 510                                                         anIndexes[anIndexId+8],
 511                                                         anIndexes[anIndexId]);
 512       if(!anElem)
 513         EXCEPTION(runtime_error,"SMDS_Mesh::FindElement - cannot AddFaceWithID for ID = "<<anElemId);
 514     }
 515   }
 516
 517   //=======================================================================
 518   //function : AddBiQuadQuadsWithID
 519   //=======================================================================
 520   inline void AddBiQuadQuadsWithID(SMDS_Mesh* theMesh,
 521                                    SMESH::log_array_var theSeq,
 522                                    CORBA::Long theId)
 523   {
 524     const SMESH::long_array& anIndexes = theSeq[theId].indexes;
 525     CORBA::Long anElemId = 0, aNbElems = theSeq[theId].number;
 526     if(10*aNbElems != (CORBA::Long) anIndexes.length())
 527       EXCEPTION(runtime_error,"AddBiQuadQuadsWithID - 10*aNbElems != anIndexes.length()");
 528     for(CORBA::Long anIndexId = 0; anElemId < aNbElems; anElemId++, anIndexId+=10){
 529       SMDS_MeshElement* anElem = theMesh->AddFaceWithID(anIndexes[anIndexId+1],
 530                                                         anIndexes[anIndexId+2],
 531                                                         anIndexes[anIndexId+3],
 532                                                         anIndexes[anIndexId+4],
 533                                                         anIndexes[anIndexId+5],
 534                                                         anIndexes[anIndexId+6],
 535                                                         anIndexes[anIndexId+7],
 536                                                         anIndexes[anIndexId+8],
 537                                                         anIndexes[anIndexId+9],
 538                                                         anIndexes[anIndexId]);
 539       if(!anElem)
 540         EXCEPTION(runtime_error,"AddBiQuadQuadsWithID() - cannot AddFaceWithID for ID = "<<anElemId);
 541     }
 542   }
 543
 544   //=======================================================================
 545   //function : AddBiQuadTriasWithID
 546   //=======================================================================
 547   inline void AddBiQuadTriasWithID(SMDS_Mesh* theMesh,
 548                                    SMESH::log_array_var theSeq,
 549                                    CORBA::Long theId)
 550   {
 551     const SMESH::long_array& anIndexes = theSeq[theId].indexes;
 552     CORBA::Long anElemId = 0, aNbElems = theSeq[theId].number;
 553     if(8*aNbElems != (CORBA::Long) anIndexes.length())
 554       EXCEPTION(runtime_error,"AddBiQuadTriasWithID - 8*aNbElems != anIndexes.length()");
 555     for(CORBA::Long anIndexId = 0; anElemId < aNbElems; anElemId++, anIndexId+=8){
 556       SMDS_MeshElement* anElem = theMesh->AddFaceWithID(anIndexes[anIndexId+1],
 557                                                         anIndexes[anIndexId+2],
 558                                                         anIndexes[anIndexId+3],
 559                                                         anIndexes[anIndexId+4],
 560                                                         anIndexes[anIndexId+5],
 561                                                         anIndexes[anIndexId+6],
 562                                                         anIndexes[anIndexId+7],
 563                                                         anIndexes[anIndexId]);
 564       if(!anElem)
 565         EXCEPTION(runtime_error,"AddBiQuadTriasWithID() - cannot AddFaceWithID for ID = "<<anElemId);
 566     }
 567   }
 568
 569
 570   //=======================================================================
 571   //function : AddQuadTetrasWithID
 572   //=======================================================================
 573   inline void AddQuadTetrasWithID(SMDS_Mesh* theMesh,
 574                                   SMESH::log_array_var& theSeq,
 575                                   CORBA::Long theId)
 576   {
 577     const SMESH::long_array& anIndexes = theSeq[theId].indexes;
 578     CORBA::Long anElemId = 0, aNbElems = theSeq[theId].number;
 579     if(11*aNbElems != (CORBA::Long) anIndexes.length())
 580       EXCEPTION(runtime_error,"AddQuadTetrasWithID - 11*aNbElems != anIndexes.length()");
 581     for(CORBA::Long anIndexId = 0; anElemId < aNbElems; anElemId++, anIndexId+=11){
 582       SMDS_MeshElement* anElem = theMesh->AddVolumeWithID(anIndexes[anIndexId+1],
 583                                                           anIndexes[anIndexId+2],
 584                                                           anIndexes[anIndexId+3],
 585                                                           anIndexes[anIndexId+4],
 586                                                           anIndexes[anIndexId+5],
 587                                                           anIndexes[anIndexId+6],
 588                                                           anIndexes[anIndexId+7],
 589                                                           anIndexes[anIndexId+8],
 590                                                           anIndexes[anIndexId+9],
 591                                                           anIndexes[anIndexId+10],
 592                                                           anIndexes[anIndexId]);
 593       if(!anElem)
 594         EXCEPTION(runtime_error,"SMDS_Mesh::FindElement - cannot AddVolumeWithID for ID = "<<anElemId);
 595     }
 596   }
 597
 598
 599   //=======================================================================
 600   //function : AddQuadPiramidsWithID
 601   //=======================================================================
 602   inline void AddQuadPiramidsWithID(SMDS_Mesh* theMesh,
 603                                     SMESH::log_array_var& theSeq,
 604                                     CORBA::Long theId)
 605   {
 606     const SMESH::long_array& anIndexes = theSeq[theId].indexes;
 607     CORBA::Long anElemId = 0, aNbElems = theSeq[theId].number;
 608     if(14*aNbElems != (CORBA::Long) anIndexes.length())
 609       EXCEPTION(runtime_error,"AddQuadPiramidsWithID - 14*aNbElems != anIndexes.length()");
 610     for(CORBA::Long anIndexId = 0; anElemId < aNbElems; anElemId++, anIndexId+=14){
 611       SMDS_MeshElement* anElem = theMesh->AddVolumeWithID(anIndexes[anIndexId+1],
 612                                                           anIndexes[anIndexId+2],
 613                                                           anIndexes[anIndexId+3],
 614                                                           anIndexes[anIndexId+4],
 615                                                           anIndexes[anIndexId+5],
 616                                                           anIndexes[anIndexId+6],
 617                                                           anIndexes[anIndexId+7],
 618                                                           anIndexes[anIndexId+8],
 619                                                           anIndexes[anIndexId+9],
 620                                                           anIndexes[anIndexId+10],
 621                                                           anIndexes[anIndexId+11],
 622                                                           anIndexes[anIndexId+12],
 623                                                           anIndexes[anIndexId+13],
 624                                                           anIndexes[anIndexId]);
 625       if(!anElem)
 626         EXCEPTION(runtime_error,"SMDS_Mesh::FindElement - cannot AddVolumeWithID for ID = "<<anElemId);
 627     }
 628   }
 629
 630
 631   //=======================================================================
 632   //function : AddQuadPentasWithID
 633   //=======================================================================
 634   inline void AddQuadPentasWithID(SMDS_Mesh* theMesh,
 635                                   SMESH::log_array_var& theSeq,
 636                                   CORBA::Long theId)
 637   {
 638     const SMESH::long_array& anIndexes = theSeq[theId].indexes;
 639     CORBA::Long anElemId = 0, aNbElems = theSeq[theId].number;
 640     if(16*aNbElems != (CORBA::Long) anIndexes.length())
 641       EXCEPTION(runtime_error,"AddQuadPentasWithID - 16*aNbElems != anIndexes.length()");
 642     for(CORBA::Long anIndexId = 0; anElemId < aNbElems; anElemId++, anIndexId+=16){
 643       SMDS_MeshElement* anElem = theMesh->AddVolumeWithID(anIndexes[anIndexId+1],
 644                                                           anIndexes[anIndexId+2],
 645                                                           anIndexes[anIndexId+3],
 646                                                           anIndexes[anIndexId+4],
 647                                                           anIndexes[anIndexId+5],
 648                                                           anIndexes[anIndexId+6],
 649                                                           anIndexes[anIndexId+7],
 650                                                           anIndexes[anIndexId+8],
 651                                                           anIndexes[anIndexId+9],
 652                                                           anIndexes[anIndexId+10],
 653                                                           anIndexes[anIndexId+11],
 654                                                           anIndexes[anIndexId+12],
 655                                                           anIndexes[anIndexId+13],
 656                                                           anIndexes[anIndexId+14],
 657                                                           anIndexes[anIndexId+15],
 658                                                           anIndexes[anIndexId]);
 659       if(!anElem)
 660         EXCEPTION(runtime_error,"SMDS_Mesh::FindElement - cannot AddVolumeWithID for ID = "<<anElemId);
 661     }
 662   }
 663
 664
 665   //=======================================================================
 666   //function : AddQuadHexasWithID
 667   //=======================================================================
 668   inline void AddQuadHexasWithID(SMDS_Mesh* theMesh,
 669                                  SMESH::log_array_var& theSeq,
 670                                  CORBA::Long theId)
 671   {
 672     const SMESH::long_array& anIndexes = theSeq[theId].indexes;
 673     CORBA::Long anElemId = 0, aNbElems = theSeq[theId].number;
 674     if(21*aNbElems != (CORBA::Long) anIndexes.length())
 675       EXCEPTION(runtime_error,"AddQuadHexasWithID - 21*aNbElems != anIndexes.length()");
 676     for(CORBA::Long anIndexId = 0; anElemId < aNbElems; anElemId++, anIndexId+=21){
 677       SMDS_MeshElement* anElem = theMesh->AddVolumeWithID(anIndexes[anIndexId+1],
 678                                                           anIndexes[anIndexId+2],
 679                                                           anIndexes[anIndexId+3],
 680                                                           anIndexes[anIndexId+4],
 681                                                           anIndexes[anIndexId+5],
 682                                                           anIndexes[anIndexId+6],
 683                                                           anIndexes[anIndexId+7],
 684                                                           anIndexes[anIndexId+8],
 685                                                           anIndexes[anIndexId+9],
 686                                                           anIndexes[anIndexId+10],
 687                                                           anIndexes[anIndexId+11],
 688                                                           anIndexes[anIndexId+12],
 689                                                           anIndexes[anIndexId+13],
 690                                                           anIndexes[anIndexId+14],
 691                                                           anIndexes[anIndexId+15],
 692                                                           anIndexes[anIndexId+16],
 693                                                           anIndexes[anIndexId+17],
 694                                                           anIndexes[anIndexId+18],
 695                                                           anIndexes[anIndexId+19],
 696                                                           anIndexes[anIndexId+20],
 697                                                           anIndexes[anIndexId]);
 698       if(!anElem)
 699         EXCEPTION(runtime_error,"SMDS_Mesh::FindElement - cannot AddVolumeWithID for ID = "<<anElemId);
 700     }
 701   }
 702
 703   //=======================================================================
 704   //function : AddTriQuadHexasWithID
 705   //=======================================================================
 706   inline void AddTriQuadHexasWithID(SMDS_Mesh* theMesh,
 707                                     SMESH::log_array_var& theSeq,
 708                                     CORBA::Long theId)
 709   {
 710     const SMESH::long_array& anIndexes = theSeq[theId].indexes;
 711     CORBA::Long anElemId = 0, aNbElems = theSeq[theId].number;
 712     if(28*aNbElems != (CORBA::Long) anIndexes.length())
 713       EXCEPTION(runtime_error,"AddTriQuadHexasWithID - 28*aNbElems != anIndexes.length()");
 714     for(CORBA::Long anIndexId = 0; anElemId < aNbElems; anElemId++, anIndexId+=28){
 715       SMDS_MeshElement* anElem = theMesh->AddVolumeWithID(anIndexes[anIndexId+1],
 716                                                           anIndexes[anIndexId+2],
 717                                                           anIndexes[anIndexId+3],
 718                                                           anIndexes[anIndexId+4],
 719                                                           anIndexes[anIndexId+5],
 720                                                           anIndexes[anIndexId+6],
 721                                                           anIndexes[anIndexId+7],
 722                                                           anIndexes[anIndexId+8],
 723                                                           anIndexes[anIndexId+9],
 724                                                           anIndexes[anIndexId+10],
 725                                                           anIndexes[anIndexId+11],
 726                                                           anIndexes[anIndexId+12],
 727                                                           anIndexes[anIndexId+13],
 728                                                           anIndexes[anIndexId+14],
 729                                                           anIndexes[anIndexId+15],
 730                                                           anIndexes[anIndexId+16],
 731                                                           anIndexes[anIndexId+17],
 732                                                           anIndexes[anIndexId+18],
 733                                                           anIndexes[anIndexId+19],
 734                                                           anIndexes[anIndexId+20],
 735                                                           anIndexes[anIndexId+21],
 736                                                           anIndexes[anIndexId+22],
 737                                                           anIndexes[anIndexId+23],
 738                                                           anIndexes[anIndexId+24],
 739                                                           anIndexes[anIndexId+25],
 740                                                           anIndexes[anIndexId+26],
 741                                                           anIndexes[anIndexId+27],
 742                                                           anIndexes[anIndexId]);
 743       if(!anElem)
 744         EXCEPTION(runtime_error,"AddTriQuadHexasWithID() - cannot AddVolumeWithID for ID = "<<anElemId);
 745     }
 746   }
 747
 748
 749   //=======================================================================
 750   //function : ChangePolyhedronNodes
 751   //=======================================================================
 752   inline void ChangePolyhedronNodes (SMDS_Mesh*            theMesh,
 753                                      SMESH::log_array_var& theSeq,
 754                                      CORBA::Long           theId)
 755   {
 756     const SMESH::long_array& anIndexes = theSeq[theId].indexes;
 757     CORBA::Long iind = 0, aNbElems = theSeq[theId].number;
 758
 759     for (CORBA::Long anElemId = 0; anElemId < aNbElems; anElemId++)
 760     {
 761       // find element
 762       const SMDS_MeshElement* elem = FindElement(theMesh, anIndexes[iind++]);
 763       // nb nodes
 764       int nbNodes = anIndexes[iind++];
 765       // nodes
 766       std::vector<const SMDS_MeshNode*> aNodes (nbNodes);
 767       for (int iNode = 0; iNode < nbNodes; iNode++) {
 768         aNodes[iNode] = FindNode(theMesh, anIndexes[iind++]);
 769       }
 770       // nb faces
 771       int nbFaces = anIndexes[iind++];
 772       // quantities
 773       std::vector<int> quantities (nbFaces);
 774       for (int iFace = 0; iFace < nbFaces; iFace++) {
 775         quantities[iFace] = anIndexes[iind++];
 776       }
 777       // change
 778       theMesh->ChangePolyhedronNodes(elem, aNodes, quantities);
 779     }
 780   }
 781 }
 782
 783 //=======================================================================
 784 SMESH::SMESH_Gen_var
 785 SMESH_Client::GetSMESHGen(CORBA::ORB_ptr theORB,
 786                           CORBA::Boolean& theIsEmbeddedMode)
 787 {
 788   static SMESH::SMESH_Gen_var aMeshGen;
 789
 790   if(CORBA::is_nil(aMeshGen.in()))
 791   {
 792 #ifdef WIN32
 793     long aClientPID = (long)_getpid();
 794 #else
 795     long aClientPID =  (long)getpid();
 796 #endif
 797
 798     std::unique_ptr<SALOME_NamingService_Abstract> aNamingService;
 799     if(getSSLMode())
 800     {
 801       aNamingService.reset(new SALOME_Fake_NamingService);
 802     }
 803     else
 804     {
 805       aNamingService.reset(new SALOME_NamingService(theORB));
 806     }
 807     SALOME_LifeCycleCORBA aLifeCycleCORBA(aNamingService.get());
 808     Engines::EngineComponent_var aComponent = aLifeCycleCORBA.FindOrLoad_Component("FactoryServer","SMESH");
 809     aMeshGen = SMESH::SMESH_Gen::_narrow(aComponent);
 810
 811     std::string aClientHostName = Kernel_Utils::GetHostname();
 812     Engines::Container_var aServerContainer = aMeshGen->GetContainerRef();
 813     CORBA::String_var aServerHostName = aServerContainer->getHostName();
 814     CORBA::Long aServerPID = aServerContainer->getPID();
 815     aMeshGen->SetEmbeddedMode((aClientPID == aServerPID) && (aClientHostName == aServerHostName.in()));
 816   }
 817   theIsEmbeddedMode = aMeshGen->IsEmbeddedMode();
 818   return aMeshGen;
 819 }
 820
 821
 822 //=======================================================================
 823 // function : Create()
 824 // purpose  :
 825 //=======================================================================
 826 SMESH_Client::SMESH_Client(CORBA::ORB_ptr theORB,
 827                            SMESH::SMESH_Mesh_ptr theMesh):
 828   myMeshServer(SMESH::SMESH_Mesh::_duplicate(theMesh)),
 829   mySMESHDSMesh(NULL),
 830   mySMDSMesh(NULL)
 831 {
 832   if ( MYDEBUG ) MESSAGE("SMESH_Client::SMESH_Client");
 833   myMeshServer->Register();
 834
 835   CORBA::Boolean anIsEmbeddedMode;
 836   GetSMESHGen(theORB,anIsEmbeddedMode);
 837   if(anIsEmbeddedMode){
 838     if ( MYDEBUG ) MESSAGE("Info: The same process, update mesh by pointer ");
 839     // just set client mesh pointer to server mesh pointer
 840     //SMESH_Mesh* aMesh = reinterpret_cast<SMESH_Mesh*>(theMesh->GetMeshPtr());
 841     CORBA::LongLong pointeur = theMesh->GetMeshPtr();
 842     if( MYDEBUG ) MESSAGE("SMESH_Client::SMESH_Client pointeur "<<pointeur);
 843     SMESH_Mesh* aMesh = reinterpret_cast<SMESH_Mesh*> (pointeur);
 844     if ( MYDEBUG ) MESSAGE("SMESH_Client::SMESH_Client aMesh "<<aMesh);
 845     //if(aMesh->GetMeshDS()->IsEmbeddedMode()){
 846     if(anIsEmbeddedMode){
 847       mySMESHDSMesh = aMesh->GetMeshDS();
 848       mySMDSMesh = mySMESHDSMesh;
 849     }
 850   }
 851   if(!mySMDSMesh)
 852     mySMDSMesh = new SMDS_Mesh();
 853 }
 854
 855
 856 //=================================================================================
 857 // function : ~SMESH_Client
 858 // purpose  : Destructor
 859 //=================================================================================
 860 SMESH_Client::~SMESH_Client()
 861 {
 862   myMeshServer->UnRegister();
 863   if(!mySMESHDSMesh)
 864     delete mySMDSMesh;
 865 }
 866
 867
 868 //=================================================================================
 869 SMDS_Mesh*
 870 SMESH_Client::GetMesh() const
 871 {
 872   return mySMDSMesh;
 873 }
 874
 875
 876 //=================================================================================
 877 SMDS_Mesh*
 878 SMESH_Client::operator->() const
 879 {
 880   return GetMesh();
 881 }
 882
 883
 884 //=================================================================================
 885 SMESH::SMESH_Mesh_ptr
 886 SMESH_Client::GetMeshServer()
 887 {
 888   return myMeshServer.in();
 889 }
 890
 891
 892 //=================================================================================
 893 // function : SMESH_Client
 894 // purpose  : Update mesh
 895 //=================================================================================
 896 bool
 897 SMESH_Client::Update(bool theIsClear)
 898 {
 899   bool anIsModified = true;
 900   if(mySMESHDSMesh)
 901   {
 902     if ( MYDEBUG ) MESSAGE("Update mySMESHDSMesh");
 903     SMESHDS_Script* aScript = mySMESHDSMesh->GetScript();
 904     anIsModified = aScript->IsModified();
 905     aScript->SetModified(false);
 906   }
 907   else
 908   {
 909     if ( MYDEBUG ) MESSAGE("Update CORBA");
 910     SMESH::log_array_var aSeq = myMeshServer->GetLog( theIsClear );
 911     CORBA::Long aLength = aSeq->length();
 912     anIsModified = aLength > 0;
 913     if ( MYDEBUG ) MESSAGE( "Update: length of the script is "<<aLength );
 914
 915     if ( !anIsModified )
 916       return false;
 917
 918     // update client mesh structure by logged changes commands
 919     try
 920     {
 921       for ( CORBA::Long anId = 0; anId < aLength; anId++)
 922       {
 923         const SMESH::double_array& aCoords = aSeq[anId].coords;
 924         const SMESH::long_array& anIndexes = aSeq[anId].indexes;
 925         CORBA::Long anElemId = 0, aNbElems = aSeq[anId].number;
 926         CORBA::Long aCommand = aSeq[anId].commandType;
 927
 928         switch(aCommand)
 929         {
 930         case SMESH::ADD_NODE             : AddNodesWithID      ( mySMDSMesh, aSeq, anId ); break;
 931         case SMESH::ADD_EDGE             : AddEdgesWithID      ( mySMDSMesh, aSeq, anId ); break;
 932         case SMESH::ADD_TRIANGLE         : AddTriasWithID      ( mySMDSMesh, aSeq, anId ); break;
 933         case SMESH::ADD_QUADRANGLE       : AddQuadsWithID      ( mySMDSMesh, aSeq, anId ); break;
 934         case SMESH::ADD_POLYGON          : AddPolygonsWithID   ( mySMDSMesh, aSeq, anId ); break;
 935         case SMESH::ADD_TETRAHEDRON      : AddTetrasWithID     ( mySMDSMesh, aSeq, anId ); break;
 936         case SMESH::ADD_PYRAMID          : AddPiramidsWithID   ( mySMDSMesh, aSeq, anId ); break;
 937         case SMESH::ADD_PRISM            : AddPrismsWithID     ( mySMDSMesh, aSeq, anId ); break;
 938         case SMESH::ADD_HEXAHEDRON       : AddHexasWithID      ( mySMDSMesh, aSeq, anId ); break;
 939         case SMESH::ADD_HEXAGONAL_PRISM  : AddHexPrismWithID   ( mySMDSMesh, aSeq, anId ); break;
 940         case SMESH::ADD_POLYHEDRON       : AddPolyhedronsWithID( mySMDSMesh, aSeq, anId ); break;
 941         case SMESH::ADD_ELEM0D           : Add0DElementsWithID ( mySMDSMesh, aSeq, anId ); break;
 942         case SMESH::ADD_BALL             : AddBallsWithID      ( mySMDSMesh, aSeq, anId ); break;
 943
 944         case SMESH::ADD_QUADEDGE         : AddQuadEdgesWithID   ( mySMDSMesh, aSeq, anId ); break;
 945         case SMESH::ADD_QUADTRIANGLE     : AddQuadTriasWithID   ( mySMDSMesh, aSeq, anId ); break;
 946         case SMESH::ADD_QUADQUADRANGLE   : AddQuadQuadsWithID   ( mySMDSMesh, aSeq, anId ); break;
 947         case SMESH::ADD_QUADPOLYGON      : AddQuadPolygonsWithID( mySMDSMesh, aSeq, anId ); break;
 948         case SMESH::ADD_QUADTETRAHEDRON  : AddQuadTetrasWithID  ( mySMDSMesh, aSeq, anId ); break;
 949         case SMESH::ADD_QUADPYRAMID      : AddQuadPiramidsWithID( mySMDSMesh, aSeq, anId ); break;
 950         case SMESH::ADD_QUADPENTAHEDRON  : AddQuadPentasWithID  ( mySMDSMesh, aSeq, anId ); break;
 951         case SMESH::ADD_QUADHEXAHEDRON   : AddQuadHexasWithID   ( mySMDSMesh, aSeq, anId ); break;
 952
 953         case SMESH::ADD_BIQUAD_QUADRANGLE: AddBiQuadQuadsWithID ( mySMDSMesh, aSeq, anId ); break;
 954         case SMESH::ADD_BIQUAD_TRIANGLE  : AddBiQuadTriasWithID ( mySMDSMesh, aSeq, anId ); break;
 955         case SMESH::ADD_TRIQUAD_HEXA     : AddTriQuadHexasWithID( mySMDSMesh, aSeq, anId ); break;
 956
 957         case SMESH::CLEAR_MESH:
 958           mySMDSMesh->Clear();
 959           break;
 960
 961         case SMESH::REMOVE_NODE:
 962           for( ; anElemId < aNbElems; anElemId++ )
 963             mySMDSMesh->RemoveNode( FindNode( mySMDSMesh, anIndexes[anElemId] ) );
 964         break;
 965
 966         case SMESH::REMOVE_ELEMENT:
 967           for( ; anElemId < aNbElems; anElemId++ )
 968             mySMDSMesh->RemoveElement( FindElement( mySMDSMesh, anIndexes[anElemId] ) );
 969         break;
 970
 971         case SMESH::MOVE_NODE:
 972           for(CORBA::Long aCoordId=0; anElemId < aNbElems; anElemId++, aCoordId+=3)
 973           {
 974             SMDS_MeshNode* node =
 975               const_cast<SMDS_MeshNode*>( FindNode( mySMDSMesh, anIndexes[anElemId] ));
 976             node->setXYZ( aCoords[aCoordId], aCoords[aCoordId+1], aCoords[aCoordId+2] );
 977           }
 978         break;
 979
 980         case SMESH::CHANGE_ELEMENT_NODES:
 981           for ( CORBA::Long i = 0; anElemId < aNbElems; anElemId++ )
 982           {
 983             // find element
 984             const SMDS_MeshElement* elem = FindElement( mySMDSMesh, anIndexes[i++] );
 985             // nb nodes
 986             int nbNodes = anIndexes[i++];
 987             // nodes
 988             //ASSERT( nbNodes < 9 );
 989             std::vector<const SMDS_MeshNode*> aNodes( nbNodes );
 990             for ( int iNode = 0; iNode < nbNodes; iNode++ )
 991               aNodes[ iNode ] = FindNode( mySMDSMesh, anIndexes[i++] );
 992             // change
 993             mySMDSMesh->ChangeElementNodes( elem, &aNodes[0], nbNodes );
 994           }
 995           break;
 996
 997         case SMESH::CHANGE_POLYHEDRON_NODES:
 998           ChangePolyhedronNodes(mySMDSMesh, aSeq, anId);
 999           break;
1000         case SMESH::RENUMBER:
1001           // for(CORBA::Long i=0; anElemId < aNbElems; anElemId++, i+=3)
1002           // {
1003           //   mySMDSMesh->Renumber( anIndexes[i], anIndexes[i+1], anIndexes[i+2] );
1004           // }
1005           break;
1006
1007         default:;
1008         }
1009       }
1010     }
1011     catch ( SALOME::SALOME_Exception& exc )
1012     {
1013       INFOS("Following exception was cought:\n\t"<<exc.details.text);
1014     }
1015     catch( const std::exception& exc)
1016     {
1017       INFOS("Following exception was cought:\n\t"<<exc.what());
1018     }
1019     catch(...)
1020     {
1021       INFOS("Unknown exception was cought !!!");
1022     }
1023
1024     if ( MYDEBUG && mySMDSMesh )
1025     {
1026       MESSAGE("Update - mySMDSMesh->NbNodes() = "<<mySMDSMesh->NbNodes());
1027       MESSAGE("Update - mySMDSMesh->Nb0DElements() = "<<mySMDSMesh->Nb0DElements());
1028       MESSAGE("Update - mySMDSMesh->NbEdges() = "<<mySMDSMesh->NbEdges());
1029       MESSAGE("Update - mySMDSMesh->NbFaces() = "<<mySMDSMesh->NbFaces());
1030       MESSAGE("Update - mySMDSMesh->NbVolumes() = "<<mySMDSMesh->NbVolumes());
1031     }
1032   } // end of update mesh by log script
1033
1034   return anIsModified;
1035 }