src/SMESHClient/SMESH_Client.cxx

   1 // Copyright (C) 2007-2013  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.
  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 WNT
  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 != 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 != 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 != anIndexes.length() )
 139       EXCEPTION(runtime_error,"AddEdgeWithID - 2*aNbElems != anIndexes.length()");
 140     if (aNbElems != 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 != 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 != 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 != 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 : AddTetrasWithID
 249   //=======================================================================
 250   inline void AddTetrasWithID(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 anElemId = 0, aNbElems = theSeq[theId].number;
 256     if(5*aNbElems != anIndexes.length())
 257       EXCEPTION(runtime_error,"AddTetrasWithID - 5*aNbElems != anIndexes.length()");
 258     for(CORBA::Long anIndexId = 0; anElemId < aNbElems; anElemId++, anIndexId+=5){
 259       SMDS_MeshElement* anElem = theMesh->AddVolumeWithID(anIndexes[anIndexId+1],
 260                                                           anIndexes[anIndexId+2],
 261                                                           anIndexes[anIndexId+3],
 262                                                           anIndexes[anIndexId+4],
 263                                                           anIndexes[anIndexId]);
 264       if(!anElem)
 265         EXCEPTION(runtime_error,"SMDS_Mesh::FindElement - cannot AddVolumeWithID for ID = "<<anElemId);
 266     }
 267   }
 268
 269
 270   //=======================================================================
 271   //function : AddPiramidsWithID
 272   //=======================================================================
 273   inline void AddPiramidsWithID(SMDS_Mesh* theMesh,
 274                                 SMESH::log_array_var& theSeq,
 275                                 CORBA::Long theId)
 276   {
 277     const SMESH::long_array& anIndexes = theSeq[theId].indexes;
 278     CORBA::Long anElemId = 0, aNbElems = theSeq[theId].number;
 279     if(6*aNbElems != anIndexes.length())
 280       EXCEPTION(runtime_error,"AddPiramidsWithID - 6*aNbElems != anIndexes.length()");
 281     for(CORBA::Long anIndexId = 0; anElemId < aNbElems; anElemId++, anIndexId+=6){
 282       SMDS_MeshElement* anElem = theMesh->AddVolumeWithID(anIndexes[anIndexId+1],
 283                                                           anIndexes[anIndexId+2],
 284                                                           anIndexes[anIndexId+3],
 285                                                           anIndexes[anIndexId+4],
 286                                                           anIndexes[anIndexId+5],
 287                                                           anIndexes[anIndexId]);
 288       if(!anElem)
 289         EXCEPTION(runtime_error,"SMDS_Mesh::FindElement - cannot AddVolumeWithID for ID = "<<anElemId);
 290     }
 291   }
 292
 293
 294   //=======================================================================
 295   //function : AddPrismsWithID
 296   //=======================================================================
 297   inline void AddPrismsWithID(SMDS_Mesh* theMesh,
 298                               SMESH::log_array_var& theSeq,
 299                               CORBA::Long theId)
 300   {
 301     const SMESH::long_array& anIndexes = theSeq[theId].indexes;
 302     CORBA::Long anElemId = 0, aNbElems = theSeq[theId].number;
 303     if(7*aNbElems != anIndexes.length())
 304       EXCEPTION(runtime_error,"AddPrismsWithID - 7*aNbElems != anIndexes.length()");
 305     for(CORBA::Long anIndexId = 0; anElemId < aNbElems; anElemId++, anIndexId+=7){
 306       SMDS_MeshElement* anElem = theMesh->AddVolumeWithID(anIndexes[anIndexId+1],
 307                                                           anIndexes[anIndexId+2],
 308                                                           anIndexes[anIndexId+3],
 309                                                           anIndexes[anIndexId+4],
 310                                                           anIndexes[anIndexId+5],
 311                                                           anIndexes[anIndexId+6],
 312                                                           anIndexes[anIndexId]);
 313       if(!anElem)
 314         EXCEPTION(runtime_error,"SMDS_Mesh::FindElement - cannot AddVolumeWithID for ID = "<<anElemId);
 315     }
 316   }
 317
 318
 319   //=======================================================================
 320   //function : AddHexasWithID
 321   //=======================================================================
 322   inline void AddHexasWithID(SMDS_Mesh* theMesh,
 323                              SMESH::log_array_var& theSeq,
 324                              CORBA::Long theId)
 325   {
 326     const SMESH::long_array& anIndexes = theSeq[theId].indexes;
 327     CORBA::Long anElemId = 0, aNbElems = theSeq[theId].number;
 328     if(9*aNbElems != anIndexes.length())
 329       EXCEPTION(runtime_error,"AddHexasWithID - 9*aNbElems != anIndexes.length()");
 330     for(CORBA::Long anIndexId = 0; anElemId < aNbElems; anElemId++, anIndexId+=9){
 331       SMDS_MeshElement* anElem = theMesh->AddVolumeWithID(anIndexes[anIndexId+1],
 332                                                           anIndexes[anIndexId+2],
 333                                                           anIndexes[anIndexId+3],
 334                                                           anIndexes[anIndexId+4],
 335                                                           anIndexes[anIndexId+5],
 336                                                           anIndexes[anIndexId+6],
 337                                                           anIndexes[anIndexId+7],
 338                                                           anIndexes[anIndexId+8],
 339                                                           anIndexes[anIndexId]);
 340       if(!anElem)
 341         EXCEPTION(runtime_error,"SMDS_Mesh::FindElement - cannot AddVolumeWithID for ID = "<<anElemId);
 342     }
 343   }
 344
 345   //=======================================================================
 346   //function : AddHexPrismWithID
 347   //=======================================================================
 348   inline void AddHexPrismWithID(SMDS_Mesh* theMesh,
 349                                 SMESH::log_array_var& theSeq,
 350                                 CORBA::Long theId)
 351   {
 352     const SMESH::long_array& anIndexes = theSeq[theId].indexes;
 353     CORBA::Long anElemId = 0, aNbElems = theSeq[theId].number;
 354     if(13*aNbElems != anIndexes.length())
 355       EXCEPTION(runtime_error,"AddHexPrismWithID - 13*aNbElems != anIndexes.length()");
 356     for(CORBA::Long anIndexId = 0; anElemId < aNbElems; anElemId++, anIndexId+=13){
 357       SMDS_MeshElement* anElem = theMesh->AddVolumeWithID(anIndexes[anIndexId+1],
 358                                                           anIndexes[anIndexId+2],
 359                                                           anIndexes[anIndexId+3],
 360                                                           anIndexes[anIndexId+4],
 361                                                           anIndexes[anIndexId+5],
 362                                                           anIndexes[anIndexId+6],
 363                                                           anIndexes[anIndexId+7],
 364                                                           anIndexes[anIndexId+8],
 365                                                           anIndexes[anIndexId+9],
 366                                                           anIndexes[anIndexId+10],
 367                                                           anIndexes[anIndexId+11],
 368                                                           anIndexes[anIndexId+12],
 369                                                           anIndexes[anIndexId]);
 370       if(!anElem)
 371         EXCEPTION(runtime_error,"AddHexPrismWithID - cannot AddVolumeWithID for ID = "<<anElemId);
 372     }
 373   }
 374
 375
 376   //=======================================================================
 377   //function : AddPolyhedronsWithID
 378   //=======================================================================
 379   inline void AddPolyhedronsWithID (SMDS_Mesh* theMesh,
 380                                     SMESH::log_array_var& theSeq,
 381                                     CORBA::Long theId)
 382   {
 383     const SMESH::long_array& anIndexes = theSeq[theId].indexes;
 384     CORBA::Long anIndexId = 0, aNbElems = theSeq[theId].number;
 385
 386     for (CORBA::Long anElemId = 0; anElemId < aNbElems; anElemId++) {
 387       int aFaceId = anIndexes[anIndexId++];
 388
 389       int aNbNodes = anIndexes[anIndexId++];
 390       std::vector<int> nodes_ids (aNbNodes);
 391       for (int i = 0; i < aNbNodes; i++) {
 392         nodes_ids[i] = anIndexes[anIndexId++];
 393       }
 394
 395       int aNbFaces = anIndexes[anIndexId++];
 396       std::vector<int> quantities (aNbFaces);
 397       for (int i = 0; i < aNbFaces; i++) {
 398         quantities[i] = anIndexes[anIndexId++];
 399       }
 400
 401       SMDS_MeshElement* anElem =
 402         theMesh->AddPolyhedralVolumeWithID(nodes_ids, quantities, aFaceId);
 403       if (!anElem)
 404         EXCEPTION(runtime_error, "SMDS_Mesh::FindElement - cannot AddPolyhedralVolumeWithID for ID = "
 405                   << anElemId);
 406     }
 407   }
 408
 409
 410   //=======================================================================
 411   //function : AddQuadEdgesWithID
 412   //=======================================================================
 413   inline void AddQuadEdgesWithID(SMDS_Mesh* theMesh,
 414                                  SMESH::log_array_var& theSeq,
 415                                  CORBA::Long theId)
 416   {
 417     const SMESH::long_array& anIndexes = theSeq[theId].indexes;
 418     CORBA::Long anElemId = 0, aNbElems = theSeq[theId].number;
 419     if(4*aNbElems != anIndexes.length())
 420       EXCEPTION(runtime_error,"AddQuadEdgeWithID - 4*aNbElems != aCoords.length()");
 421     for(CORBA::Long anIndexId = 0; anElemId < aNbElems; anElemId++, anIndexId+=4){
 422       SMDS_MeshElement* anElem = theMesh->AddEdgeWithID(anIndexes[anIndexId+1],
 423                                                         anIndexes[anIndexId+2],
 424                                                         anIndexes[anIndexId+3],
 425                                                         anIndexes[anIndexId]);
 426       if(!anElem)
 427         EXCEPTION(runtime_error,"SMDS_Mesh::FindElement - cannot AddEdgeWithID for ID = "<<anElemId);
 428     }
 429   }
 430
 431
 432   //=======================================================================
 433   //function : AddQuadTriasWithID
 434   //=======================================================================
 435   inline void AddQuadTriasWithID(SMDS_Mesh* theMesh,
 436                                  SMESH::log_array_var& theSeq,
 437                                  CORBA::Long theId)
 438   {
 439     const SMESH::long_array& anIndexes = theSeq[theId].indexes;
 440     CORBA::Long anElemId = 0, aNbElems = theSeq[theId].number;
 441     if(7*aNbElems != anIndexes.length())
 442       EXCEPTION(runtime_error,"AddQuadTriasWithID - 7*aNbElems != anIndexes.length()");
 443     for(CORBA::Long anIndexId = 0; anElemId < aNbElems; anElemId++, anIndexId+=7){
 444       SMDS_MeshElement* anElem = theMesh->AddFaceWithID(anIndexes[anIndexId+1],
 445                                                         anIndexes[anIndexId+2],
 446                                                         anIndexes[anIndexId+3],
 447                                                         anIndexes[anIndexId+4],
 448                                                         anIndexes[anIndexId+5],
 449                                                         anIndexes[anIndexId+6],
 450                                                         anIndexes[anIndexId]);
 451       if(!anElem)
 452         EXCEPTION(runtime_error,"SMDS_Mesh::FindElement - cannot AddFaceWithID for ID = "<<anElemId);
 453     }
 454   }
 455
 456
 457   //=======================================================================
 458   //function : AddQuadQuadsWithID
 459   //=======================================================================
 460   inline void AddQuadQuadsWithID(SMDS_Mesh* theMesh,
 461                                  SMESH::log_array_var theSeq,
 462                                  CORBA::Long theId)
 463   {
 464     const SMESH::long_array& anIndexes = theSeq[theId].indexes;
 465     CORBA::Long anElemId = 0, aNbElems = theSeq[theId].number;
 466     if(9*aNbElems != anIndexes.length())
 467       EXCEPTION(runtime_error,"AddQuadQuadsWithID - 9*aNbElems != anIndexes.length()");
 468     for(CORBA::Long anIndexId = 0; anElemId < aNbElems; anElemId++, anIndexId+=9){
 469       SMDS_MeshElement* anElem = theMesh->AddFaceWithID(anIndexes[anIndexId+1],
 470                                                         anIndexes[anIndexId+2],
 471                                                         anIndexes[anIndexId+3],
 472                                                         anIndexes[anIndexId+4],
 473                                                         anIndexes[anIndexId+5],
 474                                                         anIndexes[anIndexId+6],
 475                                                         anIndexes[anIndexId+7],
 476                                                         anIndexes[anIndexId+8],
 477                                                         anIndexes[anIndexId]);
 478       if(!anElem)
 479         EXCEPTION(runtime_error,"SMDS_Mesh::FindElement - cannot AddFaceWithID for ID = "<<anElemId);
 480     }
 481   }
 482
 483   //=======================================================================
 484   //function : AddBiQuadQuadsWithID
 485   //=======================================================================
 486   inline void AddBiQuadQuadsWithID(SMDS_Mesh* theMesh,
 487                                    SMESH::log_array_var theSeq,
 488                                    CORBA::Long theId)
 489   {
 490     const SMESH::long_array& anIndexes = theSeq[theId].indexes;
 491     CORBA::Long anElemId = 0, aNbElems = theSeq[theId].number;
 492     if(10*aNbElems != anIndexes.length())
 493       EXCEPTION(runtime_error,"AddBiQuadQuadsWithID - 10*aNbElems != anIndexes.length()");
 494     for(CORBA::Long anIndexId = 0; anElemId < aNbElems; anElemId++, anIndexId+=10){
 495       SMDS_MeshElement* anElem = theMesh->AddFaceWithID(anIndexes[anIndexId+1],
 496                                                         anIndexes[anIndexId+2],
 497                                                         anIndexes[anIndexId+3],
 498                                                         anIndexes[anIndexId+4],
 499                                                         anIndexes[anIndexId+5],
 500                                                         anIndexes[anIndexId+6],
 501                                                         anIndexes[anIndexId+7],
 502                                                         anIndexes[anIndexId+8],
 503                                                         anIndexes[anIndexId+9],
 504                                                         anIndexes[anIndexId]);
 505       if(!anElem)
 506         EXCEPTION(runtime_error,"AddBiQuadQuadsWithID() - cannot AddFaceWithID for ID = "<<anElemId);
 507     }
 508   }
 509
 510
 511   //=======================================================================
 512   //function : AddQuadTetrasWithID
 513   //=======================================================================
 514   inline void AddQuadTetrasWithID(SMDS_Mesh* theMesh,
 515                                   SMESH::log_array_var& theSeq,
 516                                   CORBA::Long theId)
 517   {
 518     const SMESH::long_array& anIndexes = theSeq[theId].indexes;
 519     CORBA::Long anElemId = 0, aNbElems = theSeq[theId].number;
 520     if(11*aNbElems != anIndexes.length())
 521       EXCEPTION(runtime_error,"AddQuadTetrasWithID - 11*aNbElems != anIndexes.length()");
 522     for(CORBA::Long anIndexId = 0; anElemId < aNbElems; anElemId++, anIndexId+=11){
 523       SMDS_MeshElement* anElem = theMesh->AddVolumeWithID(anIndexes[anIndexId+1],
 524                                                           anIndexes[anIndexId+2],
 525                                                           anIndexes[anIndexId+3],
 526                                                           anIndexes[anIndexId+4],
 527                                                           anIndexes[anIndexId+5],
 528                                                           anIndexes[anIndexId+6],
 529                                                           anIndexes[anIndexId+7],
 530                                                           anIndexes[anIndexId+8],
 531                                                           anIndexes[anIndexId+9],
 532                                                           anIndexes[anIndexId+10],
 533                                                           anIndexes[anIndexId]);
 534       if(!anElem)
 535         EXCEPTION(runtime_error,"SMDS_Mesh::FindElement - cannot AddVolumeWithID for ID = "<<anElemId);
 536     }
 537   }
 538
 539
 540   //=======================================================================
 541   //function : AddQuadPiramidsWithID
 542   //=======================================================================
 543   inline void AddQuadPiramidsWithID(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(14*aNbElems != anIndexes.length())
 550       EXCEPTION(runtime_error,"AddQuadPiramidsWithID - 14*aNbElems != anIndexes.length()");
 551     for(CORBA::Long anIndexId = 0; anElemId < aNbElems; anElemId++, anIndexId+=14){
 552       SMDS_MeshElement* anElem = theMesh->AddVolumeWithID(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+8],
 560                                                           anIndexes[anIndexId+9],
 561                                                           anIndexes[anIndexId+10],
 562                                                           anIndexes[anIndexId+11],
 563                                                           anIndexes[anIndexId+12],
 564                                                           anIndexes[anIndexId+13],
 565                                                           anIndexes[anIndexId]);
 566       if(!anElem)
 567         EXCEPTION(runtime_error,"SMDS_Mesh::FindElement - cannot AddVolumeWithID for ID = "<<anElemId);
 568     }
 569   }
 570
 571
 572   //=======================================================================
 573   //function : AddQuadPentasWithID
 574   //=======================================================================
 575   inline void AddQuadPentasWithID(SMDS_Mesh* theMesh,
 576                                   SMESH::log_array_var& theSeq,
 577                                   CORBA::Long theId)
 578   {
 579     const SMESH::long_array& anIndexes = theSeq[theId].indexes;
 580     CORBA::Long anElemId = 0, aNbElems = theSeq[theId].number;
 581     if(16*aNbElems != anIndexes.length())
 582       EXCEPTION(runtime_error,"AddQuadPentasWithID - 16*aNbElems != anIndexes.length()");
 583     for(CORBA::Long anIndexId = 0; anElemId < aNbElems; anElemId++, anIndexId+=16){
 584       SMDS_MeshElement* anElem = theMesh->AddVolumeWithID(anIndexes[anIndexId+1],
 585                                                           anIndexes[anIndexId+2],
 586                                                           anIndexes[anIndexId+3],
 587                                                           anIndexes[anIndexId+4],
 588                                                           anIndexes[anIndexId+5],
 589                                                           anIndexes[anIndexId+6],
 590                                                           anIndexes[anIndexId+7],
 591                                                           anIndexes[anIndexId+8],
 592                                                           anIndexes[anIndexId+9],
 593                                                           anIndexes[anIndexId+10],
 594                                                           anIndexes[anIndexId+11],
 595                                                           anIndexes[anIndexId+12],
 596                                                           anIndexes[anIndexId+13],
 597                                                           anIndexes[anIndexId+14],
 598                                                           anIndexes[anIndexId+15],
 599                                                           anIndexes[anIndexId]);
 600       if(!anElem)
 601         EXCEPTION(runtime_error,"SMDS_Mesh::FindElement - cannot AddVolumeWithID for ID = "<<anElemId);
 602     }
 603   }
 604
 605
 606   //=======================================================================
 607   //function : AddQuadHexasWithID
 608   //=======================================================================
 609   inline void AddQuadHexasWithID(SMDS_Mesh* theMesh,
 610                                  SMESH::log_array_var& theSeq,
 611                                  CORBA::Long theId)
 612   {
 613     const SMESH::long_array& anIndexes = theSeq[theId].indexes;
 614     CORBA::Long anElemId = 0, aNbElems = theSeq[theId].number;
 615     if(21*aNbElems != anIndexes.length())
 616       EXCEPTION(runtime_error,"AddQuadHexasWithID - 21*aNbElems != anIndexes.length()");
 617     for(CORBA::Long anIndexId = 0; anElemId < aNbElems; anElemId++, anIndexId+=21){
 618       SMDS_MeshElement* anElem = theMesh->AddVolumeWithID(anIndexes[anIndexId+1],
 619                                                           anIndexes[anIndexId+2],
 620                                                           anIndexes[anIndexId+3],
 621                                                           anIndexes[anIndexId+4],
 622                                                           anIndexes[anIndexId+5],
 623                                                           anIndexes[anIndexId+6],
 624                                                           anIndexes[anIndexId+7],
 625                                                           anIndexes[anIndexId+8],
 626                                                           anIndexes[anIndexId+9],
 627                                                           anIndexes[anIndexId+10],
 628                                                           anIndexes[anIndexId+11],
 629                                                           anIndexes[anIndexId+12],
 630                                                           anIndexes[anIndexId+13],
 631                                                           anIndexes[anIndexId+14],
 632                                                           anIndexes[anIndexId+15],
 633                                                           anIndexes[anIndexId+16],
 634                                                           anIndexes[anIndexId+17],
 635                                                           anIndexes[anIndexId+18],
 636                                                           anIndexes[anIndexId+19],
 637                                                           anIndexes[anIndexId+20],
 638                                                           anIndexes[anIndexId]);
 639       if(!anElem)
 640         EXCEPTION(runtime_error,"SMDS_Mesh::FindElement - cannot AddVolumeWithID for ID = "<<anElemId);
 641     }
 642   }
 643
 644   //=======================================================================
 645   //function : AddTriQuadHexasWithID
 646   //=======================================================================
 647   inline void AddTriQuadHexasWithID(SMDS_Mesh* theMesh,
 648                                     SMESH::log_array_var& theSeq,
 649                                     CORBA::Long theId)
 650   {
 651     const SMESH::long_array& anIndexes = theSeq[theId].indexes;
 652     CORBA::Long anElemId = 0, aNbElems = theSeq[theId].number;
 653     if(28*aNbElems != anIndexes.length())
 654       EXCEPTION(runtime_error,"AddTriQuadHexasWithID - 28*aNbElems != anIndexes.length()");
 655     for(CORBA::Long anIndexId = 0; anElemId < aNbElems; anElemId++, anIndexId+=28){
 656       SMDS_MeshElement* anElem = theMesh->AddVolumeWithID(anIndexes[anIndexId+1],
 657                                                           anIndexes[anIndexId+2],
 658                                                           anIndexes[anIndexId+3],
 659                                                           anIndexes[anIndexId+4],
 660                                                           anIndexes[anIndexId+5],
 661                                                           anIndexes[anIndexId+6],
 662                                                           anIndexes[anIndexId+7],
 663                                                           anIndexes[anIndexId+8],
 664                                                           anIndexes[anIndexId+9],
 665                                                           anIndexes[anIndexId+10],
 666                                                           anIndexes[anIndexId+11],
 667                                                           anIndexes[anIndexId+12],
 668                                                           anIndexes[anIndexId+13],
 669                                                           anIndexes[anIndexId+14],
 670                                                           anIndexes[anIndexId+15],
 671                                                           anIndexes[anIndexId+16],
 672                                                           anIndexes[anIndexId+17],
 673                                                           anIndexes[anIndexId+18],
 674                                                           anIndexes[anIndexId+19],
 675                                                           anIndexes[anIndexId+20],
 676                                                           anIndexes[anIndexId+21],
 677                                                           anIndexes[anIndexId+22],
 678                                                           anIndexes[anIndexId+23],
 679                                                           anIndexes[anIndexId+24],
 680                                                           anIndexes[anIndexId+25],
 681                                                           anIndexes[anIndexId+26],
 682                                                           anIndexes[anIndexId+27],
 683                                                           anIndexes[anIndexId]);
 684       if(!anElem)
 685         EXCEPTION(runtime_error,"AddTriQuadHexasWithID() - cannot AddVolumeWithID for ID = "<<anElemId);
 686     }
 687   }
 688
 689
 690   //=======================================================================
 691   //function : ChangePolyhedronNodes
 692   //=======================================================================
 693   inline void ChangePolyhedronNodes (SMDS_Mesh* theMesh,
 694                                      SMESH::log_array_var& theSeq,
 695                                      CORBA::Long theId)
 696   {
 697     const SMESH::long_array& anIndexes = theSeq[theId].indexes;
 698     CORBA::Long iind = 0, aNbElems = theSeq[theId].number;
 699
 700     for (CORBA::Long anElemId = 0; anElemId < aNbElems; anElemId++)
 701     {
 702       // find element
 703       const SMDS_MeshElement* elem = FindElement(theMesh, anIndexes[iind++]);
 704       // nb nodes
 705       int nbNodes = anIndexes[iind++];
 706       // nodes
 707       std::vector<const SMDS_MeshNode*> aNodes (nbNodes);
 708       for (int iNode = 0; iNode < nbNodes; iNode++) {
 709         aNodes[iNode] = FindNode(theMesh, anIndexes[iind++]);
 710       }
 711       // nb faces
 712       int nbFaces = anIndexes[iind++];
 713       // quantities
 714       std::vector<int> quantities (nbFaces);
 715       for (int iFace = 0; iFace < nbFaces; iFace++) {
 716         quantities[iFace] = anIndexes[iind++];
 717       }
 718       // change
 719       theMesh->ChangePolyhedronNodes(elem, aNodes, quantities);
 720     }
 721   }
 722 }
 723
 724 //=======================================================================
 725 SMESH::SMESH_Gen_var
 726 SMESH_Client::GetSMESHGen(CORBA::ORB_ptr theORB,
 727                           CORBA::Boolean& theIsEmbeddedMode)
 728 {
 729   static SMESH::SMESH_Gen_var aMeshGen;
 730
 731   if(CORBA::is_nil(aMeshGen.in())){
 732 #ifdef WNT
 733     long aClientPID = (long)_getpid();
 734 #else
 735     long aClientPID =  (long)getpid();
 736 #endif
 737
 738     SALOME_NamingService aNamingService(theORB);
 739     SALOME_LifeCycleCORBA aLifeCycleCORBA(&aNamingService);
 740     Engines::EngineComponent_var aComponent = aLifeCycleCORBA.FindOrLoad_Component("FactoryServer","SMESH");
 741     aMeshGen = SMESH::SMESH_Gen::_narrow(aComponent);
 742
 743     std::string aClientHostName = Kernel_Utils::GetHostname();
 744     Engines::Container_var aServerContainer = aMeshGen->GetContainerRef();
 745     CORBA::String_var aServerHostName = aServerContainer->getHostName();
 746     CORBA::Long aServerPID = aServerContainer->getPID();
 747     aMeshGen->SetEmbeddedMode((aClientPID == aServerPID) && (aClientHostName == aServerHostName.in()));
 748   }
 749   theIsEmbeddedMode = aMeshGen->IsEmbeddedMode();
 750
 751   return aMeshGen;
 752 }
 753
 754
 755 //=======================================================================
 756 // function : Create()
 757 // purpose  :
 758 //=======================================================================
 759 SMESH_Client::SMESH_Client(CORBA::ORB_ptr theORB,
 760                            SMESH::SMESH_Mesh_ptr theMesh):
 761   myMeshServer(SMESH::SMESH_Mesh::_duplicate(theMesh)),
 762   mySMESHDSMesh(NULL),
 763   mySMDSMesh(NULL)
 764 {
 765   MESSAGE("SMESH_Client::SMESH_Client");
 766   myMeshServer->Register();
 767
 768   CORBA::Boolean anIsEmbeddedMode;
 769   GetSMESHGen(theORB,anIsEmbeddedMode);
 770   if(anIsEmbeddedMode){
 771     if ( MYDEBUG )
 772       MESSAGE("Info: The same process, update mesh by pointer ");
 773     // just set client mesh pointer to server mesh pointer
 774     //SMESH_Mesh* aMesh = reinterpret_cast<SMESH_Mesh*>(theMesh->GetMeshPtr());
 775     CORBA::LongLong pointeur = theMesh->GetMeshPtr();
 776     if( MYDEBUG )
 777       MESSAGE("SMESH_Client::SMESH_Client pointeur "<<pointeur);
 778     SMESH_Mesh* aMesh = reinterpret_cast<SMESH_Mesh*> (pointeur);
 779     if ( MYDEBUG )
 780       MESSAGE("SMESH_Client::SMESH_Client aMesh "<<aMesh);
 781     //if(aMesh->GetMeshDS()->IsEmbeddedMode()){
 782     if(anIsEmbeddedMode){
 783       mySMESHDSMesh = aMesh->GetMeshDS();
 784       mySMDSMesh = mySMESHDSMesh;
 785     }
 786   }
 787   if(!mySMDSMesh)
 788     mySMDSMesh = new SMDS_Mesh();
 789 }
 790
 791
 792 //=================================================================================
 793 // function : ~SMESH_Client
 794 // purpose  : Destructor
 795 //=================================================================================
 796 SMESH_Client::~SMESH_Client()
 797 {
 798   myMeshServer->UnRegister();
 799   if(!mySMESHDSMesh)
 800     delete mySMDSMesh;
 801 }
 802
 803
 804 //=================================================================================
 805 SMDS_Mesh*
 806 SMESH_Client::GetMesh() const
 807 {
 808   return mySMDSMesh;
 809 }
 810
 811
 812 //=================================================================================
 813 SMDS_Mesh*
 814 SMESH_Client::operator->() const
 815 {
 816   return GetMesh();
 817 }
 818
 819
 820 //=================================================================================
 821 SMESH::SMESH_Mesh_ptr
 822 SMESH_Client::GetMeshServer()
 823 {
 824   return myMeshServer.in();
 825 }
 826
 827
 828 //=================================================================================
 829 // function : SMESH_Client
 830 // purpose  : Update mesh
 831 //=================================================================================
 832 bool
 833 SMESH_Client::Update(bool theIsClear)
 834 {
 835   bool anIsModified = true;
 836   if(mySMESHDSMesh){
 837         MESSAGE("Update mySMESHDSMesh");
 838     SMESHDS_Script* aScript = mySMESHDSMesh->GetScript();
 839     anIsModified = aScript->IsModified();
 840     aScript->SetModified(false);
 841   }else{
 842         MESSAGE("Update CORBA");
 843     SMESH::log_array_var aSeq = myMeshServer->GetLog( theIsClear );
 844     CORBA::Long aLength = aSeq->length();
 845     anIsModified = aLength > 0;
 846     if( MYDEBUG )
 847       MESSAGE( "Update: length of the script is "<<aLength );
 848
 849     if(!anIsModified)
 850       return false;
 851
 852     // update client mesh structure by logged changes commands
 853     try
 854     {
 855       for ( CORBA::Long anId = 0; anId < aLength; anId++)
 856       {
 857         const SMESH::double_array& aCoords = aSeq[anId].coords;
 858         const SMESH::long_array& anIndexes = aSeq[anId].indexes;
 859         CORBA::Long anElemId = 0, aNbElems = aSeq[anId].number;
 860         CORBA::Long aCommand = aSeq[anId].commandType;
 861
 862         switch(aCommand)
 863         {
 864         case SMESH::ADD_NODE             : AddNodesWithID      ( mySMDSMesh, aSeq, anId ); break;
 865         case SMESH::ADD_EDGE             : AddEdgesWithID      ( mySMDSMesh, aSeq, anId ); break;
 866         case SMESH::ADD_TRIANGLE         : AddTriasWithID      ( mySMDSMesh, aSeq, anId ); break;
 867         case SMESH::ADD_QUADRANGLE       : AddQuadsWithID      ( mySMDSMesh, aSeq, anId ); break;
 868         case SMESH::ADD_POLYGON          : AddPolygonsWithID   ( mySMDSMesh, aSeq, anId ); break;
 869         case SMESH::ADD_TETRAHEDRON      : AddTetrasWithID     ( mySMDSMesh, aSeq, anId ); break;
 870         case SMESH::ADD_PYRAMID          : AddPiramidsWithID   ( mySMDSMesh, aSeq, anId ); break;
 871         case SMESH::ADD_PRISM            : AddPrismsWithID     ( mySMDSMesh, aSeq, anId ); break;
 872         case SMESH::ADD_HEXAHEDRON       : AddHexasWithID      ( mySMDSMesh, aSeq, anId ); break;
 873         case SMESH::ADD_HEXAGONAL_PRISM  : AddHexPrismWithID   ( mySMDSMesh, aSeq, anId ); break;
 874         case SMESH::ADD_POLYHEDRON       : AddPolyhedronsWithID( mySMDSMesh, aSeq, anId ); break;
 875         case SMESH::ADD_ELEM0D           : Add0DElementsWithID ( mySMDSMesh, aSeq, anId ); break;
 876         case SMESH::ADD_BALL             : AddBallsWithID      ( mySMDSMesh, aSeq, anId ); break;
 877
 878         case SMESH::ADD_QUADEDGE         : AddQuadEdgesWithID   ( mySMDSMesh, aSeq, anId ); break;
 879         case SMESH::ADD_QUADTRIANGLE     : AddQuadTriasWithID   ( mySMDSMesh, aSeq, anId ); break;
 880         case SMESH::ADD_QUADQUADRANGLE   : AddQuadQuadsWithID   ( mySMDSMesh, aSeq, anId ); break;
 881         case SMESH::ADD_BIQUAD_QUADRANGLE: AddBiQuadQuadsWithID ( mySMDSMesh, aSeq, anId ); break;
 882         case SMESH::ADD_QUADTETRAHEDRON  : AddQuadTetrasWithID  ( mySMDSMesh, aSeq, anId ); break;
 883         case SMESH::ADD_QUADPYRAMID      : AddQuadPiramidsWithID( mySMDSMesh, aSeq, anId ); break;
 884         case SMESH::ADD_QUADPENTAHEDRON  : AddQuadPentasWithID  ( mySMDSMesh, aSeq, anId ); break;
 885         case SMESH::ADD_QUADHEXAHEDRON   : AddQuadHexasWithID   ( mySMDSMesh, aSeq, anId ); break;
 886         case SMESH::ADD_TRIQUAD_HEXA     : AddTriQuadHexasWithID( mySMDSMesh, aSeq, anId ); break;
 887
 888         case SMESH::CLEAR_MESH:
 889           mySMDSMesh->Clear();
 890           break;
 891
 892         case SMESH::REMOVE_NODE:
 893           for( ; anElemId < aNbElems; anElemId++ )
 894             mySMDSMesh->RemoveNode( FindNode( mySMDSMesh, anIndexes[anElemId] ) );
 895         break;
 896
 897         case SMESH::REMOVE_ELEMENT:
 898           for( ; anElemId < aNbElems; anElemId++ )
 899             mySMDSMesh->RemoveElement( FindElement( mySMDSMesh, anIndexes[anElemId] ) );
 900         break;
 901
 902         case SMESH::MOVE_NODE:
 903           for(CORBA::Long aCoordId=0; anElemId < aNbElems; anElemId++, aCoordId+=3)
 904           {
 905             SMDS_MeshNode* node =
 906               const_cast<SMDS_MeshNode*>( FindNode( mySMDSMesh, anIndexes[anElemId] ));
 907             node->setXYZ( aCoords[aCoordId], aCoords[aCoordId+1], aCoords[aCoordId+2] );
 908           }
 909         break;
 910
 911         case SMESH::CHANGE_ELEMENT_NODES:
 912           for ( CORBA::Long i = 0; anElemId < aNbElems; anElemId++ )
 913           {
 914             // find element
 915             const SMDS_MeshElement* elem = FindElement( mySMDSMesh, anIndexes[i++] );
 916             // nb nodes
 917             int nbNodes = anIndexes[i++];
 918             // nodes
 919             //ASSERT( nbNodes < 9 );
 920             vector<const SMDS_MeshNode*> aNodes( nbNodes );
 921             for ( int iNode = 0; iNode < nbNodes; iNode++ )
 922               aNodes[ iNode ] = FindNode( mySMDSMesh, anIndexes[i++] );
 923             // change
 924             mySMDSMesh->ChangeElementNodes( elem, &aNodes[0], nbNodes );
 925           }
 926           break;
 927
 928         case SMESH::CHANGE_POLYHEDRON_NODES:
 929           ChangePolyhedronNodes(mySMDSMesh, aSeq, anId);
 930           break;
 931         case SMESH::RENUMBER:
 932           for(CORBA::Long i=0; anElemId < aNbElems; anElemId++, i+=3)
 933           {
 934             mySMDSMesh->Renumber( anIndexes[i], anIndexes[i+1], anIndexes[i+2] );
 935           }
 936           break;
 937
 938         default:;
 939         }
 940       }
 941     }
 942     catch ( SALOME::SALOME_Exception& exc )
 943     {
 944       INFOS("Following exception was cought:\n\t"<<exc.details.text);
 945     }
 946     catch( const std::exception& exc)
 947     {
 948       INFOS("Following exception was cought:\n\t"<<exc.what());
 949     }
 950     catch(...)
 951     {
 952       INFOS("Unknown exception was cought !!!");
 953     }
 954
 955     if ( MYDEBUG && mySMDSMesh )
 956     {
 957       MESSAGE("Update - mySMDSMesh->NbNodes() = "<<mySMDSMesh->NbNodes());
 958       MESSAGE("Update - mySMDSMesh->Nb0DElements() = "<<mySMDSMesh->Nb0DElements());
 959       MESSAGE("Update - mySMDSMesh->NbEdges() = "<<mySMDSMesh->NbEdges());
 960       MESSAGE("Update - mySMDSMesh->NbFaces() = "<<mySMDSMesh->NbFaces());
 961       MESSAGE("Update - mySMDSMesh->NbVolumes() = "<<mySMDSMesh->NbVolumes());
 962     }
 963   } // end of update mesh by log script
 964
 965   return anIsModified;
 966 }