src/SMESHClient/SMESH_Client.cxx

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