src/SMESHDS/SMESHDS_Command.cxx

   1 //  SMESH SMESHDS : management of mesh data and SMESH document
   2 //
   3 //  Copyright (C) 2003  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 //
  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::AddEdge(int NewEdgeID, int idnode1, int idnode2)
  93 {
  94         if (!myType == SMESHDS_AddEdge)
  95         {
  96                 MESSAGE("SMESHDS_Command::AddEdge : Bad Type");
  97                 return;
  98         }
  99         myIntegers.push_back(NewEdgeID);
 100         myIntegers.push_back(idnode1);
 101         myIntegers.push_back(idnode2);
 102         myNumber++;
 103 }
 104
 105 //=======================================================================
 106 //function :
 107 //purpose  :
 108 //=======================================================================
 109 void SMESHDS_Command::AddFace(int NewFaceID,
 110         int idnode1, int idnode2, int idnode3)
 111 {
 112         if (!myType == SMESHDS_AddTriangle)
 113         {
 114                 MESSAGE("SMESHDS_Command::AddFace : Bad Type");
 115                 return;
 116         }
 117         myIntegers.push_back(NewFaceID);
 118         myIntegers.push_back(idnode1);
 119         myIntegers.push_back(idnode2);
 120         myIntegers.push_back(idnode3);
 121         myNumber++;
 122 }
 123
 124 //=======================================================================
 125 //function :
 126 //purpose  :
 127 //=======================================================================
 128 void SMESHDS_Command::AddFace(int NewFaceID,
 129         int idnode1, int idnode2, int idnode3, int idnode4)
 130 {
 131         if (!myType == SMESHDS_AddQuadrangle)
 132         {
 133                 MESSAGE("SMESHDS_Command::AddFace : Bad Type");
 134                 return;
 135         }
 136         myIntegers.push_back(NewFaceID);
 137         myIntegers.push_back(idnode1);
 138         myIntegers.push_back(idnode2);
 139         myIntegers.push_back(idnode3);
 140         myIntegers.push_back(idnode4);
 141         myNumber++;
 142 }
 143
 144 //=======================================================================
 145 //function :
 146 //purpose  :
 147 //=======================================================================
 148 void SMESHDS_Command::AddVolume(int NewVolID,
 149         int idnode1, int idnode2, int idnode3, int idnode4)
 150 {
 151         if (!myType == SMESHDS_AddTetrahedron)
 152         {
 153                 MESSAGE("SMESHDS_Command::AddVolume : Bad Type");
 154                 return;
 155         }
 156         myIntegers.push_back(NewVolID);
 157         myIntegers.push_back(idnode1);
 158         myIntegers.push_back(idnode2);
 159         myIntegers.push_back(idnode3);
 160         myIntegers.push_back(idnode4);
 161         myNumber++;
 162 }
 163
 164 //=======================================================================
 165 //function :
 166 //purpose  :
 167 //=======================================================================
 168 void SMESHDS_Command::AddVolume(int NewVolID,
 169         int idnode1, int idnode2, int idnode3, int idnode4, int idnode5)
 170 {
 171         if (!myType == SMESHDS_AddPyramid)
 172         {
 173                 MESSAGE("SMESHDS_Command::AddVolume : Bad Type");
 174                 return;
 175         }
 176         myIntegers.push_back(NewVolID);
 177         myIntegers.push_back(idnode1);
 178         myIntegers.push_back(idnode2);
 179         myIntegers.push_back(idnode3);
 180         myIntegers.push_back(idnode4);
 181         myIntegers.push_back(idnode5);
 182         myNumber++;
 183 }
 184
 185 //=======================================================================
 186 //function :
 187 //purpose  :
 188 //=======================================================================
 189 void SMESHDS_Command::AddVolume(int NewVolID,
 190         int idnode1,
 191         int idnode2, int idnode3, int idnode4, int idnode5, int idnode6)
 192 {
 193         if (!myType == SMESHDS_AddPrism)
 194         {
 195                 MESSAGE("SMESHDS_Command::AddVolume : Bad Type");
 196                 return;
 197         }
 198         myIntegers.push_back(NewVolID);
 199         myIntegers.push_back(idnode1);
 200         myIntegers.push_back(idnode2);
 201         myIntegers.push_back(idnode3);
 202         myIntegers.push_back(idnode4);
 203         myIntegers.push_back(idnode5);
 204         myIntegers.push_back(idnode6);
 205         myNumber++;
 206 }
 207
 208 //=======================================================================
 209 //function :
 210 //purpose  :
 211 //=======================================================================
 212 void SMESHDS_Command::AddVolume(int NewVolID,
 213         int idnode1,
 214         int idnode2,
 215         int idnode3,
 216         int idnode4, int idnode5, int idnode6, int idnode7, int idnode8)
 217 {
 218         if (!myType == SMESHDS_AddHexahedron)
 219         {
 220                 MESSAGE("SMESHDS_Command::AddVolume : Bad Type");
 221                 return;
 222         }
 223         myIntegers.push_back(NewVolID);
 224         myIntegers.push_back(idnode1);
 225         myIntegers.push_back(idnode2);
 226         myIntegers.push_back(idnode3);
 227         myIntegers.push_back(idnode4);
 228         myIntegers.push_back(idnode5);
 229         myIntegers.push_back(idnode6);
 230         myIntegers.push_back(idnode7);
 231         myIntegers.push_back(idnode8);
 232         myNumber++;
 233 }
 234
 235 //=======================================================================
 236 //function : AddPolygonalFace
 237 //purpose  :
 238 //=======================================================================
 239 void SMESHDS_Command::AddPolygonalFace (const int        ElementID,
 240                                         std::vector<int> nodes_ids)
 241 {
 242   if (!myType == SMESHDS_AddPolygon) {
 243     MESSAGE("SMESHDS_Command::AddPolygonalFace : Bad Type");
 244     return;
 245   }
 246   myIntegers.push_back(ElementID);
 247
 248   int i, nbNodes = nodes_ids.size();
 249   myIntegers.push_back(nbNodes);
 250   for (i = 0; i < nbNodes; i++) {
 251     myIntegers.push_back(nodes_ids[i]);
 252   }
 253
 254   myNumber++;
 255 }
 256
 257 //=======================================================================
 258 //function : AddPolyhedralVolume
 259 //purpose  :
 260 //=======================================================================
 261 void SMESHDS_Command::AddPolyhedralVolume (const int        ElementID,
 262                                            std::vector<int> nodes_ids,
 263                                            std::vector<int> quantities)
 264 {
 265   if (!myType == SMESHDS_AddPolyhedron) {
 266     MESSAGE("SMESHDS_Command::AddPolyhedralVolume : Bad Type");
 267     return;
 268   }
 269   myIntegers.push_back(ElementID);
 270
 271   int i, nbNodes = nodes_ids.size();
 272   myIntegers.push_back(nbNodes);
 273   for (i = 0; i < nbNodes; i++) {
 274     myIntegers.push_back(nodes_ids[i]);
 275   }
 276
 277   int nbFaces = quantities.size();
 278   myIntegers.push_back(nbFaces);
 279   for (i = 0; i < nbFaces; i++) {
 280     myIntegers.push_back(quantities[i]);
 281   }
 282
 283   myNumber++;
 284 }
 285
 286 //=======================================================================
 287 //function :
 288 //purpose  :
 289 //=======================================================================
 290 void SMESHDS_Command::RemoveNode(int NodeID)
 291 {
 292         if (!myType == SMESHDS_RemoveNode)
 293         {
 294                 MESSAGE("SMESHDS_Command::RemoveNode : Bad Type");
 295                 return;
 296         }
 297         myIntegers.push_back(NodeID);
 298         myNumber++;
 299 }
 300
 301 //=======================================================================
 302 //function :
 303 //purpose  :
 304 //=======================================================================
 305 void SMESHDS_Command::RemoveElement(int ElementID)
 306 {
 307         if (!myType == SMESHDS_RemoveElement)
 308         {
 309                 MESSAGE("SMESHDS_Command::RemoveElement : Bad Type");
 310                 return;
 311         }
 312         myIntegers.push_back(ElementID);
 313         myNumber++;
 314 }
 315
 316 //=======================================================================
 317 //function : ChangeElementNodes
 318 //purpose  :
 319 //=======================================================================
 320
 321 void SMESHDS_Command::ChangeElementNodes(int ElementID, int nodes[], int nbnodes)
 322 {
 323   if (!myType == SMESHDS_ChangeElementNodes)
 324   {
 325     MESSAGE("SMESHDS_Command::ChangeElementNodes : Bad Type");
 326     return;
 327   }
 328   myIntegers.push_back(ElementID);
 329   myIntegers.push_back(nbnodes);
 330   for ( int i = 0; i < nbnodes; i++ )
 331     myIntegers.push_back( nodes[ i ] );
 332
 333   myNumber++;
 334 }
 335
 336 //=======================================================================
 337 //function : ChangePolyhedronNodes
 338 //purpose  :
 339 //=======================================================================
 340 void SMESHDS_Command::ChangePolyhedronNodes (const int ElementID,
 341                                              std::vector<int> nodes_ids,
 342                                              std::vector<int> quantities)
 343 {
 344   if (myType != SMESHDS_ChangePolyhedronNodes)
 345   {
 346     MESSAGE("SMESHDS_Command::ChangePolyhedronNodes : Bad Type");
 347     return;
 348   }
 349   myIntegers.push_back(ElementID);
 350
 351   int i, nbNodes = nodes_ids.size();
 352   myIntegers.push_back(nbNodes);
 353   for (i = 0; i < nbNodes; i++) {
 354     myIntegers.push_back(nodes_ids[i]);
 355   }
 356
 357   int nbFaces = quantities.size();
 358   myIntegers.push_back(nbFaces);
 359   for (i = 0; i < nbFaces; i++) {
 360     myIntegers.push_back(quantities[i]);
 361   }
 362
 363   myNumber++;
 364 }
 365
 366 //=======================================================================
 367 //function : Renumber
 368 //purpose  :
 369 //=======================================================================
 370
 371 void SMESHDS_Command::Renumber (const bool isNodes, const int startID, const int deltaID)
 372 {
 373   if (!myType == SMESHDS_Renumber)
 374   {
 375     MESSAGE("SMESHDS_Command::Renumber : Bad Type");
 376     return;
 377   }
 378   myIntegers.push_back(isNodes);
 379   myIntegers.push_back(startID);
 380   myIntegers.push_back(deltaID);
 381   myNumber++;
 382 }
 383
 384 //=======================================================================
 385 //function :
 386 //purpose  :
 387 //=======================================================================
 388 SMESHDS_CommandType SMESHDS_Command::GetType()
 389 {
 390         return myType;
 391 }
 392
 393 //=======================================================================
 394 //function :
 395 //purpose  :
 396 //=======================================================================
 397 int SMESHDS_Command::GetNumber()
 398 {
 399         return myNumber;
 400 }
 401
 402 //=======================================================================
 403 //function :
 404 //purpose  :
 405 //=======================================================================
 406 const list < int >&SMESHDS_Command::GetIndexes()
 407 {
 408         return myIntegers;
 409 }
 410
 411 //=======================================================================
 412 //function :
 413 //purpose  :
 414 //=======================================================================
 415 const list < double >&SMESHDS_Command::GetCoords()
 416 {
 417         return myReals;
 418 }
 419
 420
 421 //********************************************************************
 422 //*****             Methods for quadratic elements              ******
 423 //********************************************************************
 424
 425 //=======================================================================
 426 //function : AddEdge
 427 //purpose  :
 428 //=======================================================================
 429 void SMESHDS_Command::AddEdge(int NewEdgeID, int n1, int n2, int n12)
 430 {
 431   if (!myType == SMESHDS_AddQuadEdge) {
 432     MESSAGE("SMESHDS_Command::AddEdge : Bad Type");
 433     return;
 434   }
 435   myIntegers.push_back(NewEdgeID);
 436   myIntegers.push_back(n1);
 437   myIntegers.push_back(n2);
 438   myIntegers.push_back(n12);
 439   myNumber++;
 440 }
 441
 442 //=======================================================================
 443 //function : AddFace
 444 //purpose  :
 445 //=======================================================================
 446 void SMESHDS_Command::AddFace(int NewFaceID,
 447                               int n1, int n2, int n3,
 448                               int n12, int n23, int n31)
 449 {
 450   if (!myType == SMESHDS_AddQuadTriangle) {
 451     MESSAGE("SMESHDS_Command::AddFace : Bad Type");
 452     return;
 453   }
 454   myIntegers.push_back(NewFaceID);
 455   myIntegers.push_back(n1);
 456   myIntegers.push_back(n2);
 457   myIntegers.push_back(n3);
 458   myIntegers.push_back(n12);
 459   myIntegers.push_back(n23);
 460   myIntegers.push_back(n31);
 461   myNumber++;
 462 }
 463
 464 //=======================================================================
 465 //function : AddFace
 466 //purpose  :
 467 //=======================================================================
 468 void SMESHDS_Command::AddFace(int NewFaceID,
 469                               int n1, int n2, int n3, int n4,
 470                               int n12, int n23, int n34, int n41)
 471 {
 472   if (!myType == SMESHDS_AddQuadQuadrangle) {
 473     MESSAGE("SMESHDS_Command::AddFace : Bad Type");
 474     return;
 475   }
 476   myIntegers.push_back(NewFaceID);
 477   myIntegers.push_back(n1);
 478   myIntegers.push_back(n2);
 479   myIntegers.push_back(n3);
 480   myIntegers.push_back(n4);
 481   myIntegers.push_back(n12);
 482   myIntegers.push_back(n23);
 483   myIntegers.push_back(n34);
 484   myIntegers.push_back(n41);
 485   myNumber++;
 486 }
 487
 488 //=======================================================================
 489 //function : AddVolume
 490 //purpose  :
 491 //=======================================================================
 492 void SMESHDS_Command::AddVolume(int NewVolID, int n1, int n2, int n3, int n4,
 493                                 int n12, int n23, int n31,
 494                                 int n14, int n24, int n34)
 495 {
 496   if (!myType == SMESHDS_AddQuadTetrahedron) {
 497     MESSAGE("SMESHDS_Command::AddVolume : Bad Type");
 498     return;
 499   }
 500   myIntegers.push_back(NewVolID);
 501   myIntegers.push_back(n1);
 502   myIntegers.push_back(n2);
 503   myIntegers.push_back(n3);
 504   myIntegers.push_back(n4);
 505   myIntegers.push_back(n12);
 506   myIntegers.push_back(n23);
 507   myIntegers.push_back(n31);
 508   myIntegers.push_back(n14);
 509   myIntegers.push_back(n24);
 510   myIntegers.push_back(n34);
 511   myNumber++;
 512 }
 513
 514 //=======================================================================
 515 //function : AddVolume
 516 //purpose  :
 517 //=======================================================================
 518 void SMESHDS_Command::AddVolume(int NewVolID, int n1, int n2,
 519                                 int n3, int n4, int n5,
 520                                 int n12, int n23, int n34, int n41,
 521                                 int n15, int n25, int n35, int n45)
 522 {
 523   if (!myType == SMESHDS_AddQuadPyramid) {
 524     MESSAGE("SMESHDS_Command::AddVolume : Bad Type");
 525     return;
 526   }
 527   myIntegers.push_back(NewVolID);
 528   myIntegers.push_back(n1);
 529   myIntegers.push_back(n2);
 530   myIntegers.push_back(n3);
 531   myIntegers.push_back(n4);
 532   myIntegers.push_back(n5);
 533   myIntegers.push_back(n12);
 534   myIntegers.push_back(n23);
 535   myIntegers.push_back(n34);
 536   myIntegers.push_back(n41);
 537   myIntegers.push_back(n15);
 538   myIntegers.push_back(n25);
 539   myIntegers.push_back(n35);
 540   myIntegers.push_back(n45);
 541   myNumber++;
 542 }
 543
 544 //=======================================================================
 545 //function : AddVolume
 546 //purpose  :
 547 //=======================================================================
 548 void SMESHDS_Command::AddVolume(int NewVolID, int n1, int n2,
 549                                 int n3, int n4, int n5,int n6,
 550                                 int n12, int n23, int n31,
 551                                 int n45, int n56, int n64,
 552                                 int n14, int n25, int n36)
 553 {
 554   if (!myType == SMESHDS_AddQuadPentahedron) {
 555     MESSAGE("SMESHDS_Command::AddVolume : Bad Type");
 556     return;
 557   }
 558   myIntegers.push_back(NewVolID);
 559   myIntegers.push_back(n1);
 560   myIntegers.push_back(n2);
 561   myIntegers.push_back(n3);
 562   myIntegers.push_back(n4);
 563   myIntegers.push_back(n5);
 564   myIntegers.push_back(n6);
 565   myIntegers.push_back(n12);
 566   myIntegers.push_back(n23);
 567   myIntegers.push_back(n31);
 568   myIntegers.push_back(n45);
 569   myIntegers.push_back(n56);
 570   myIntegers.push_back(n64);
 571   myIntegers.push_back(n14);
 572   myIntegers.push_back(n25);
 573   myIntegers.push_back(n36);
 574   myNumber++;
 575 }
 576
 577 //=======================================================================
 578 //function : AddVolume
 579 //purpose  :
 580 //=======================================================================
 581 void SMESHDS_Command::AddVolume(int NewVolID, int n1, int n2, int n3,
 582                                 int n4, int n5, int n6, int n7, int n8,
 583                                 int n12, int n23, int n34, int n41,
 584                                 int n56, int n67, int n78, int n85,
 585                                 int n15, int n26, int n37, int n48)
 586 {
 587   if (!myType == SMESHDS_AddQuadHexahedron) {
 588     MESSAGE("SMESHDS_Command::AddVolume : Bad Type");
 589     return;
 590   }
 591   myIntegers.push_back(NewVolID);
 592   myIntegers.push_back(n1);
 593   myIntegers.push_back(n2);
 594   myIntegers.push_back(n3);
 595   myIntegers.push_back(n4);
 596   myIntegers.push_back(n5);
 597   myIntegers.push_back(n6);
 598   myIntegers.push_back(n7);
 599   myIntegers.push_back(n8);
 600   myIntegers.push_back(n12);
 601   myIntegers.push_back(n23);
 602   myIntegers.push_back(n34);
 603   myIntegers.push_back(n41);
 604   myIntegers.push_back(n56);
 605   myIntegers.push_back(n67);
 606   myIntegers.push_back(n78);
 607   myIntegers.push_back(n85);
 608   myIntegers.push_back(n15);
 609   myIntegers.push_back(n26);
 610   myIntegers.push_back(n37);
 611   myIntegers.push_back(n48);
 612   myNumber++;
 613 }
 614