src/SMESHClient/SMESH_Client.cxx

   1 // Copyright (C) 2007-2011  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   //=======================================================================
 320   //function : AddPolyhedronsWithID
 321   //=======================================================================
 322   inline void AddPolyhedronsWithID (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 anIndexId = 0, aNbElems = theSeq[theId].number;
 328
 329     for (CORBA::Long anElemId = 0; anElemId < aNbElems; anElemId++) {
 330       int aFaceId = anIndexes[anIndexId++];
 331
 332       int aNbNodes = anIndexes[anIndexId++];
 333       std::vector<int> nodes_ids (aNbNodes);
 334       for (int i = 0; i < aNbNodes; i++) {
 335         nodes_ids[i] = anIndexes[anIndexId++];
 336       }
 337
 338       int aNbFaces = anIndexes[anIndexId++];
 339       std::vector<int> quantities (aNbFaces);
 340       for (int i = 0; i < aNbFaces; i++) {
 341         quantities[i] = anIndexes[anIndexId++];
 342       }
 343
 344       SMDS_MeshElement* anElem =
 345         theMesh->AddPolyhedralVolumeWithID(nodes_ids, quantities, aFaceId);
 346       if (!anElem)
 347         EXCEPTION(runtime_error, "SMDS_Mesh::FindElement - cannot AddPolyhedralVolumeWithID for ID = "
 348                   << anElemId);
 349     }
 350   }
 351
 352
 353   //=======================================================================
 354   //function : AddQuadEdgesWithID
 355   //=======================================================================
 356   inline void AddQuadEdgesWithID(SMDS_Mesh* theMesh,
 357                                  SMESH::log_array_var& theSeq,
 358                                  CORBA::Long theId)
 359   {
 360     const SMESH::long_array& anIndexes = theSeq[theId].indexes;
 361     CORBA::Long anElemId = 0, aNbElems = theSeq[theId].number;
 362     if(4*aNbElems != anIndexes.length())
 363       EXCEPTION(runtime_error,"AddQuadEdgeWithID - 4*aNbElems != aCoords.length()");
 364     for(CORBA::Long anIndexId = 0; anElemId < aNbElems; anElemId++, anIndexId+=4){
 365       SMDS_MeshElement* anElem = theMesh->AddEdgeWithID(anIndexes[anIndexId+1],
 366                                                         anIndexes[anIndexId+2],
 367                                                         anIndexes[anIndexId+3],
 368                                                         anIndexes[anIndexId]);
 369       if(!anElem)
 370         EXCEPTION(runtime_error,"SMDS_Mesh::FindElement - cannot AddEdgeWithID for ID = "<<anElemId);
 371     }
 372   }
 373
 374
 375   //=======================================================================
 376   //function : AddQuadTriasWithID
 377   //=======================================================================
 378   inline void AddQuadTriasWithID(SMDS_Mesh* theMesh,
 379                                  SMESH::log_array_var& theSeq,
 380                                  CORBA::Long theId)
 381   {
 382     const SMESH::long_array& anIndexes = theSeq[theId].indexes;
 383     CORBA::Long anElemId = 0, aNbElems = theSeq[theId].number;
 384     if(7*aNbElems != anIndexes.length())
 385       EXCEPTION(runtime_error,"AddQuadTriasWithID - 7*aNbElems != anIndexes.length()");
 386     for(CORBA::Long anIndexId = 0; anElemId < aNbElems; anElemId++, anIndexId+=7){
 387       SMDS_MeshElement* anElem = theMesh->AddFaceWithID(anIndexes[anIndexId+1],
 388                                                         anIndexes[anIndexId+2],
 389                                                         anIndexes[anIndexId+3],
 390                                                         anIndexes[anIndexId+4],
 391                                                         anIndexes[anIndexId+5],
 392                                                         anIndexes[anIndexId+6],
 393                                                         anIndexes[anIndexId]);
 394       if(!anElem)
 395         EXCEPTION(runtime_error,"SMDS_Mesh::FindElement - cannot AddFaceWithID for ID = "<<anElemId);
 396     }
 397   }
 398
 399
 400   //=======================================================================
 401   //function : AddQuadQuadsWithID
 402   //=======================================================================
 403   inline void AddQuadQuadsWithID(SMDS_Mesh* theMesh,
 404                                  SMESH::log_array_var theSeq,
 405                                  CORBA::Long theId)
 406   {
 407     const SMESH::long_array& anIndexes = theSeq[theId].indexes;
 408     CORBA::Long anElemId = 0, aNbElems = theSeq[theId].number;
 409     if(9*aNbElems != anIndexes.length())
 410       EXCEPTION(runtime_error,"AddQuadQuadsWithID - 9*aNbElems != anIndexes.length()");
 411     for(CORBA::Long anIndexId = 0; anElemId < aNbElems; anElemId++, anIndexId+=9){
 412       SMDS_MeshElement* anElem = theMesh->AddFaceWithID(anIndexes[anIndexId+1],
 413                                                         anIndexes[anIndexId+2],
 414                                                         anIndexes[anIndexId+3],
 415                                                         anIndexes[anIndexId+4],
 416                                                         anIndexes[anIndexId+5],
 417                                                         anIndexes[anIndexId+6],
 418                                                         anIndexes[anIndexId+7],
 419                                                         anIndexes[anIndexId+8],
 420                                                         anIndexes[anIndexId]);
 421       if(!anElem)
 422         EXCEPTION(runtime_error,"SMDS_Mesh::FindElement - cannot AddFaceWithID for ID = "<<anElemId);
 423     }
 424   }
 425
 426
 427   //=======================================================================
 428   //function : AddQuadTetrasWithID
 429   //=======================================================================
 430   inline void AddQuadTetrasWithID(SMDS_Mesh* theMesh,
 431                                   SMESH::log_array_var& theSeq,
 432                                   CORBA::Long theId)
 433   {
 434     const SMESH::long_array& anIndexes = theSeq[theId].indexes;
 435     CORBA::Long anElemId = 0, aNbElems = theSeq[theId].number;
 436     if(11*aNbElems != anIndexes.length())
 437       EXCEPTION(runtime_error,"AddQuadTetrasWithID - 11*aNbElems != anIndexes.length()");
 438     for(CORBA::Long anIndexId = 0; anElemId < aNbElems; anElemId++, anIndexId+=11){
 439       SMDS_MeshElement* anElem = theMesh->AddVolumeWithID(anIndexes[anIndexId+1],
 440                                                           anIndexes[anIndexId+2],
 441                                                           anIndexes[anIndexId+3],
 442                                                           anIndexes[anIndexId+4],
 443                                                           anIndexes[anIndexId+5],
 444                                                           anIndexes[anIndexId+6],
 445                                                           anIndexes[anIndexId+7],
 446                                                           anIndexes[anIndexId+8],
 447                                                           anIndexes[anIndexId+9],
 448                                                           anIndexes[anIndexId+10],
 449                                                           anIndexes[anIndexId]);
 450       if(!anElem)
 451         EXCEPTION(runtime_error,"SMDS_Mesh::FindElement - cannot AddVolumeWithID for ID = "<<anElemId);
 452     }
 453   }
 454
 455
 456   //=======================================================================
 457   //function : AddQuadPiramidsWithID
 458   //=======================================================================
 459   inline void AddQuadPiramidsWithID(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(14*aNbElems != anIndexes.length())
 466       EXCEPTION(runtime_error,"AddQuadPiramidsWithID - 14*aNbElems != anIndexes.length()");
 467     for(CORBA::Long anIndexId = 0; anElemId < aNbElems; anElemId++, anIndexId+=14){
 468       SMDS_MeshElement* anElem = theMesh->AddVolumeWithID(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+10],
 478                                                           anIndexes[anIndexId+11],
 479                                                           anIndexes[anIndexId+12],
 480                                                           anIndexes[anIndexId+13],
 481                                                           anIndexes[anIndexId]);
 482       if(!anElem)
 483         EXCEPTION(runtime_error,"SMDS_Mesh::FindElement - cannot AddVolumeWithID for ID = "<<anElemId);
 484     }
 485   }
 486
 487
 488   //=======================================================================
 489   //function : AddQuadPentasWithID
 490   //=======================================================================
 491   inline void AddQuadPentasWithID(SMDS_Mesh* theMesh,
 492                                   SMESH::log_array_var& theSeq,
 493                                   CORBA::Long theId)
 494   {
 495     const SMESH::long_array& anIndexes = theSeq[theId].indexes;
 496     CORBA::Long anElemId = 0, aNbElems = theSeq[theId].number;
 497     if(16*aNbElems != anIndexes.length())
 498       EXCEPTION(runtime_error,"AddQuadPentasWithID - 16*aNbElems != anIndexes.length()");
 499     for(CORBA::Long anIndexId = 0; anElemId < aNbElems; anElemId++, anIndexId+=16){
 500       SMDS_MeshElement* anElem = theMesh->AddVolumeWithID(anIndexes[anIndexId+1],
 501                                                           anIndexes[anIndexId+2],
 502                                                           anIndexes[anIndexId+3],
 503                                                           anIndexes[anIndexId+4],
 504                                                           anIndexes[anIndexId+5],
 505                                                           anIndexes[anIndexId+6],
 506                                                           anIndexes[anIndexId+7],
 507                                                           anIndexes[anIndexId+8],
 508                                                           anIndexes[anIndexId+9],
 509                                                           anIndexes[anIndexId+10],
 510                                                           anIndexes[anIndexId+11],
 511                                                           anIndexes[anIndexId+12],
 512                                                           anIndexes[anIndexId+13],
 513                                                           anIndexes[anIndexId+14],
 514                                                           anIndexes[anIndexId+15],
 515                                                           anIndexes[anIndexId]);
 516       if(!anElem)
 517         EXCEPTION(runtime_error,"SMDS_Mesh::FindElement - cannot AddVolumeWithID for ID = "<<anElemId);
 518     }
 519   }
 520
 521
 522   //=======================================================================
 523   //function : AddQuadHexasWithID
 524   //=======================================================================
 525   inline void AddQuadHexasWithID(SMDS_Mesh* theMesh,
 526                                  SMESH::log_array_var& theSeq,
 527                                  CORBA::Long theId)
 528   {
 529     const SMESH::long_array& anIndexes = theSeq[theId].indexes;
 530     CORBA::Long anElemId = 0, aNbElems = theSeq[theId].number;
 531     if(21*aNbElems != anIndexes.length())
 532       EXCEPTION(runtime_error,"AddQuadHexasWithID - 21*aNbElems != anIndexes.length()");
 533     for(CORBA::Long anIndexId = 0; anElemId < aNbElems; anElemId++, anIndexId+=21){
 534       SMDS_MeshElement* anElem = theMesh->AddVolumeWithID(anIndexes[anIndexId+1],
 535                                                           anIndexes[anIndexId+2],
 536                                                           anIndexes[anIndexId+3],
 537                                                           anIndexes[anIndexId+4],
 538                                                           anIndexes[anIndexId+5],
 539                                                           anIndexes[anIndexId+6],
 540                                                           anIndexes[anIndexId+7],
 541                                                           anIndexes[anIndexId+8],
 542                                                           anIndexes[anIndexId+9],
 543                                                           anIndexes[anIndexId+10],
 544                                                           anIndexes[anIndexId+11],
 545                                                           anIndexes[anIndexId+12],
 546                                                           anIndexes[anIndexId+13],
 547                                                           anIndexes[anIndexId+14],
 548                                                           anIndexes[anIndexId+15],
 549                                                           anIndexes[anIndexId+16],
 550                                                           anIndexes[anIndexId+17],
 551                                                           anIndexes[anIndexId+18],
 552                                                           anIndexes[anIndexId+19],
 553                                                           anIndexes[anIndexId+20],
 554                                                           anIndexes[anIndexId]);
 555       if(!anElem)
 556         EXCEPTION(runtime_error,"SMDS_Mesh::FindElement - cannot AddVolumeWithID for ID = "<<anElemId);
 557     }
 558   }
 559
 560
 561   //=======================================================================
 562   //function : ChangePolyhedronNodes
 563   //=======================================================================
 564   inline void ChangePolyhedronNodes (SMDS_Mesh* theMesh,
 565                                      SMESH::log_array_var& theSeq,
 566                                      CORBA::Long theId)
 567   {
 568     const SMESH::long_array& anIndexes = theSeq[theId].indexes;
 569     CORBA::Long iind = 0, aNbElems = theSeq[theId].number;
 570
 571     for (CORBA::Long anElemId = 0; anElemId < aNbElems; anElemId++)
 572     {
 573       // find element
 574       const SMDS_MeshElement* elem = FindElement(theMesh, anIndexes[iind++]);
 575       // nb nodes
 576       int nbNodes = anIndexes[iind++];
 577       // nodes
 578       std::vector<const SMDS_MeshNode*> aNodes (nbNodes);
 579       for (int iNode = 0; iNode < nbNodes; iNode++) {
 580         aNodes[iNode] = FindNode(theMesh, anIndexes[iind++]);
 581       }
 582       // nb faces
 583       int nbFaces = anIndexes[iind++];
 584       // quantities
 585       std::vector<int> quantities (nbFaces);
 586       for (int iFace = 0; iFace < nbFaces; iFace++) {
 587         quantities[iFace] = anIndexes[iind++];
 588       }
 589       // change
 590       theMesh->ChangePolyhedronNodes(elem, aNodes, quantities);
 591     }
 592   }
 593 }
 594
 595 //=======================================================================
 596 SMESH::SMESH_Gen_var
 597 SMESH_Client::GetSMESHGen(CORBA::ORB_ptr theORB,
 598                           CORBA::Boolean& theIsEmbeddedMode)
 599 {
 600   static SMESH::SMESH_Gen_var aMeshGen;
 601
 602   if(CORBA::is_nil(aMeshGen.in())){
 603 #ifdef WNT
 604     long aClientPID = (long)_getpid();
 605 #else
 606     long aClientPID =  (long)getpid();
 607 #endif
 608
 609     SALOME_NamingService aNamingService(theORB);
 610     SALOME_LifeCycleCORBA aLifeCycleCORBA(&aNamingService);
 611     Engines::EngineComponent_var aComponent = aLifeCycleCORBA.FindOrLoad_Component("FactoryServer","SMESH");
 612     aMeshGen = SMESH::SMESH_Gen::_narrow(aComponent);
 613
 614     std::string aClientHostName = Kernel_Utils::GetHostname();
 615     Engines::Container_var aServerContainer = aMeshGen->GetContainerRef();
 616     CORBA::String_var aServerHostName = aServerContainer->getHostName();
 617     CORBA::Long aServerPID = aServerContainer->getPID();
 618     aMeshGen->SetEmbeddedMode((aClientPID == aServerPID) && (aClientHostName == aServerHostName.in()));
 619   }
 620   theIsEmbeddedMode = aMeshGen->IsEmbeddedMode();
 621
 622   return aMeshGen;
 623 }
 624
 625
 626 //=======================================================================
 627 // function : Create()
 628 // purpose  :
 629 //=======================================================================
 630 SMESH_Client::SMESH_Client(CORBA::ORB_ptr theORB,
 631                            SMESH::SMESH_Mesh_ptr theMesh):
 632   myMeshServer(SMESH::SMESH_Mesh::_duplicate(theMesh)),
 633   mySMESHDSMesh(NULL),
 634   mySMDSMesh(NULL)
 635 {
 636   MESSAGE("SMESH_Client::SMESH_Client");
 637   myMeshServer->Register();
 638
 639   CORBA::Boolean anIsEmbeddedMode;
 640   GetSMESHGen(theORB,anIsEmbeddedMode);
 641   if(anIsEmbeddedMode){
 642     if ( MYDEBUG )
 643       MESSAGE("Info: The same process, update mesh by pointer ");
 644     // just set client mesh pointer to server mesh pointer
 645     //SMESH_Mesh* aMesh = reinterpret_cast<SMESH_Mesh*>(theMesh->GetMeshPtr());
 646     CORBA::LongLong pointeur = theMesh->GetMeshPtr();
 647     if( MYDEBUG )
 648       MESSAGE("SMESH_Client::SMESH_Client pointeur "<<pointeur);
 649     SMESH_Mesh* aMesh = reinterpret_cast<SMESH_Mesh*> (pointeur);
 650     if ( MYDEBUG )
 651       MESSAGE("SMESH_Client::SMESH_Client aMesh "<<aMesh);
 652     //if(aMesh->GetMeshDS()->IsEmbeddedMode()){
 653     if(anIsEmbeddedMode){
 654       mySMESHDSMesh = aMesh->GetMeshDS();
 655       mySMDSMesh = mySMESHDSMesh;
 656     }
 657   }
 658   if(!mySMDSMesh)
 659     mySMDSMesh = new SMDS_Mesh();
 660 }
 661
 662
 663 //=================================================================================
 664 // function : ~SMESH_Client
 665 // purpose  : Destructor
 666 //=================================================================================
 667 SMESH_Client::~SMESH_Client()
 668 {
 669   myMeshServer->UnRegister();
 670   if(!mySMESHDSMesh)
 671     delete mySMDSMesh;
 672 }
 673
 674
 675 //=================================================================================
 676 SMDS_Mesh*
 677 SMESH_Client::GetMesh() const
 678 {
 679   return mySMDSMesh;
 680 }
 681
 682
 683 //=================================================================================
 684 SMDS_Mesh*
 685 SMESH_Client::operator->() const
 686 {
 687   return GetMesh();
 688 }
 689
 690
 691 //=================================================================================
 692 SMESH::SMESH_Mesh_ptr
 693 SMESH_Client::GetMeshServer()
 694 {
 695   return myMeshServer.in();
 696 }
 697
 698
 699 //=================================================================================
 700 // function : SMESH_Client
 701 // purpose  : Update mesh
 702 //=================================================================================
 703 bool
 704 SMESH_Client::Update(bool theIsClear)
 705 {
 706   bool anIsModified = true;
 707   if(mySMESHDSMesh){
 708         MESSAGE("Update mySMESHDSMesh");
 709     SMESHDS_Script* aScript = mySMESHDSMesh->GetScript();
 710     anIsModified = aScript->IsModified();
 711     aScript->SetModified(false);
 712   }else{
 713         MESSAGE("Update CORBA");
 714     SMESH::log_array_var aSeq = myMeshServer->GetLog( theIsClear );
 715     CORBA::Long aLength = aSeq->length();
 716     anIsModified = aLength > 0;
 717     if( MYDEBUG )
 718       MESSAGE( "Update: length of the script is "<<aLength );
 719
 720     if(!anIsModified)
 721       return false;
 722
 723     // update client mesh structure by logged changes commands
 724     try
 725     {
 726       for ( CORBA::Long anId = 0; anId < aLength; anId++)
 727       {
 728         const SMESH::double_array& aCoords = aSeq[anId].coords;
 729         const SMESH::long_array& anIndexes = aSeq[anId].indexes;
 730         CORBA::Long anElemId = 0, aNbElems = aSeq[anId].number;
 731         CORBA::Long aCommand = aSeq[anId].commandType;
 732
 733         switch(aCommand)
 734         {
 735         case SMESH::ADD_NODE       : AddNodesWithID      ( mySMDSMesh, aSeq, anId ); break;
 736         case SMESH::ADD_ELEM0D     : Add0DElementsWithID ( mySMDSMesh, aSeq, anId ); break;
 737         case SMESH::ADD_EDGE       : AddEdgesWithID      ( mySMDSMesh, aSeq, anId ); break;
 738         case SMESH::ADD_TRIANGLE   : AddTriasWithID      ( mySMDSMesh, aSeq, anId ); break;
 739         case SMESH::ADD_QUADRANGLE : AddQuadsWithID      ( mySMDSMesh, aSeq, anId ); break;
 740         case SMESH::ADD_POLYGON    : AddPolygonsWithID   ( mySMDSMesh, aSeq, anId ); break;
 741         case SMESH::ADD_TETRAHEDRON: AddTetrasWithID     ( mySMDSMesh, aSeq, anId ); break;
 742         case SMESH::ADD_PYRAMID    : AddPiramidsWithID   ( mySMDSMesh, aSeq, anId ); break;
 743         case SMESH::ADD_PRISM      : AddPrismsWithID     ( mySMDSMesh, aSeq, anId ); break;
 744         case SMESH::ADD_HEXAHEDRON : AddHexasWithID      ( mySMDSMesh, aSeq, anId ); break;
 745         case SMESH::ADD_POLYHEDRON : AddPolyhedronsWithID( mySMDSMesh, aSeq, anId ); break;
 746
 747         case SMESH::ADD_QUADEDGE       : AddQuadEdgesWithID   ( mySMDSMesh, aSeq, anId ); break;
 748         case SMESH::ADD_QUADTRIANGLE   : AddQuadTriasWithID   ( mySMDSMesh, aSeq, anId ); break;
 749         case SMESH::ADD_QUADQUADRANGLE : AddQuadQuadsWithID   ( mySMDSMesh, aSeq, anId ); break;
 750         case SMESH::ADD_QUADTETRAHEDRON: AddQuadTetrasWithID  ( mySMDSMesh, aSeq, anId ); break;
 751         case SMESH::ADD_QUADPYRAMID    : AddQuadPiramidsWithID( mySMDSMesh, aSeq, anId ); break;
 752         case SMESH::ADD_QUADPENTAHEDRON: AddQuadPentasWithID  ( mySMDSMesh, aSeq, anId ); break;
 753         case SMESH::ADD_QUADHEXAHEDRON : AddQuadHexasWithID   ( mySMDSMesh, aSeq, anId ); break;
 754
 755         case SMESH::CLEAR_MESH:
 756           mySMDSMesh->Clear();
 757           break;
 758
 759         case SMESH::REMOVE_NODE:
 760           for( ; anElemId < aNbElems; anElemId++ )
 761             mySMDSMesh->RemoveNode( FindNode( mySMDSMesh, anIndexes[anElemId] ) );
 762         break;
 763
 764         case SMESH::REMOVE_ELEMENT:
 765           for( ; anElemId < aNbElems; anElemId++ )
 766             mySMDSMesh->RemoveElement( FindElement( mySMDSMesh, anIndexes[anElemId] ) );
 767         break;
 768
 769         case SMESH::MOVE_NODE:
 770           for(CORBA::Long aCoordId=0; anElemId < aNbElems; anElemId++, aCoordId+=3)
 771           {
 772             SMDS_MeshNode* node =
 773               const_cast<SMDS_MeshNode*>( FindNode( mySMDSMesh, anIndexes[anElemId] ));
 774             node->setXYZ( aCoords[aCoordId], aCoords[aCoordId+1], aCoords[aCoordId+2] );
 775           }
 776         break;
 777
 778         case SMESH::CHANGE_ELEMENT_NODES:
 779           for ( CORBA::Long i = 0; anElemId < aNbElems; anElemId++ )
 780           {
 781             // find element
 782             const SMDS_MeshElement* elem = FindElement( mySMDSMesh, anIndexes[i++] );
 783             // nb nodes
 784             int nbNodes = anIndexes[i++];
 785             // nodes
 786             //ASSERT( nbNodes < 9 );
 787             vector<const SMDS_MeshNode*> aNodes( nbNodes );
 788             for ( int iNode = 0; iNode < nbNodes; iNode++ )
 789               aNodes[ iNode ] = FindNode( mySMDSMesh, anIndexes[i++] );
 790             // change
 791             mySMDSMesh->ChangeElementNodes( elem, &aNodes[0], nbNodes );
 792           }
 793           break;
 794
 795         case SMESH::CHANGE_POLYHEDRON_NODES:
 796           ChangePolyhedronNodes(mySMDSMesh, aSeq, anId);
 797           break;
 798         case SMESH::RENUMBER:
 799           for(CORBA::Long i=0; anElemId < aNbElems; anElemId++, i+=3)
 800           {
 801             mySMDSMesh->Renumber( anIndexes[i], anIndexes[i+1], anIndexes[i+2] );
 802           }
 803           break;
 804
 805         default:;
 806         }
 807       }
 808     }
 809     catch ( SALOME::SALOME_Exception& exc )
 810     {
 811       INFOS("Following exception was cought:\n\t"<<exc.details.text);
 812     }
 813     catch( const std::exception& exc)
 814     {
 815       INFOS("Following exception was cought:\n\t"<<exc.what());
 816     }
 817     catch(...)
 818     {
 819       INFOS("Unknown exception was cought !!!");
 820     }
 821
 822     if ( MYDEBUG && mySMDSMesh )
 823     {
 824       MESSAGE("Update - mySMDSMesh->NbNodes() = "<<mySMDSMesh->NbNodes());
 825       MESSAGE("Update - mySMDSMesh->Nb0DElements() = "<<mySMDSMesh->Nb0DElements());
 826       MESSAGE("Update - mySMDSMesh->NbEdges() = "<<mySMDSMesh->NbEdges());
 827       MESSAGE("Update - mySMDSMesh->NbFaces() = "<<mySMDSMesh->NbFaces());
 828       MESSAGE("Update - mySMDSMesh->NbVolumes() = "<<mySMDSMesh->NbVolumes());
 829     }
 830   } // end of update mesh by log script
 831
 832   return anIsModified;
 833 }