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