src/SMESHDS/SMESHDS_Command.cxx

   1 // Copyright (C) 2007-2019  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, or (at your option) any later version.
  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 : AddQuadPolygonalFace
 300 //purpose  :
 301 //=======================================================================
 302 void SMESHDS_Command::AddQuadPolygonalFace (const int               ElementID,
 303                                             const std::vector<int>& nodes_ids)
 304 {
 305   if ( myType != SMESHDS_AddQuadPolygon) {
 306     MESSAGE("SMESHDS_Command::AddQuadraticPolygonalFace : Bad Type");
 307     return;
 308   }
 309   myIntegers.push_back(ElementID);
 310
 311   int i, nbNodes = nodes_ids.size();
 312   myIntegers.push_back(nbNodes);
 313   for (i = 0; i < nbNodes; i++) {
 314     myIntegers.push_back(nodes_ids[i]);
 315   }
 316
 317   myNumber++;
 318 }
 319
 320 //=======================================================================
 321 //function : AddPolyhedralVolume
 322 //purpose  :
 323 //=======================================================================
 324 void SMESHDS_Command::AddPolyhedralVolume (const int               ElementID,
 325                                            const std::vector<int>& nodes_ids,
 326                                            const std::vector<int>& quantities)
 327 {
 328   if ( myType != SMESHDS_AddPolyhedron) {
 329     MESSAGE("SMESHDS_Command::AddPolyhedralVolume : Bad Type");
 330     return;
 331   }
 332   myIntegers.push_back(ElementID);
 333
 334   int i, nbNodes = nodes_ids.size();
 335   myIntegers.push_back(nbNodes);
 336   for (i = 0; i < nbNodes; i++) {
 337     myIntegers.push_back(nodes_ids[i]);
 338   }
 339
 340   int nbFaces = quantities.size();
 341   myIntegers.push_back(nbFaces);
 342   for (i = 0; i < nbFaces; i++) {
 343     myIntegers.push_back(quantities[i]);
 344   }
 345
 346   myNumber++;
 347 }
 348
 349 //=======================================================================
 350 //function :
 351 //purpose  :
 352 //=======================================================================
 353 void SMESHDS_Command::RemoveNode(int NodeID)
 354 {
 355         if ( myType != SMESHDS_RemoveNode)
 356         {
 357                 MESSAGE("SMESHDS_Command::RemoveNode : Bad Type");
 358                 return;
 359         }
 360         myIntegers.push_back(NodeID);
 361         myNumber++;
 362 }
 363
 364 //=======================================================================
 365 //function :
 366 //purpose  :
 367 //=======================================================================
 368 void SMESHDS_Command::RemoveElement(int ElementID)
 369 {
 370         if ( myType != SMESHDS_RemoveElement)
 371         {
 372                 MESSAGE("SMESHDS_Command::RemoveElement : Bad Type");
 373                 return;
 374         }
 375         myIntegers.push_back(ElementID);
 376         myNumber++;
 377 }
 378
 379 //=======================================================================
 380 //function : ChangeElementNodes
 381 //purpose  :
 382 //=======================================================================
 383
 384 void SMESHDS_Command::ChangeElementNodes(int ElementID, int nodes[], int nbnodes)
 385 {
 386   if ( myType != SMESHDS_ChangeElementNodes)
 387   {
 388     MESSAGE("SMESHDS_Command::ChangeElementNodes : Bad Type");
 389     return;
 390   }
 391   myIntegers.push_back(ElementID);
 392   myIntegers.push_back(nbnodes);
 393   for ( int i = 0; i < nbnodes; i++ )
 394     myIntegers.push_back( nodes[ i ] );
 395
 396   myNumber++;
 397 }
 398
 399 //=======================================================================
 400 //function : ChangePolyhedronNodes
 401 //purpose  :
 402 //=======================================================================
 403 void SMESHDS_Command::ChangePolyhedronNodes (const int               ElementID,
 404                                              const std::vector<int>& nodes_ids,
 405                                              const std::vector<int>& quantities)
 406 {
 407   if (myType != SMESHDS_ChangePolyhedronNodes)
 408   {
 409     MESSAGE("SMESHDS_Command::ChangePolyhedronNodes : Bad Type");
 410     return;
 411   }
 412   myIntegers.push_back(ElementID);
 413
 414   int i, nbNodes = nodes_ids.size();
 415   myIntegers.push_back(nbNodes);
 416   for (i = 0; i < nbNodes; i++) {
 417     myIntegers.push_back(nodes_ids[i]);
 418   }
 419
 420   int nbFaces = quantities.size();
 421   myIntegers.push_back(nbFaces);
 422   for (i = 0; i < nbFaces; i++) {
 423     myIntegers.push_back(quantities[i]);
 424   }
 425
 426   myNumber++;
 427 }
 428
 429 //=======================================================================
 430 //function : Renumber
 431 //purpose  :
 432 //=======================================================================
 433
 434 void SMESHDS_Command::Renumber (const bool isNodes, const int startID, const int deltaID)
 435 {
 436   if ( myType != SMESHDS_Renumber)
 437   {
 438     MESSAGE("SMESHDS_Command::Renumber : Bad Type");
 439     return;
 440   }
 441   myIntegers.push_back(isNodes);
 442   myIntegers.push_back(startID);
 443   myIntegers.push_back(deltaID);
 444   myNumber++;
 445 }
 446
 447 //=======================================================================
 448 //function :
 449 //purpose  :
 450 //=======================================================================
 451 SMESHDS_CommandType SMESHDS_Command::GetType()
 452 {
 453         return myType;
 454 }
 455
 456 //=======================================================================
 457 //function :
 458 //purpose  :
 459 //=======================================================================
 460 int SMESHDS_Command::GetNumber()
 461 {
 462         return myNumber;
 463 }
 464
 465 //=======================================================================
 466 //function :
 467 //purpose  :
 468 //=======================================================================
 469 const list < int >&SMESHDS_Command::GetIndexes()
 470 {
 471         return myIntegers;
 472 }
 473
 474 //=======================================================================
 475 //function :
 476 //purpose  :
 477 //=======================================================================
 478 const list < double >&SMESHDS_Command::GetCoords()
 479 {
 480         return myReals;
 481 }
 482
 483
 484 //********************************************************************
 485 //*****             Methods for quadratic elements              ******
 486 //********************************************************************
 487
 488 //=======================================================================
 489 //function : AddEdge
 490 //purpose  :
 491 //=======================================================================
 492 void SMESHDS_Command::AddEdge(int NewEdgeID, int n1, int n2, int n12)
 493 {
 494   if ( myType != SMESHDS_AddQuadEdge) {
 495     MESSAGE("SMESHDS_Command::AddEdge : Bad Type");
 496     return;
 497   }
 498   myIntegers.push_back(NewEdgeID);
 499   myIntegers.push_back(n1);
 500   myIntegers.push_back(n2);
 501   myIntegers.push_back(n12);
 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)
 512 {
 513   if ( myType != SMESHDS_AddQuadTriangle) {
 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   myNumber++;
 525 }
 526
 527 //=======================================================================
 528 //function : AddFace
 529 //purpose  :
 530 //=======================================================================
 531 void SMESHDS_Command::AddFace(int NewFaceID,
 532                               int n1, int n2, int n3,
 533                               int n12, int n23, int n31, int nCenter)
 534 {
 535   if ( myType != SMESHDS_AddBiQuadTriangle) {
 536     MESSAGE("SMESHDS_Command::AddFace : Bad Type");
 537     return;
 538   }
 539   myIntegers.push_back(NewFaceID);
 540   myIntegers.push_back(n1);
 541   myIntegers.push_back(n2);
 542   myIntegers.push_back(n3);
 543   myIntegers.push_back(n12);
 544   myIntegers.push_back(n23);
 545   myIntegers.push_back(n31);
 546   myIntegers.push_back(nCenter);
 547   myNumber++;
 548 }
 549
 550 //=======================================================================
 551 //function : AddFace
 552 //purpose  :
 553 //=======================================================================
 554 void SMESHDS_Command::AddFace(int NewFaceID,
 555                               int n1, int n2, int n3, int n4,
 556                               int n12, int n23, int n34, int n41)
 557 {
 558   if ( myType != SMESHDS_AddQuadQuadrangle) {
 559     MESSAGE("SMESHDS_Command::AddFace : Bad Type");
 560     return;
 561   }
 562   myIntegers.push_back(NewFaceID);
 563   myIntegers.push_back(n1);
 564   myIntegers.push_back(n2);
 565   myIntegers.push_back(n3);
 566   myIntegers.push_back(n4);
 567   myIntegers.push_back(n12);
 568   myIntegers.push_back(n23);
 569   myIntegers.push_back(n34);
 570   myIntegers.push_back(n41);
 571   myNumber++;
 572 }
 573
 574 //=======================================================================
 575 //function : AddFace
 576 //purpose  :
 577 //=======================================================================
 578 void SMESHDS_Command::AddFace(int NewFaceID,
 579                               int n1, int n2, int n3, int n4,
 580                               int n12, int n23, int n34, int n41, int nCenter)
 581 {
 582   if (myType != SMESHDS_AddBiQuadQuadrangle) {
 583     MESSAGE("SMESHDS_Command::AddFace : Bad Type");
 584     return;
 585   }
 586   myIntegers.push_back(NewFaceID);
 587   myIntegers.push_back(n1);
 588   myIntegers.push_back(n2);
 589   myIntegers.push_back(n3);
 590   myIntegers.push_back(n4);
 591   myIntegers.push_back(n12);
 592   myIntegers.push_back(n23);
 593   myIntegers.push_back(n34);
 594   myIntegers.push_back(n41);
 595   myIntegers.push_back(nCenter);
 596   myNumber++;
 597 }
 598
 599 //=======================================================================
 600 //function : AddVolume
 601 //purpose  :
 602 //=======================================================================
 603 void SMESHDS_Command::AddVolume(int NewVolID, int n1, int n2, int n3, int n4,
 604                                 int n12, int n23, int n31,
 605                                 int n14, int n24, int n34)
 606 {
 607   if ( myType != SMESHDS_AddQuadTetrahedron) {
 608     MESSAGE("SMESHDS_Command::AddVolume : Bad Type");
 609     return;
 610   }
 611   myIntegers.push_back(NewVolID);
 612   myIntegers.push_back(n1);
 613   myIntegers.push_back(n2);
 614   myIntegers.push_back(n3);
 615   myIntegers.push_back(n4);
 616   myIntegers.push_back(n12);
 617   myIntegers.push_back(n23);
 618   myIntegers.push_back(n31);
 619   myIntegers.push_back(n14);
 620   myIntegers.push_back(n24);
 621   myIntegers.push_back(n34);
 622   myNumber++;
 623 }
 624
 625 //=======================================================================
 626 //function : AddVolume
 627 //purpose  :
 628 //=======================================================================
 629 void SMESHDS_Command::AddVolume(int NewVolID, int n1, int n2,
 630                                 int n3, int n4, int n5,
 631                                 int n12, int n23, int n34, int n41,
 632                                 int n15, int n25, int n35, int n45)
 633 {
 634   if ( myType != SMESHDS_AddQuadPyramid) {
 635     MESSAGE("SMESHDS_Command::AddVolume : Bad Type");
 636     return;
 637   }
 638   myIntegers.push_back(NewVolID);
 639   myIntegers.push_back(n1);
 640   myIntegers.push_back(n2);
 641   myIntegers.push_back(n3);
 642   myIntegers.push_back(n4);
 643   myIntegers.push_back(n5);
 644   myIntegers.push_back(n12);
 645   myIntegers.push_back(n23);
 646   myIntegers.push_back(n34);
 647   myIntegers.push_back(n41);
 648   myIntegers.push_back(n15);
 649   myIntegers.push_back(n25);
 650   myIntegers.push_back(n35);
 651   myIntegers.push_back(n45);
 652   myNumber++;
 653 }
 654
 655 //=======================================================================
 656 //function : AddVolume
 657 //purpose  :
 658 //=======================================================================
 659 void SMESHDS_Command::AddVolume(int NewVolID, int n1, int n2,
 660                                 int n3, int n4, int n5,int n6,
 661                                 int n12, int n23, int n31,
 662                                 int n45, int n56, int n64,
 663                                 int n14, int n25, int n36)
 664 {
 665   if ( myType != SMESHDS_AddQuadPentahedron) {
 666     MESSAGE("SMESHDS_Command::AddVolume : Bad Type");
 667     return;
 668   }
 669   myIntegers.push_back(NewVolID);
 670   myIntegers.push_back(n1);
 671   myIntegers.push_back(n2);
 672   myIntegers.push_back(n3);
 673   myIntegers.push_back(n4);
 674   myIntegers.push_back(n5);
 675   myIntegers.push_back(n6);
 676   myIntegers.push_back(n12);
 677   myIntegers.push_back(n23);
 678   myIntegers.push_back(n31);
 679   myIntegers.push_back(n45);
 680   myIntegers.push_back(n56);
 681   myIntegers.push_back(n64);
 682   myIntegers.push_back(n14);
 683   myIntegers.push_back(n25);
 684   myIntegers.push_back(n36);
 685   myNumber++;
 686 }
 687 //=======================================================================
 688 //function : AddVolume
 689 //purpose  :
 690 //=======================================================================
 691 void SMESHDS_Command::AddVolume(int NewVolID, int n1, int n2,
 692                                 int n3, int n4, int n5,int n6,
 693                                 int n12, int n23, int n31,
 694                                 int n45, int n56, int n64,
 695                                 int n14, int n25, int n36,
 696                                 int n1245, int n2356, int n1346)
 697 {
 698   if ( myType != SMESHDS_AddBiQuadPentahedron) {
 699     MESSAGE("SMESHDS_Command::AddVolume : Bad Type");
 700     return;
 701   }
 702   myIntegers.push_back(NewVolID);
 703   myIntegers.push_back(n1);
 704   myIntegers.push_back(n2);
 705   myIntegers.push_back(n3);
 706   myIntegers.push_back(n4);
 707   myIntegers.push_back(n5);
 708   myIntegers.push_back(n6);
 709   myIntegers.push_back(n12);
 710   myIntegers.push_back(n23);
 711   myIntegers.push_back(n31);
 712   myIntegers.push_back(n45);
 713   myIntegers.push_back(n56);
 714   myIntegers.push_back(n64);
 715   myIntegers.push_back(n14);
 716   myIntegers.push_back(n25);
 717   myIntegers.push_back(n36);
 718   myIntegers.push_back(n1245);
 719   myIntegers.push_back(n2356);
 720   myIntegers.push_back(n1346);
 721   myNumber++;
 722 }
 723
 724
 725 //=======================================================================
 726 //function : AddVolume
 727 //purpose  :
 728 //=======================================================================
 729 void SMESHDS_Command::AddVolume(int NewVolID, int n1, int n2, int n3,
 730                                 int n4, int n5, int n6, int n7, int n8,
 731                                 int n12, int n23, int n34, int n41,
 732                                 int n56, int n67, int n78, int n85,
 733                                 int n15, int n26, int n37, int n48)
 734 {
 735   if ( myType != SMESHDS_AddQuadHexahedron) {
 736     MESSAGE("SMESHDS_Command::AddVolume : Bad Type");
 737     return;
 738   }
 739   myIntegers.push_back(NewVolID);
 740   myIntegers.push_back(n1);
 741   myIntegers.push_back(n2);
 742   myIntegers.push_back(n3);
 743   myIntegers.push_back(n4);
 744   myIntegers.push_back(n5);
 745   myIntegers.push_back(n6);
 746   myIntegers.push_back(n7);
 747   myIntegers.push_back(n8);
 748   myIntegers.push_back(n12);
 749   myIntegers.push_back(n23);
 750   myIntegers.push_back(n34);
 751   myIntegers.push_back(n41);
 752   myIntegers.push_back(n56);
 753   myIntegers.push_back(n67);
 754   myIntegers.push_back(n78);
 755   myIntegers.push_back(n85);
 756   myIntegers.push_back(n15);
 757   myIntegers.push_back(n26);
 758   myIntegers.push_back(n37);
 759   myIntegers.push_back(n48);
 760   myNumber++;
 761 }
 762
 763 //=======================================================================
 764 //function : AddVolume
 765 //purpose  :
 766 //=======================================================================
 767 void SMESHDS_Command::AddVolume(int NewVolID, int n1, int n2, int n3,
 768                                 int n4, int n5, int n6, int n7, int n8,
 769                                 int n12, int n23, int n34, int n41,
 770                                 int n56, int n67, int n78, int n85,
 771                                 int n15, int n26, int n37, int n48,
 772                                 int n1234,int n1256,int n2367,int n3478,
 773                                 int n1458,int n5678,int nCenter)
 774 {
 775   if ( myType != SMESHDS_AddTriQuadHexa) {
 776     MESSAGE("SMESHDS_Command::AddVolume : Bad Type");
 777     return;
 778   }
 779   myIntegers.push_back(NewVolID);
 780   myIntegers.push_back(n1);
 781   myIntegers.push_back(n2);
 782   myIntegers.push_back(n3);
 783   myIntegers.push_back(n4);
 784   myIntegers.push_back(n5);
 785   myIntegers.push_back(n6);
 786   myIntegers.push_back(n7);
 787   myIntegers.push_back(n8);
 788   myIntegers.push_back(n12);
 789   myIntegers.push_back(n23);
 790   myIntegers.push_back(n34);
 791   myIntegers.push_back(n41);
 792   myIntegers.push_back(n56);
 793   myIntegers.push_back(n67);
 794   myIntegers.push_back(n78);
 795   myIntegers.push_back(n85);
 796   myIntegers.push_back(n15);
 797   myIntegers.push_back(n26);
 798   myIntegers.push_back(n37);
 799   myIntegers.push_back(n48);
 800   myIntegers.push_back(n1234);
 801   myIntegers.push_back(n1256);
 802   myIntegers.push_back(n2367);
 803   myIntegers.push_back(n3478);
 804   myIntegers.push_back(n1458);
 805   myIntegers.push_back(n5678);
 806   myIntegers.push_back(nCenter);
 807   myNumber++;
 808 }
 809
 810 //================================================================================
 811 /*!
 812  * \brief Record adding a Ball
 813  */
 814 //================================================================================
 815
 816 void SMESHDS_Command::AddBall(int NewBallID, int node, double diameter)
 817 {
 818   if ( myType != SMESHDS_AddBall)
 819   {
 820     MESSAGE("SMESHDS_Command::SMESHDS_AddBall : Bad Type");
 821     return;
 822   }
 823   myIntegers.push_back(NewBallID);
 824   myIntegers.push_back(node);
 825   myReals.push_back(diameter);
 826   myNumber++;
 827 }