src/SMESHClient/SMESH_Client.cxx

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