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