Back to index

salome-smesh  6.5.0
SMESHDS_Command.cxx
Go to the documentation of this file.
00001 // Copyright (C) 2007-2012  CEA/DEN, EDF R&D, OPEN CASCADE
00002 //
00003 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
00004 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
00005 //
00006 // This library is free software; you can redistribute it and/or
00007 // modify it under the terms of the GNU Lesser General Public
00008 // License as published by the Free Software Foundation; either
00009 // version 2.1 of the License.
00010 //
00011 // This library is distributed in the hope that it will be useful,
00012 // but WITHOUT ANY WARRANTY; without even the implied warranty of
00013 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00014 // Lesser General Public License for more details.
00015 //
00016 // You should have received a copy of the GNU Lesser General Public
00017 // License along with this library; if not, write to the Free Software
00018 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
00019 //
00020 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
00021 //
00022 
00023 //  SMESH SMESHDS : management of mesh data and SMESH document
00024 //  File   : SMESH_Command.cxx
00025 //  Author : Yves FRICAUD, OCC
00026 //  Module : SMESH
00027 //  $Header: 
00028 //
00029 #include "SMESHDS_Command.hxx"
00030 
00031 #include "utilities.h"
00032 
00033 using namespace std;
00034 
00035 //=======================================================================
00036 //function : Constructor
00037 //purpose  : 
00038 //=======================================================================
00039 SMESHDS_Command::SMESHDS_Command(const SMESHDS_CommandType aType):myType(aType),
00040 myNumber(0)
00041 {
00042 }
00043 
00044 //=======================================================================
00045 //function : Destructor
00046 //purpose  : 
00047 //=======================================================================
00048 SMESHDS_Command::~SMESHDS_Command()
00049 {
00050 }
00051 
00052 //=======================================================================
00053 //function : 
00054 //purpose  : 
00055 //=======================================================================
00056 void SMESHDS_Command::AddNode(int NewNodeID, double x, double y, double z)
00057 {
00058         if (!myType == SMESHDS_AddNode)
00059         {
00060                 MESSAGE("SMESHDS_Command::AddNode : Bad Type");
00061                 return;
00062         }
00063         myIntegers.push_back(NewNodeID);
00064         myReals.push_back(x);
00065         myReals.push_back(y);
00066         myReals.push_back(z);
00067         myNumber++;
00068 }
00069 
00070 //=======================================================================
00071 //function : 
00072 //purpose  : 
00073 //=======================================================================
00074 void SMESHDS_Command::MoveNode(int NodeID, double x, double y, double z)
00075 {
00076         if (!myType == SMESHDS_MoveNode)
00077         {
00078                 MESSAGE("SMESHDS_Command::MoveNode : Bad Type");
00079                 return;
00080         }
00081         myIntegers.push_back(NodeID);
00082         myReals.push_back(x);
00083         myReals.push_back(y);
00084         myReals.push_back(z);
00085         myNumber++;
00086 }
00087 
00088 //=======================================================================
00089 //function : 
00090 //purpose  : 
00091 //=======================================================================
00092 void SMESHDS_Command::Add0DElement(int New0DElementID, int idnode)
00093 {
00094   if (!myType == SMESHDS_Add0DElement)
00095   {
00096     MESSAGE("SMESHDS_Command::Add0DElement : Bad Type");
00097     return;
00098   }
00099   myIntegers.push_back(New0DElementID);
00100   myIntegers.push_back(idnode);
00101   myNumber++;
00102 }
00103 
00104 //=======================================================================
00105 //function : 
00106 //purpose  : 
00107 //=======================================================================
00108 void SMESHDS_Command::AddEdge(int NewEdgeID, int idnode1, int idnode2)
00109 {
00110         if (!myType == SMESHDS_AddEdge)
00111         {
00112                 MESSAGE("SMESHDS_Command::AddEdge : Bad Type");
00113                 return;
00114         }
00115         myIntegers.push_back(NewEdgeID);
00116         myIntegers.push_back(idnode1);
00117         myIntegers.push_back(idnode2);
00118         myNumber++;
00119 }
00120 
00121 //=======================================================================
00122 //function : 
00123 //purpose  : 
00124 //=======================================================================
00125 void SMESHDS_Command::AddFace(int NewFaceID,
00126         int idnode1, int idnode2, int idnode3)
00127 {
00128         if (!myType == SMESHDS_AddTriangle)
00129         {
00130                 MESSAGE("SMESHDS_Command::AddFace : Bad Type");
00131                 return;
00132         }
00133         myIntegers.push_back(NewFaceID);
00134         myIntegers.push_back(idnode1);
00135         myIntegers.push_back(idnode2);
00136         myIntegers.push_back(idnode3);
00137         myNumber++;
00138 }
00139 
00140 //=======================================================================
00141 //function : 
00142 //purpose  : 
00143 //=======================================================================
00144 void SMESHDS_Command::AddFace(int NewFaceID,
00145         int idnode1, int idnode2, int idnode3, int idnode4)
00146 {
00147         if (!myType == SMESHDS_AddQuadrangle)
00148         {
00149                 MESSAGE("SMESHDS_Command::AddFace : Bad Type");
00150                 return;
00151         }
00152         myIntegers.push_back(NewFaceID);
00153         myIntegers.push_back(idnode1);
00154         myIntegers.push_back(idnode2);
00155         myIntegers.push_back(idnode3);
00156         myIntegers.push_back(idnode4);
00157         myNumber++;
00158 }
00159 
00160 //=======================================================================
00161 //function : 
00162 //purpose  : 
00163 //=======================================================================
00164 void SMESHDS_Command::AddVolume(int NewVolID,
00165         int idnode1, int idnode2, int idnode3, int idnode4)
00166 {
00167         if (!myType == SMESHDS_AddTetrahedron)
00168         {
00169                 MESSAGE("SMESHDS_Command::AddVolume : Bad Type");
00170                 return;
00171         }
00172         myIntegers.push_back(NewVolID);
00173         myIntegers.push_back(idnode1);
00174         myIntegers.push_back(idnode2);
00175         myIntegers.push_back(idnode3);
00176         myIntegers.push_back(idnode4);
00177         myNumber++;
00178 }
00179 
00180 //=======================================================================
00181 //function : 
00182 //purpose  : 
00183 //=======================================================================
00184 void SMESHDS_Command::AddVolume(int NewVolID,
00185         int idnode1, int idnode2, int idnode3, int idnode4, int idnode5)
00186 {
00187         if (!myType == SMESHDS_AddPyramid)
00188         {
00189                 MESSAGE("SMESHDS_Command::AddVolume : Bad Type");
00190                 return;
00191         }
00192         myIntegers.push_back(NewVolID);
00193         myIntegers.push_back(idnode1);
00194         myIntegers.push_back(idnode2);
00195         myIntegers.push_back(idnode3);
00196         myIntegers.push_back(idnode4);
00197         myIntegers.push_back(idnode5);
00198         myNumber++;
00199 }
00200 
00201 //=======================================================================
00202 //function : 
00203 //purpose  : 
00204 //=======================================================================
00205 void SMESHDS_Command::AddVolume(int NewVolID,
00206         int idnode1,
00207         int idnode2, int idnode3, int idnode4, int idnode5, int idnode6)
00208 {
00209         if (!myType == SMESHDS_AddPrism)
00210         {
00211                 MESSAGE("SMESHDS_Command::AddVolume : Bad Type");
00212                 return;
00213         }
00214         myIntegers.push_back(NewVolID);
00215         myIntegers.push_back(idnode1);
00216         myIntegers.push_back(idnode2);
00217         myIntegers.push_back(idnode3);
00218         myIntegers.push_back(idnode4);
00219         myIntegers.push_back(idnode5);
00220         myIntegers.push_back(idnode6);
00221         myNumber++;
00222 }
00223 
00224 //=======================================================================
00225 //function : 
00226 //purpose  : 
00227 //=======================================================================
00228 void SMESHDS_Command::AddVolume(int NewVolID,
00229         int idnode1,
00230         int idnode2,
00231         int idnode3,
00232         int idnode4, int idnode5, int idnode6, int idnode7, int idnode8)
00233 {
00234         if (!myType == SMESHDS_AddHexahedron)
00235         {
00236                 MESSAGE("SMESHDS_Command::AddVolume : Bad Type");
00237                 return;
00238         }
00239         myIntegers.push_back(NewVolID);
00240         myIntegers.push_back(idnode1);
00241         myIntegers.push_back(idnode2);
00242         myIntegers.push_back(idnode3);
00243         myIntegers.push_back(idnode4);
00244         myIntegers.push_back(idnode5);
00245         myIntegers.push_back(idnode6);
00246         myIntegers.push_back(idnode7);
00247         myIntegers.push_back(idnode8);
00248         myNumber++;
00249 }
00250 
00251 void SMESHDS_Command::AddVolume(int NewVolID,
00252                                 int idnode1,int idnode2,int idnode3,int idnode4,
00253                                 int idnode5, int idnode6, int idnode7, int idnode8,
00254                                 int idnode9, int idnode10, int idnode11, int idnode12)
00255 {
00256   if (myType != SMESHDS_AddHexagonalPrism)
00257   {
00258     MESSAGE("SMESHDS_Command::AddVolume : Bad Type");
00259     return;
00260   }
00261   myIntegers.push_back(NewVolID);
00262   myIntegers.push_back(idnode1);
00263   myIntegers.push_back(idnode2);
00264   myIntegers.push_back(idnode3);
00265   myIntegers.push_back(idnode4);
00266   myIntegers.push_back(idnode5);
00267   myIntegers.push_back(idnode6);
00268   myIntegers.push_back(idnode7);
00269   myIntegers.push_back(idnode8);
00270   myIntegers.push_back(idnode9);
00271   myIntegers.push_back(idnode10);
00272   myIntegers.push_back(idnode11);
00273   myIntegers.push_back(idnode12);
00274   myNumber++;
00275 }
00276 
00277 //=======================================================================
00278 //function : AddPolygonalFace
00279 //purpose  : 
00280 //=======================================================================
00281 void SMESHDS_Command::AddPolygonalFace (const int        ElementID,
00282                                         std::vector<int> nodes_ids)
00283 {
00284   if (!myType == SMESHDS_AddPolygon) {
00285     MESSAGE("SMESHDS_Command::AddPolygonalFace : Bad Type");
00286     return;
00287   }
00288   myIntegers.push_back(ElementID);
00289 
00290   int i, nbNodes = nodes_ids.size();
00291   myIntegers.push_back(nbNodes);
00292   for (i = 0; i < nbNodes; i++) {
00293     myIntegers.push_back(nodes_ids[i]);
00294   }
00295 
00296   myNumber++;
00297 }
00298 
00299 //=======================================================================
00300 //function : AddPolyhedralVolume
00301 //purpose  : 
00302 //=======================================================================
00303 void SMESHDS_Command::AddPolyhedralVolume (const int        ElementID,
00304                                            std::vector<int> nodes_ids,
00305                                            std::vector<int> quantities)
00306 {
00307   if (!myType == SMESHDS_AddPolyhedron) {
00308     MESSAGE("SMESHDS_Command::AddPolyhedralVolume : Bad Type");
00309     return;
00310   }
00311   myIntegers.push_back(ElementID);
00312 
00313   int i, nbNodes = nodes_ids.size();
00314   myIntegers.push_back(nbNodes);
00315   for (i = 0; i < nbNodes; i++) {
00316     myIntegers.push_back(nodes_ids[i]);
00317   }
00318 
00319   int nbFaces = quantities.size();
00320   myIntegers.push_back(nbFaces);
00321   for (i = 0; i < nbFaces; i++) {
00322     myIntegers.push_back(quantities[i]);
00323   }
00324 
00325   myNumber++;
00326 }
00327 
00328 //=======================================================================
00329 //function : 
00330 //purpose  : 
00331 //=======================================================================
00332 void SMESHDS_Command::RemoveNode(int NodeID)
00333 {
00334         if (!myType == SMESHDS_RemoveNode)
00335         {
00336                 MESSAGE("SMESHDS_Command::RemoveNode : Bad Type");
00337                 return;
00338         }
00339         myIntegers.push_back(NodeID);
00340         myNumber++;
00341 }
00342 
00343 //=======================================================================
00344 //function : 
00345 //purpose  : 
00346 //=======================================================================
00347 void SMESHDS_Command::RemoveElement(int ElementID)
00348 {
00349         if (!myType == SMESHDS_RemoveElement)
00350         {
00351                 MESSAGE("SMESHDS_Command::RemoveElement : Bad Type");
00352                 return;
00353         }
00354         myIntegers.push_back(ElementID);
00355         myNumber++;
00356 }
00357 
00358 //=======================================================================
00359 //function : ChangeElementNodes
00360 //purpose  : 
00361 //=======================================================================
00362 
00363 void SMESHDS_Command::ChangeElementNodes(int ElementID, int nodes[], int nbnodes)
00364 {
00365   if (!myType == SMESHDS_ChangeElementNodes)
00366   {
00367     MESSAGE("SMESHDS_Command::ChangeElementNodes : Bad Type");
00368     return;
00369   }
00370   myIntegers.push_back(ElementID);
00371   myIntegers.push_back(nbnodes);
00372   for ( int i = 0; i < nbnodes; i++ )
00373     myIntegers.push_back( nodes[ i ] );
00374 
00375   myNumber++;
00376 }
00377 
00378 //=======================================================================
00379 //function : ChangePolyhedronNodes
00380 //purpose  : 
00381 //=======================================================================
00382 void SMESHDS_Command::ChangePolyhedronNodes (const int ElementID,
00383                                              std::vector<int> nodes_ids,
00384                                              std::vector<int> quantities)
00385 {
00386   if (myType != SMESHDS_ChangePolyhedronNodes)
00387   {
00388     MESSAGE("SMESHDS_Command::ChangePolyhedronNodes : Bad Type");
00389     return;
00390   }
00391   myIntegers.push_back(ElementID);
00392 
00393   int i, nbNodes = nodes_ids.size();
00394   myIntegers.push_back(nbNodes);
00395   for (i = 0; i < nbNodes; i++) {
00396     myIntegers.push_back(nodes_ids[i]);
00397   }
00398 
00399   int nbFaces = quantities.size();
00400   myIntegers.push_back(nbFaces);
00401   for (i = 0; i < nbFaces; i++) {
00402     myIntegers.push_back(quantities[i]);
00403   }
00404 
00405   myNumber++;
00406 }
00407 
00408 //=======================================================================
00409 //function : Renumber
00410 //purpose  : 
00411 //=======================================================================
00412 
00413 void SMESHDS_Command::Renumber (const bool isNodes, const int startID, const int deltaID)
00414 {
00415   if (!myType == SMESHDS_Renumber)
00416   {
00417     MESSAGE("SMESHDS_Command::Renumber : Bad Type");
00418     return;
00419   }
00420   myIntegers.push_back(isNodes);
00421   myIntegers.push_back(startID);
00422   myIntegers.push_back(deltaID);
00423   myNumber++;
00424 }
00425 
00426 //=======================================================================
00427 //function : 
00428 //purpose  : 
00429 //=======================================================================
00430 SMESHDS_CommandType SMESHDS_Command::GetType()
00431 {
00432         return myType;
00433 }
00434 
00435 //=======================================================================
00436 //function : 
00437 //purpose  : 
00438 //=======================================================================
00439 int SMESHDS_Command::GetNumber()
00440 {
00441         return myNumber;
00442 }
00443 
00444 //=======================================================================
00445 //function : 
00446 //purpose  : 
00447 //=======================================================================
00448 const list < int >&SMESHDS_Command::GetIndexes()
00449 {
00450         return myIntegers;
00451 }
00452 
00453 //=======================================================================
00454 //function : 
00455 //purpose  : 
00456 //=======================================================================
00457 const list < double >&SMESHDS_Command::GetCoords()
00458 {
00459         return myReals;
00460 }
00461 
00462 
00463 //********************************************************************
00464 //*****             Methods for quadratic elements              ******
00465 //********************************************************************
00466 
00467 //=======================================================================
00468 //function : AddEdge
00469 //purpose  : 
00470 //=======================================================================
00471 void SMESHDS_Command::AddEdge(int NewEdgeID, int n1, int n2, int n12)
00472 {
00473   if (!myType == SMESHDS_AddQuadEdge) {
00474     MESSAGE("SMESHDS_Command::AddEdge : Bad Type");
00475     return;
00476   }
00477   myIntegers.push_back(NewEdgeID);
00478   myIntegers.push_back(n1);
00479   myIntegers.push_back(n2);
00480   myIntegers.push_back(n12);
00481   myNumber++;
00482 }
00483 
00484 //=======================================================================
00485 //function : AddFace
00486 //purpose  : 
00487 //=======================================================================
00488 void SMESHDS_Command::AddFace(int NewFaceID,
00489                               int n1, int n2, int n3,
00490                               int n12, int n23, int n31)
00491 {
00492   if (!myType == SMESHDS_AddQuadTriangle) {
00493     MESSAGE("SMESHDS_Command::AddFace : Bad Type");
00494     return;
00495   }
00496   myIntegers.push_back(NewFaceID);
00497   myIntegers.push_back(n1);
00498   myIntegers.push_back(n2);
00499   myIntegers.push_back(n3);
00500   myIntegers.push_back(n12);
00501   myIntegers.push_back(n23);
00502   myIntegers.push_back(n31);
00503   myNumber++;
00504 }
00505 
00506 //=======================================================================
00507 //function : AddFace
00508 //purpose  : 
00509 //=======================================================================
00510 void SMESHDS_Command::AddFace(int NewFaceID,
00511                               int n1, int n2, int n3, int n4,
00512                               int n12, int n23, int n34, int n41)
00513 {
00514   if (!myType == SMESHDS_AddQuadQuadrangle) {
00515     MESSAGE("SMESHDS_Command::AddFace : Bad Type");
00516     return;
00517   }
00518   myIntegers.push_back(NewFaceID);
00519   myIntegers.push_back(n1);
00520   myIntegers.push_back(n2);
00521   myIntegers.push_back(n3);
00522   myIntegers.push_back(n4);
00523   myIntegers.push_back(n12);
00524   myIntegers.push_back(n23);
00525   myIntegers.push_back(n34);
00526   myIntegers.push_back(n41);
00527   myNumber++;
00528 }
00529 
00530 //=======================================================================
00531 //function : AddFace
00532 //purpose  : 
00533 //=======================================================================
00534 void SMESHDS_Command::AddFace(int NewFaceID,
00535                               int n1, int n2, int n3, int n4,
00536                               int n12, int n23, int n34, int n41, int nCenter)
00537 {
00538   if (myType != SMESHDS_AddBiQuadQuadrangle) {
00539     MESSAGE("SMESHDS_Command::AddFace : Bad Type");
00540     return;
00541   }
00542   myIntegers.push_back(NewFaceID);
00543   myIntegers.push_back(n1);
00544   myIntegers.push_back(n2);
00545   myIntegers.push_back(n3);
00546   myIntegers.push_back(n4);
00547   myIntegers.push_back(n12);
00548   myIntegers.push_back(n23);
00549   myIntegers.push_back(n34);
00550   myIntegers.push_back(n41);
00551   myIntegers.push_back(nCenter);
00552   myNumber++;
00553 }
00554 
00555 //=======================================================================
00556 //function : AddVolume
00557 //purpose  : 
00558 //=======================================================================
00559 void SMESHDS_Command::AddVolume(int NewVolID, int n1, int n2, int n3, int n4,
00560                                 int n12, int n23, int n31,
00561                                 int n14, int n24, int n34)
00562 {
00563   if (!myType == SMESHDS_AddQuadTetrahedron) {
00564     MESSAGE("SMESHDS_Command::AddVolume : Bad Type");
00565     return;
00566   }
00567   myIntegers.push_back(NewVolID);
00568   myIntegers.push_back(n1);
00569   myIntegers.push_back(n2);
00570   myIntegers.push_back(n3);
00571   myIntegers.push_back(n4);
00572   myIntegers.push_back(n12);
00573   myIntegers.push_back(n23);
00574   myIntegers.push_back(n31);
00575   myIntegers.push_back(n14);
00576   myIntegers.push_back(n24);
00577   myIntegers.push_back(n34);
00578   myNumber++;
00579 }
00580 
00581 //=======================================================================
00582 //function : AddVolume
00583 //purpose  : 
00584 //=======================================================================
00585 void SMESHDS_Command::AddVolume(int NewVolID, int n1, int n2,
00586                                 int n3, int n4, int n5,
00587                                 int n12, int n23, int n34, int n41,
00588                                 int n15, int n25, int n35, int n45)
00589 {
00590   if (!myType == SMESHDS_AddQuadPyramid) {
00591     MESSAGE("SMESHDS_Command::AddVolume : Bad Type");
00592     return;
00593   }
00594   myIntegers.push_back(NewVolID);
00595   myIntegers.push_back(n1);
00596   myIntegers.push_back(n2);
00597   myIntegers.push_back(n3);
00598   myIntegers.push_back(n4);
00599   myIntegers.push_back(n5);
00600   myIntegers.push_back(n12);
00601   myIntegers.push_back(n23);
00602   myIntegers.push_back(n34);
00603   myIntegers.push_back(n41);
00604   myIntegers.push_back(n15);
00605   myIntegers.push_back(n25);
00606   myIntegers.push_back(n35);
00607   myIntegers.push_back(n45);
00608   myNumber++;
00609 }
00610 
00611 //=======================================================================
00612 //function : AddVolume
00613 //purpose  : 
00614 //=======================================================================
00615 void SMESHDS_Command::AddVolume(int NewVolID, int n1, int n2,
00616                                 int n3, int n4, int n5,int n6,
00617                                 int n12, int n23, int n31,
00618                                 int n45, int n56, int n64,
00619                                 int n14, int n25, int n36)
00620 {
00621   if (!myType == SMESHDS_AddQuadPentahedron) {
00622     MESSAGE("SMESHDS_Command::AddVolume : Bad Type");
00623     return;
00624   }
00625   myIntegers.push_back(NewVolID);
00626   myIntegers.push_back(n1);
00627   myIntegers.push_back(n2);
00628   myIntegers.push_back(n3);
00629   myIntegers.push_back(n4);
00630   myIntegers.push_back(n5);
00631   myIntegers.push_back(n6);
00632   myIntegers.push_back(n12);
00633   myIntegers.push_back(n23);
00634   myIntegers.push_back(n31);
00635   myIntegers.push_back(n45);
00636   myIntegers.push_back(n56);
00637   myIntegers.push_back(n64);
00638   myIntegers.push_back(n14);
00639   myIntegers.push_back(n25);
00640   myIntegers.push_back(n36);
00641   myNumber++;
00642 }
00643 
00644 //=======================================================================
00645 //function : AddVolume
00646 //purpose  : 
00647 //=======================================================================
00648 void SMESHDS_Command::AddVolume(int NewVolID, int n1, int n2, int n3,
00649                                 int n4, int n5, int n6, int n7, int n8,
00650                                 int n12, int n23, int n34, int n41,
00651                                 int n56, int n67, int n78, int n85,
00652                                 int n15, int n26, int n37, int n48)
00653 {
00654   if (!myType == SMESHDS_AddQuadHexahedron) {
00655     MESSAGE("SMESHDS_Command::AddVolume : Bad Type");
00656     return;
00657   }
00658   myIntegers.push_back(NewVolID);
00659   myIntegers.push_back(n1);
00660   myIntegers.push_back(n2);
00661   myIntegers.push_back(n3);
00662   myIntegers.push_back(n4);
00663   myIntegers.push_back(n5);
00664   myIntegers.push_back(n6);
00665   myIntegers.push_back(n7);
00666   myIntegers.push_back(n8);
00667   myIntegers.push_back(n12);
00668   myIntegers.push_back(n23);
00669   myIntegers.push_back(n34);
00670   myIntegers.push_back(n41);
00671   myIntegers.push_back(n56);
00672   myIntegers.push_back(n67);
00673   myIntegers.push_back(n78);
00674   myIntegers.push_back(n85);
00675   myIntegers.push_back(n15);
00676   myIntegers.push_back(n26);
00677   myIntegers.push_back(n37);
00678   myIntegers.push_back(n48);
00679   myNumber++;
00680 }
00681 
00682 //=======================================================================
00683 //function : AddVolume
00684 //purpose  : 
00685 //=======================================================================
00686 void SMESHDS_Command::AddVolume(int NewVolID, int n1, int n2, int n3,
00687                                 int n4, int n5, int n6, int n7, int n8,
00688                                 int n12, int n23, int n34, int n41,
00689                                 int n56, int n67, int n78, int n85,
00690                                 int n15, int n26, int n37, int n48,
00691                                 int n1234,int n1256,int n2367,int n3478,
00692                                 int n1458,int n5678,int nCenter)
00693 {
00694   if (!myType == SMESHDS_AddQuadHexahedron) {
00695     MESSAGE("SMESHDS_Command::AddVolume : Bad Type");
00696     return;
00697   }
00698   myIntegers.push_back(NewVolID);
00699   myIntegers.push_back(n1);
00700   myIntegers.push_back(n2);
00701   myIntegers.push_back(n3);
00702   myIntegers.push_back(n4);
00703   myIntegers.push_back(n5);
00704   myIntegers.push_back(n6);
00705   myIntegers.push_back(n7);
00706   myIntegers.push_back(n8);
00707   myIntegers.push_back(n12);
00708   myIntegers.push_back(n23);
00709   myIntegers.push_back(n34);
00710   myIntegers.push_back(n41);
00711   myIntegers.push_back(n56);
00712   myIntegers.push_back(n67);
00713   myIntegers.push_back(n78);
00714   myIntegers.push_back(n85);
00715   myIntegers.push_back(n15);
00716   myIntegers.push_back(n26);
00717   myIntegers.push_back(n37);
00718   myIntegers.push_back(n48);
00719   myIntegers.push_back(n1234);
00720   myIntegers.push_back(n1256);
00721   myIntegers.push_back(n2367);
00722   myIntegers.push_back(n3478);
00723   myIntegers.push_back(n1458);
00724   myIntegers.push_back(n5678);
00725   myIntegers.push_back(nCenter);
00726   myNumber++;
00727 }
00728