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