src/SMESHClient/SMESH_Client.cxx

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