src/SMESHDS/SMESHDS_Command.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
  23 //  SMESH SMESHDS : management of mesh data and SMESH document
  24 //  File   : SMESH_Command.cxx
  25 //  Author : Yves FRICAUD, OCC
  26 //  Module : SMESH
  27 //
  28 #include "SMESHDS_Command.hxx"
  29
  30 #include "utilities.h"
  31
  32 using namespace std;
  33
  34 //=======================================================================
  35 //function : Constructor
  36 //purpose  :
  37 //=======================================================================
  38 SMESHDS_Command::SMESHDS_Command(const SMESHDS_CommandType aType):myType(aType),
  39 myNumber(0)
  40 {
  41 }
  42
  43 //=======================================================================
  44 //function : Destructor
  45 //purpose  :
  46 //=======================================================================
  47 SMESHDS_Command::~SMESHDS_Command()
  48 {
  49 }
  50
  51 //=======================================================================
  52 //function :
  53 //purpose  :
  54 //=======================================================================
  55 void SMESHDS_Command::AddNode(int NewNodeID, double x, double y, double z)
  56 {
  57         if (!myType == SMESHDS_AddNode)
  58         {
  59                 MESSAGE("SMESHDS_Command::AddNode : Bad Type");
  60                 return;
  61         }
  62         myIntegers.push_back(NewNodeID);
  63         myReals.push_back(x);
  64         myReals.push_back(y);
  65         myReals.push_back(z);
  66         myNumber++;
  67 }
  68
  69 //=======================================================================
  70 //function :
  71 //purpose  :
  72 //=======================================================================
  73 void SMESHDS_Command::MoveNode(int NodeID, double x, double y, double z)
  74 {
  75         if (!myType == SMESHDS_MoveNode)
  76         {
  77                 MESSAGE("SMESHDS_Command::MoveNode : Bad Type");
  78                 return;
  79         }
  80         myIntegers.push_back(NodeID);
  81         myReals.push_back(x);
  82         myReals.push_back(y);
  83         myReals.push_back(z);
  84         myNumber++;
  85 }
  86
  87 //=======================================================================
  88 //function :
  89 //purpose  :
  90 //=======================================================================
  91 void SMESHDS_Command::Add0DElement(int New0DElementID, int idnode)
  92 {
  93   if (!myType == SMESHDS_Add0DElement)
  94   {
  95     MESSAGE("SMESHDS_Command::Add0DElement : Bad Type");
  96     return;
  97   }
  98   myIntegers.push_back(New0DElementID);
  99   myIntegers.push_back(idnode);
 100   myNumber++;
 101 }
 102
 103 //=======================================================================
 104 //function :
 105 //purpose  :
 106 //=======================================================================
 107 void SMESHDS_Command::AddEdge(int NewEdgeID, int idnode1, int idnode2)
 108 {
 109         if (!myType == SMESHDS_AddEdge)
 110         {
 111                 MESSAGE("SMESHDS_Command::AddEdge : Bad Type");
 112                 return;
 113         }
 114         myIntegers.push_back(NewEdgeID);
 115         myIntegers.push_back(idnode1);
 116         myIntegers.push_back(idnode2);
 117         myNumber++;
 118 }
 119
 120 //=======================================================================
 121 //function :
 122 //purpose  :
 123 //=======================================================================
 124 void SMESHDS_Command::AddFace(int NewFaceID,
 125         int idnode1, int idnode2, int idnode3)
 126 {
 127         if (!myType == SMESHDS_AddTriangle)
 128         {
 129                 MESSAGE("SMESHDS_Command::AddFace : Bad Type");
 130                 return;
 131         }
 132         myIntegers.push_back(NewFaceID);
 133         myIntegers.push_back(idnode1);
 134         myIntegers.push_back(idnode2);
 135         myIntegers.push_back(idnode3);
 136         myNumber++;
 137 }
 138
 139 //=======================================================================
 140 //function :
 141 //purpose  :
 142 //=======================================================================
 143 void SMESHDS_Command::AddFace(int NewFaceID,
 144         int idnode1, int idnode2, int idnode3, int idnode4)
 145 {
 146         if (!myType == SMESHDS_AddQuadrangle)
 147         {
 148                 MESSAGE("SMESHDS_Command::AddFace : Bad Type");
 149                 return;
 150         }
 151         myIntegers.push_back(NewFaceID);
 152         myIntegers.push_back(idnode1);
 153         myIntegers.push_back(idnode2);
 154         myIntegers.push_back(idnode3);
 155         myIntegers.push_back(idnode4);
 156         myNumber++;
 157 }
 158
 159 //=======================================================================
 160 //function :
 161 //purpose  :
 162 //=======================================================================
 163 void SMESHDS_Command::AddVolume(int NewVolID,
 164         int idnode1, int idnode2, int idnode3, int idnode4)
 165 {
 166         if (!myType == SMESHDS_AddTetrahedron)
 167         {
 168                 MESSAGE("SMESHDS_Command::AddVolume : Bad Type");
 169                 return;
 170         }
 171         myIntegers.push_back(NewVolID);
 172         myIntegers.push_back(idnode1);
 173         myIntegers.push_back(idnode2);
 174         myIntegers.push_back(idnode3);
 175         myIntegers.push_back(idnode4);
 176         myNumber++;
 177 }
 178
 179 //=======================================================================
 180 //function :
 181 //purpose  :
 182 //=======================================================================
 183 void SMESHDS_Command::AddVolume(int NewVolID,
 184         int idnode1, int idnode2, int idnode3, int idnode4, int idnode5)
 185 {
 186         if (!myType == SMESHDS_AddPyramid)
 187         {
 188                 MESSAGE("SMESHDS_Command::AddVolume : Bad Type");
 189                 return;
 190         }
 191         myIntegers.push_back(NewVolID);
 192         myIntegers.push_back(idnode1);
 193         myIntegers.push_back(idnode2);
 194         myIntegers.push_back(idnode3);
 195         myIntegers.push_back(idnode4);
 196         myIntegers.push_back(idnode5);
 197         myNumber++;
 198 }
 199
 200 //=======================================================================
 201 //function :
 202 //purpose  :
 203 //=======================================================================
 204 void SMESHDS_Command::AddVolume(int NewVolID,
 205         int idnode1,
 206         int idnode2, int idnode3, int idnode4, int idnode5, int idnode6)
 207 {
 208         if (!myType == SMESHDS_AddPrism)
 209         {
 210                 MESSAGE("SMESHDS_Command::AddVolume : Bad Type");
 211                 return;
 212         }
 213         myIntegers.push_back(NewVolID);
 214         myIntegers.push_back(idnode1);
 215         myIntegers.push_back(idnode2);
 216         myIntegers.push_back(idnode3);
 217         myIntegers.push_back(idnode4);
 218         myIntegers.push_back(idnode5);
 219         myIntegers.push_back(idnode6);
 220         myNumber++;
 221 }
 222
 223 //=======================================================================
 224 //function :
 225 //purpose  :
 226 //=======================================================================
 227 void SMESHDS_Command::AddVolume(int NewVolID,
 228         int idnode1,
 229         int idnode2,
 230         int idnode3,
 231         int idnode4, int idnode5, int idnode6, int idnode7, int idnode8)
 232 {
 233         if (!myType == SMESHDS_AddHexahedron)
 234         {
 235                 MESSAGE("SMESHDS_Command::AddVolume : Bad Type");
 236                 return;
 237         }
 238         myIntegers.push_back(NewVolID);
 239         myIntegers.push_back(idnode1);
 240         myIntegers.push_back(idnode2);
 241         myIntegers.push_back(idnode3);
 242         myIntegers.push_back(idnode4);
 243         myIntegers.push_back(idnode5);
 244         myIntegers.push_back(idnode6);
 245         myIntegers.push_back(idnode7);
 246         myIntegers.push_back(idnode8);
 247         myNumber++;
 248 }
 249
 250 void SMESHDS_Command::AddVolume(int NewVolID,
 251                                 int idnode1,int idnode2,int idnode3,int idnode4,
 252                                 int idnode5, int idnode6, int idnode7, int idnode8,
 253                                 int idnode9, int idnode10, int idnode11, int idnode12)
 254 {
 255   if (myType != SMESHDS_AddHexagonalPrism)
 256   {
 257     MESSAGE("SMESHDS_Command::AddVolume : Bad Type");
 258     return;
 259   }
 260   myIntegers.push_back(NewVolID);
 261   myIntegers.push_back(idnode1);
 262   myIntegers.push_back(idnode2);
 263   myIntegers.push_back(idnode3);
 264   myIntegers.push_back(idnode4);
 265   myIntegers.push_back(idnode5);
 266   myIntegers.push_back(idnode6);
 267   myIntegers.push_back(idnode7);
 268   myIntegers.push_back(idnode8);
 269   myIntegers.push_back(idnode9);
 270   myIntegers.push_back(idnode10);
 271   myIntegers.push_back(idnode11);
 272   myIntegers.push_back(idnode12);
 273   myNumber++;
 274 }
 275
 276 //=======================================================================
 277 //function : AddPolygonalFace
 278 //purpose  :
 279 //=======================================================================
 280 void SMESHDS_Command::AddPolygonalFace (const int               ElementID,
 281                                         const std::vector<int>& nodes_ids)
 282 {
 283   if (!myType == SMESHDS_AddPolygon) {
 284     MESSAGE("SMESHDS_Command::AddPolygonalFace : Bad Type");
 285     return;
 286   }
 287   myIntegers.push_back(ElementID);
 288
 289   int i, nbNodes = nodes_ids.size();
 290   myIntegers.push_back(nbNodes);
 291   for (i = 0; i < nbNodes; i++) {
 292     myIntegers.push_back(nodes_ids[i]);
 293   }
 294
 295   myNumber++;
 296 }
 297
 298 //=======================================================================
 299 //function : AddPolyhedralVolume
 300 //purpose  :
 301 //=======================================================================
 302 void SMESHDS_Command::AddPolyhedralVolume (const int               ElementID,
 303                                            const std::vector<int>& nodes_ids,
 304                                            const std::vector<int>& quantities)
 305 {
 306   if (!myType == SMESHDS_AddPolyhedron) {
 307     MESSAGE("SMESHDS_Command::AddPolyhedralVolume : Bad Type");
 308     return;
 309   }
 310   myIntegers.push_back(ElementID);
 311
 312   int i, nbNodes = nodes_ids.size();
 313   myIntegers.push_back(nbNodes);
 314   for (i = 0; i < nbNodes; i++) {
 315     myIntegers.push_back(nodes_ids[i]);
 316   }
 317
 318   int nbFaces = quantities.size();
 319   myIntegers.push_back(nbFaces);
 320   for (i = 0; i < nbFaces; i++) {
 321     myIntegers.push_back(quantities[i]);
 322   }
 323
 324   myNumber++;
 325 }
 326
 327 //=======================================================================
 328 //function :
 329 //purpose  :
 330 //=======================================================================
 331 void SMESHDS_Command::RemoveNode(int NodeID)
 332 {
 333         if (!myType == SMESHDS_RemoveNode)
 334         {
 335                 MESSAGE("SMESHDS_Command::RemoveNode : Bad Type");
 336                 return;
 337         }
 338         myIntegers.push_back(NodeID);
 339         myNumber++;
 340 }
 341
 342 //=======================================================================
 343 //function :
 344 //purpose  :
 345 //=======================================================================
 346 void SMESHDS_Command::RemoveElement(int ElementID)
 347 {
 348         if (!myType == SMESHDS_RemoveElement)
 349         {
 350                 MESSAGE("SMESHDS_Command::RemoveElement : Bad Type");
 351                 return;
 352         }
 353         myIntegers.push_back(ElementID);
 354         myNumber++;
 355 }
 356
 357 //=======================================================================
 358 //function : ChangeElementNodes
 359 //purpose  :
 360 //=======================================================================
 361
 362 void SMESHDS_Command::ChangeElementNodes(int ElementID, int nodes[], int nbnodes)
 363 {
 364   if (!myType == SMESHDS_ChangeElementNodes)
 365   {
 366     MESSAGE("SMESHDS_Command::ChangeElementNodes : Bad Type");
 367     return;
 368   }
 369   myIntegers.push_back(ElementID);
 370   myIntegers.push_back(nbnodes);
 371   for ( int i = 0; i < nbnodes; i++ )
 372     myIntegers.push_back( nodes[ i ] );
 373
 374   myNumber++;
 375 }
 376
 377 //=======================================================================
 378 //function : ChangePolyhedronNodes
 379 //purpose  :
 380 //=======================================================================
 381 void SMESHDS_Command::ChangePolyhedronNodes (const int               ElementID,
 382                                              const std::vector<int>& nodes_ids,
 383                                              const std::vector<int>& quantities)
 384 {
 385   if (myType != SMESHDS_ChangePolyhedronNodes)
 386   {
 387     MESSAGE("SMESHDS_Command::ChangePolyhedronNodes : Bad Type");
 388     return;
 389   }
 390   myIntegers.push_back(ElementID);
 391
 392   int i, nbNodes = nodes_ids.size();
 393   myIntegers.push_back(nbNodes);
 394   for (i = 0; i < nbNodes; i++) {
 395     myIntegers.push_back(nodes_ids[i]);
 396   }
 397
 398   int nbFaces = quantities.size();
 399   myIntegers.push_back(nbFaces);
 400   for (i = 0; i < nbFaces; i++) {
 401     myIntegers.push_back(quantities[i]);
 402   }
 403
 404   myNumber++;
 405 }
 406
 407 //=======================================================================
 408 //function : Renumber
 409 //purpose  :
 410 //=======================================================================
 411
 412 void SMESHDS_Command::Renumber (const bool isNodes, const int startID, const int deltaID)
 413 {
 414   if (!myType == SMESHDS_Renumber)
 415   {
 416     MESSAGE("SMESHDS_Command::Renumber : Bad Type");
 417     return;
 418   }
 419   myIntegers.push_back(isNodes);
 420   myIntegers.push_back(startID);
 421   myIntegers.push_back(deltaID);
 422   myNumber++;
 423 }
 424
 425 //=======================================================================
 426 //function :
 427 //purpose  :
 428 //=======================================================================
 429 SMESHDS_CommandType SMESHDS_Command::GetType()
 430 {
 431         return myType;
 432 }
 433
 434 //=======================================================================
 435 //function :
 436 //purpose  :
 437 //=======================================================================
 438 int SMESHDS_Command::GetNumber()
 439 {
 440         return myNumber;
 441 }
 442
 443 //=======================================================================
 444 //function :
 445 //purpose  :
 446 //=======================================================================
 447 const list < int >&SMESHDS_Command::GetIndexes()
 448 {
 449         return myIntegers;
 450 }
 451
 452 //=======================================================================
 453 //function :
 454 //purpose  :
 455 //=======================================================================
 456 const list < double >&SMESHDS_Command::GetCoords()
 457 {
 458         return myReals;
 459 }
 460
 461
 462 //********************************************************************
 463 //*****             Methods for quadratic elements              ******
 464 //********************************************************************
 465
 466 //=======================================================================
 467 //function : AddEdge
 468 //purpose  :
 469 //=======================================================================
 470 void SMESHDS_Command::AddEdge(int NewEdgeID, int n1, int n2, int n12)
 471 {
 472   if (!myType == SMESHDS_AddQuadEdge) {
 473     MESSAGE("SMESHDS_Command::AddEdge : Bad Type");
 474     return;
 475   }
 476   myIntegers.push_back(NewEdgeID);
 477   myIntegers.push_back(n1);
 478   myIntegers.push_back(n2);
 479   myIntegers.push_back(n12);
 480   myNumber++;
 481 }
 482
 483 //=======================================================================
 484 //function : AddFace
 485 //purpose  :
 486 //=======================================================================
 487 void SMESHDS_Command::AddFace(int NewFaceID,
 488                               int n1, int n2, int n3,
 489                               int n12, int n23, int n31)
 490 {
 491   if (!myType == SMESHDS_AddQuadTriangle) {
 492     MESSAGE("SMESHDS_Command::AddFace : Bad Type");
 493     return;
 494   }
 495   myIntegers.push_back(NewFaceID);
 496   myIntegers.push_back(n1);
 497   myIntegers.push_back(n2);
 498   myIntegers.push_back(n3);
 499   myIntegers.push_back(n12);
 500   myIntegers.push_back(n23);
 501   myIntegers.push_back(n31);
 502   myNumber++;
 503 }
 504
 505 //=======================================================================
 506 //function : AddFace
 507 //purpose  :
 508 //=======================================================================
 509 void SMESHDS_Command::AddFace(int NewFaceID,
 510                               int n1, int n2, int n3, int n4,
 511                               int n12, int n23, int n34, int n41)
 512 {
 513   if (!myType == SMESHDS_AddQuadQuadrangle) {
 514     MESSAGE("SMESHDS_Command::AddFace : Bad Type");
 515     return;
 516   }
 517   myIntegers.push_back(NewFaceID);
 518   myIntegers.push_back(n1);
 519   myIntegers.push_back(n2);
 520   myIntegers.push_back(n3);
 521   myIntegers.push_back(n4);
 522   myIntegers.push_back(n12);
 523   myIntegers.push_back(n23);
 524   myIntegers.push_back(n34);
 525   myIntegers.push_back(n41);
 526   myNumber++;
 527 }
 528
 529 //=======================================================================
 530 //function : AddFace
 531 //purpose  :
 532 //=======================================================================
 533 void SMESHDS_Command::AddFace(int NewFaceID,
 534                               int n1, int n2, int n3, int n4,
 535                               int n12, int n23, int n34, int n41, int nCenter)
 536 {
 537   if (myType != SMESHDS_AddBiQuadQuadrangle) {
 538     MESSAGE("SMESHDS_Command::AddFace : Bad Type");
 539     return;
 540   }
 541   myIntegers.push_back(NewFaceID);
 542   myIntegers.push_back(n1);
 543   myIntegers.push_back(n2);
 544   myIntegers.push_back(n3);
 545   myIntegers.push_back(n4);
 546   myIntegers.push_back(n12);
 547   myIntegers.push_back(n23);
 548   myIntegers.push_back(n34);
 549   myIntegers.push_back(n41);
 550   myIntegers.push_back(nCenter);
 551   myNumber++;
 552 }
 553
 554 //=======================================================================
 555 //function : AddVolume
 556 //purpose  :
 557 //=======================================================================
 558 void SMESHDS_Command::AddVolume(int NewVolID, int n1, int n2, int n3, int n4,
 559                                 int n12, int n23, int n31,
 560                                 int n14, int n24, int n34)
 561 {
 562   if (!myType == SMESHDS_AddQuadTetrahedron) {
 563     MESSAGE("SMESHDS_Command::AddVolume : Bad Type");
 564     return;
 565   }
 566   myIntegers.push_back(NewVolID);
 567   myIntegers.push_back(n1);
 568   myIntegers.push_back(n2);
 569   myIntegers.push_back(n3);
 570   myIntegers.push_back(n4);
 571   myIntegers.push_back(n12);
 572   myIntegers.push_back(n23);
 573   myIntegers.push_back(n31);
 574   myIntegers.push_back(n14);
 575   myIntegers.push_back(n24);
 576   myIntegers.push_back(n34);
 577   myNumber++;
 578 }
 579
 580 //=======================================================================
 581 //function : AddVolume
 582 //purpose  :
 583 //=======================================================================
 584 void SMESHDS_Command::AddVolume(int NewVolID, int n1, int n2,
 585                                 int n3, int n4, int n5,
 586                                 int n12, int n23, int n34, int n41,
 587                                 int n15, int n25, int n35, int n45)
 588 {
 589   if (!myType == SMESHDS_AddQuadPyramid) {
 590     MESSAGE("SMESHDS_Command::AddVolume : Bad Type");
 591     return;
 592   }
 593   myIntegers.push_back(NewVolID);
 594   myIntegers.push_back(n1);
 595   myIntegers.push_back(n2);
 596   myIntegers.push_back(n3);
 597   myIntegers.push_back(n4);
 598   myIntegers.push_back(n5);
 599   myIntegers.push_back(n12);
 600   myIntegers.push_back(n23);
 601   myIntegers.push_back(n34);
 602   myIntegers.push_back(n41);
 603   myIntegers.push_back(n15);
 604   myIntegers.push_back(n25);
 605   myIntegers.push_back(n35);
 606   myIntegers.push_back(n45);
 607   myNumber++;
 608 }
 609
 610 //=======================================================================
 611 //function : AddVolume
 612 //purpose  :
 613 //=======================================================================
 614 void SMESHDS_Command::AddVolume(int NewVolID, int n1, int n2,
 615                                 int n3, int n4, int n5,int n6,
 616                                 int n12, int n23, int n31,
 617                                 int n45, int n56, int n64,
 618                                 int n14, int n25, int n36)
 619 {
 620   if (!myType == SMESHDS_AddQuadPentahedron) {
 621     MESSAGE("SMESHDS_Command::AddVolume : Bad Type");
 622     return;
 623   }
 624   myIntegers.push_back(NewVolID);
 625   myIntegers.push_back(n1);
 626   myIntegers.push_back(n2);
 627   myIntegers.push_back(n3);
 628   myIntegers.push_back(n4);
 629   myIntegers.push_back(n5);
 630   myIntegers.push_back(n6);
 631   myIntegers.push_back(n12);
 632   myIntegers.push_back(n23);
 633   myIntegers.push_back(n31);
 634   myIntegers.push_back(n45);
 635   myIntegers.push_back(n56);
 636   myIntegers.push_back(n64);
 637   myIntegers.push_back(n14);
 638   myIntegers.push_back(n25);
 639   myIntegers.push_back(n36);
 640   myNumber++;
 641 }
 642
 643 //=======================================================================
 644 //function : AddVolume
 645 //purpose  :
 646 //=======================================================================
 647 void SMESHDS_Command::AddVolume(int NewVolID, int n1, int n2, int n3,
 648                                 int n4, int n5, int n6, int n7, int n8,
 649                                 int n12, int n23, int n34, int n41,
 650                                 int n56, int n67, int n78, int n85,
 651                                 int n15, int n26, int n37, int n48)
 652 {
 653   if (!myType == SMESHDS_AddQuadHexahedron) {
 654     MESSAGE("SMESHDS_Command::AddVolume : Bad Type");
 655     return;
 656   }
 657   myIntegers.push_back(NewVolID);
 658   myIntegers.push_back(n1);
 659   myIntegers.push_back(n2);
 660   myIntegers.push_back(n3);
 661   myIntegers.push_back(n4);
 662   myIntegers.push_back(n5);
 663   myIntegers.push_back(n6);
 664   myIntegers.push_back(n7);
 665   myIntegers.push_back(n8);
 666   myIntegers.push_back(n12);
 667   myIntegers.push_back(n23);
 668   myIntegers.push_back(n34);
 669   myIntegers.push_back(n41);
 670   myIntegers.push_back(n56);
 671   myIntegers.push_back(n67);
 672   myIntegers.push_back(n78);
 673   myIntegers.push_back(n85);
 674   myIntegers.push_back(n15);
 675   myIntegers.push_back(n26);
 676   myIntegers.push_back(n37);
 677   myIntegers.push_back(n48);
 678   myNumber++;
 679 }
 680
 681 //=======================================================================
 682 //function : AddVolume
 683 //purpose  :
 684 //=======================================================================
 685 void SMESHDS_Command::AddVolume(int NewVolID, int n1, int n2, int n3,
 686                                 int n4, int n5, int n6, int n7, int n8,
 687                                 int n12, int n23, int n34, int n41,
 688                                 int n56, int n67, int n78, int n85,
 689                                 int n15, int n26, int n37, int n48,
 690                                 int n1234,int n1256,int n2367,int n3478,
 691                                 int n1458,int n5678,int nCenter)
 692 {
 693   if (!myType == SMESHDS_AddQuadHexahedron) {
 694     MESSAGE("SMESHDS_Command::AddVolume : Bad Type");
 695     return;
 696   }
 697   myIntegers.push_back(NewVolID);
 698   myIntegers.push_back(n1);
 699   myIntegers.push_back(n2);
 700   myIntegers.push_back(n3);
 701   myIntegers.push_back(n4);
 702   myIntegers.push_back(n5);
 703   myIntegers.push_back(n6);
 704   myIntegers.push_back(n7);
 705   myIntegers.push_back(n8);
 706   myIntegers.push_back(n12);
 707   myIntegers.push_back(n23);
 708   myIntegers.push_back(n34);
 709   myIntegers.push_back(n41);
 710   myIntegers.push_back(n56);
 711   myIntegers.push_back(n67);
 712   myIntegers.push_back(n78);
 713   myIntegers.push_back(n85);
 714   myIntegers.push_back(n15);
 715   myIntegers.push_back(n26);
 716   myIntegers.push_back(n37);
 717   myIntegers.push_back(n48);
 718   myIntegers.push_back(n1234);
 719   myIntegers.push_back(n1256);
 720   myIntegers.push_back(n2367);
 721   myIntegers.push_back(n3478);
 722   myIntegers.push_back(n1458);
 723   myIntegers.push_back(n5678);
 724   myIntegers.push_back(nCenter);
 725   myNumber++;
 726 }
 727
 728 //================================================================================
 729 /*!
 730  * \brief Record adding a Ball
 731  */
 732 //================================================================================
 733
 734 void SMESHDS_Command::AddBall(int NewBallID, int node, double diameter)
 735 {
 736   if (!myType == SMESHDS_AddBall)
 737   {
 738     MESSAGE("SMESHDS_Command::SMESHDS_AddBall : Bad Type");
 739     return;
 740   }
 741   myIntegers.push_back(NewBallID);
 742   myIntegers.push_back(node);
 743   myReals.push_back(diameter);
 744   myNumber++;
 745 }