src/SMESHDS/SMESHDS_Command.cxx

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