src/SMESHClient/SMESH_Client.cxx

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