src/SMESHDS/SMESHDS_Command.cxx

   1 // Copyright (C) 2007-2013  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,
 511                               int n12, int n23, int n31, int nCenter)
 512 {
 513   if (!myType == SMESHDS_AddBiQuadTriangle) {
 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(n12);
 522   myIntegers.push_back(n23);
 523   myIntegers.push_back(n31);
 524   myIntegers.push_back(nCenter);
 525   myNumber++;
 526 }
 527
 528 //=======================================================================
 529 //function : AddFace
 530 //purpose  :
 531 //=======================================================================
 532 void SMESHDS_Command::AddFace(int NewFaceID,
 533                               int n1, int n2, int n3, int n4,
 534                               int n12, int n23, int n34, int n41)
 535 {
 536   if (!myType == SMESHDS_AddQuadQuadrangle) {
 537     MESSAGE("SMESHDS_Command::AddFace : Bad Type");
 538     return;
 539   }
 540   myIntegers.push_back(NewFaceID);
 541   myIntegers.push_back(n1);
 542   myIntegers.push_back(n2);
 543   myIntegers.push_back(n3);
 544   myIntegers.push_back(n4);
 545   myIntegers.push_back(n12);
 546   myIntegers.push_back(n23);
 547   myIntegers.push_back(n34);
 548   myIntegers.push_back(n41);
 549   myNumber++;
 550 }
 551
 552 //=======================================================================
 553 //function : AddFace
 554 //purpose  :
 555 //=======================================================================
 556 void SMESHDS_Command::AddFace(int NewFaceID,
 557                               int n1, int n2, int n3, int n4,
 558                               int n12, int n23, int n34, int n41, int nCenter)
 559 {
 560   if (myType != SMESHDS_AddBiQuadQuadrangle) {
 561     MESSAGE("SMESHDS_Command::AddFace : Bad Type");
 562     return;
 563   }
 564   myIntegers.push_back(NewFaceID);
 565   myIntegers.push_back(n1);
 566   myIntegers.push_back(n2);
 567   myIntegers.push_back(n3);
 568   myIntegers.push_back(n4);
 569   myIntegers.push_back(n12);
 570   myIntegers.push_back(n23);
 571   myIntegers.push_back(n34);
 572   myIntegers.push_back(n41);
 573   myIntegers.push_back(nCenter);
 574   myNumber++;
 575 }
 576
 577 //=======================================================================
 578 //function : AddVolume
 579 //purpose  :
 580 //=======================================================================
 581 void SMESHDS_Command::AddVolume(int NewVolID, int n1, int n2, int n3, int n4,
 582                                 int n12, int n23, int n31,
 583                                 int n14, int n24, int n34)
 584 {
 585   if (!myType == SMESHDS_AddQuadTetrahedron) {
 586     MESSAGE("SMESHDS_Command::AddVolume : Bad Type");
 587     return;
 588   }
 589   myIntegers.push_back(NewVolID);
 590   myIntegers.push_back(n1);
 591   myIntegers.push_back(n2);
 592   myIntegers.push_back(n3);
 593   myIntegers.push_back(n4);
 594   myIntegers.push_back(n12);
 595   myIntegers.push_back(n23);
 596   myIntegers.push_back(n31);
 597   myIntegers.push_back(n14);
 598   myIntegers.push_back(n24);
 599   myIntegers.push_back(n34);
 600   myNumber++;
 601 }
 602
 603 //=======================================================================
 604 //function : AddVolume
 605 //purpose  :
 606 //=======================================================================
 607 void SMESHDS_Command::AddVolume(int NewVolID, int n1, int n2,
 608                                 int n3, int n4, int n5,
 609                                 int n12, int n23, int n34, int n41,
 610                                 int n15, int n25, int n35, int n45)
 611 {
 612   if (!myType == SMESHDS_AddQuadPyramid) {
 613     MESSAGE("SMESHDS_Command::AddVolume : Bad Type");
 614     return;
 615   }
 616   myIntegers.push_back(NewVolID);
 617   myIntegers.push_back(n1);
 618   myIntegers.push_back(n2);
 619   myIntegers.push_back(n3);
 620   myIntegers.push_back(n4);
 621   myIntegers.push_back(n5);
 622   myIntegers.push_back(n12);
 623   myIntegers.push_back(n23);
 624   myIntegers.push_back(n34);
 625   myIntegers.push_back(n41);
 626   myIntegers.push_back(n15);
 627   myIntegers.push_back(n25);
 628   myIntegers.push_back(n35);
 629   myIntegers.push_back(n45);
 630   myNumber++;
 631 }
 632
 633 //=======================================================================
 634 //function : AddVolume
 635 //purpose  :
 636 //=======================================================================
 637 void SMESHDS_Command::AddVolume(int NewVolID, int n1, int n2,
 638                                 int n3, int n4, int n5,int n6,
 639                                 int n12, int n23, int n31,
 640                                 int n45, int n56, int n64,
 641                                 int n14, int n25, int n36)
 642 {
 643   if (!myType == SMESHDS_AddQuadPentahedron) {
 644     MESSAGE("SMESHDS_Command::AddVolume : Bad Type");
 645     return;
 646   }
 647   myIntegers.push_back(NewVolID);
 648   myIntegers.push_back(n1);
 649   myIntegers.push_back(n2);
 650   myIntegers.push_back(n3);
 651   myIntegers.push_back(n4);
 652   myIntegers.push_back(n5);
 653   myIntegers.push_back(n6);
 654   myIntegers.push_back(n12);
 655   myIntegers.push_back(n23);
 656   myIntegers.push_back(n31);
 657   myIntegers.push_back(n45);
 658   myIntegers.push_back(n56);
 659   myIntegers.push_back(n64);
 660   myIntegers.push_back(n14);
 661   myIntegers.push_back(n25);
 662   myIntegers.push_back(n36);
 663   myNumber++;
 664 }
 665
 666 //=======================================================================
 667 //function : AddVolume
 668 //purpose  :
 669 //=======================================================================
 670 void SMESHDS_Command::AddVolume(int NewVolID, int n1, int n2, int n3,
 671                                 int n4, int n5, int n6, int n7, int n8,
 672                                 int n12, int n23, int n34, int n41,
 673                                 int n56, int n67, int n78, int n85,
 674                                 int n15, int n26, int n37, int n48)
 675 {
 676   if (!myType == SMESHDS_AddQuadHexahedron) {
 677     MESSAGE("SMESHDS_Command::AddVolume : Bad Type");
 678     return;
 679   }
 680   myIntegers.push_back(NewVolID);
 681   myIntegers.push_back(n1);
 682   myIntegers.push_back(n2);
 683   myIntegers.push_back(n3);
 684   myIntegers.push_back(n4);
 685   myIntegers.push_back(n5);
 686   myIntegers.push_back(n6);
 687   myIntegers.push_back(n7);
 688   myIntegers.push_back(n8);
 689   myIntegers.push_back(n12);
 690   myIntegers.push_back(n23);
 691   myIntegers.push_back(n34);
 692   myIntegers.push_back(n41);
 693   myIntegers.push_back(n56);
 694   myIntegers.push_back(n67);
 695   myIntegers.push_back(n78);
 696   myIntegers.push_back(n85);
 697   myIntegers.push_back(n15);
 698   myIntegers.push_back(n26);
 699   myIntegers.push_back(n37);
 700   myIntegers.push_back(n48);
 701   myNumber++;
 702 }
 703
 704 //=======================================================================
 705 //function : AddVolume
 706 //purpose  :
 707 //=======================================================================
 708 void SMESHDS_Command::AddVolume(int NewVolID, int n1, int n2, int n3,
 709                                 int n4, int n5, int n6, int n7, int n8,
 710                                 int n12, int n23, int n34, int n41,
 711                                 int n56, int n67, int n78, int n85,
 712                                 int n15, int n26, int n37, int n48,
 713                                 int n1234,int n1256,int n2367,int n3478,
 714                                 int n1458,int n5678,int nCenter)
 715 {
 716   if (!myType == SMESHDS_AddQuadHexahedron) {
 717     MESSAGE("SMESHDS_Command::AddVolume : Bad Type");
 718     return;
 719   }
 720   myIntegers.push_back(NewVolID);
 721   myIntegers.push_back(n1);
 722   myIntegers.push_back(n2);
 723   myIntegers.push_back(n3);
 724   myIntegers.push_back(n4);
 725   myIntegers.push_back(n5);
 726   myIntegers.push_back(n6);
 727   myIntegers.push_back(n7);
 728   myIntegers.push_back(n8);
 729   myIntegers.push_back(n12);
 730   myIntegers.push_back(n23);
 731   myIntegers.push_back(n34);
 732   myIntegers.push_back(n41);
 733   myIntegers.push_back(n56);
 734   myIntegers.push_back(n67);
 735   myIntegers.push_back(n78);
 736   myIntegers.push_back(n85);
 737   myIntegers.push_back(n15);
 738   myIntegers.push_back(n26);
 739   myIntegers.push_back(n37);
 740   myIntegers.push_back(n48);
 741   myIntegers.push_back(n1234);
 742   myIntegers.push_back(n1256);
 743   myIntegers.push_back(n2367);
 744   myIntegers.push_back(n3478);
 745   myIntegers.push_back(n1458);
 746   myIntegers.push_back(n5678);
 747   myIntegers.push_back(nCenter);
 748   myNumber++;
 749 }
 750
 751 //================================================================================
 752 /*!
 753  * \brief Record adding a Ball
 754  */
 755 //================================================================================
 756
 757 void SMESHDS_Command::AddBall(int NewBallID, int node, double diameter)
 758 {
 759   if (!myType == SMESHDS_AddBall)
 760   {
 761     MESSAGE("SMESHDS_Command::SMESHDS_AddBall : Bad Type");
 762     return;
 763   }
 764   myIntegers.push_back(NewBallID);
 765   myIntegers.push_back(node);
 766   myReals.push_back(diameter);
 767   myNumber++;
 768 }