src/SMESHClient/SMESH_Client.cxx

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