src/SMESHClient/SMESH_Client.cxx

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