src/SMDS/SMDS_QuadraticVolumeOfNodes.cxx

   1 // Copyright (C) 2007-2011  CEA/DEN, EDF R&D, OPEN CASCADE
   2 //
   3 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   5 //
   6 // This library is free software; you can redistribute it and/or
   7 // modify it under the terms of the GNU Lesser General Public
   8 // License as published by the Free Software Foundation; either
   9 // version 2.1 of the License.
  10 //
  11 // This library is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 // Lesser General Public License for more details.
  15 //
  16 // You should have received a copy of the GNU Lesser General Public
  17 // License along with this library; if not, write to the Free Software
  18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19 //
  20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  21 //
  22
  23 //  SMESH SMDS : implementaion of Salome mesh data structure
  24 // File:      SMDS_QuadraticVolumeOfNodes.cxx
  25 // Created:   17.01.06 09:46:11
  26 // Author:    Sergey KUUL
  27 //
  28 #include "SMDS_QuadraticVolumeOfNodes.hxx"
  29
  30 #include "SMDS_IteratorOfElements.hxx"
  31 #include "SMDS_MeshNode.hxx"
  32 #include "SMDS_SetIterator.hxx"
  33 #include "SMDS_VolumeTool.hxx"
  34
  35 #include "utilities.h"
  36
  37 using namespace std;
  38
  39
  40 //=======================================================================
  41 //function : SMDS_QuadraticVolumeOfNodes()
  42 //purpose  : Constructor tetrahedron of 10 nodes
  43 //=======================================================================
  44
  45 SMDS_QuadraticVolumeOfNodes::SMDS_QuadraticVolumeOfNodes
  46                                                (const SMDS_MeshNode * n1,
  47                                                 const SMDS_MeshNode * n2,
  48                                                 const SMDS_MeshNode * n3,
  49                                                 const SMDS_MeshNode * n4,
  50                                                 const SMDS_MeshNode * n12,
  51                                                 const SMDS_MeshNode * n23,
  52                                                 const SMDS_MeshNode * n31,
  53                                                 const SMDS_MeshNode * n14,
  54                                                 const SMDS_MeshNode * n24,
  55                                                 const SMDS_MeshNode * n34)
  56 {
  57   //MESSAGE("*********************************************** SMDS_QuadraticVolumeOfNodes");
  58   myNodes.resize( 10 );
  59   myNodes[ 0 ] = n1;
  60   myNodes[ 1 ] = n2;
  61   myNodes[ 2 ] = n3;
  62   myNodes[ 3 ] = n4;
  63   myNodes[ 4 ] = n12;
  64   myNodes[ 5 ] = n23;
  65   myNodes[ 6 ] = n31;
  66   myNodes[ 7 ] = n14;
  67   myNodes[ 8 ] = n24;
  68   myNodes[ 9 ] = n34;
  69 }
  70
  71
  72 //=======================================================================
  73 //function : SMDS_QuadraticVolumeOfNodes()
  74 //purpose  : Constructor pyramid of 13 nodes
  75 //=======================================================================
  76
  77 SMDS_QuadraticVolumeOfNodes::SMDS_QuadraticVolumeOfNodes
  78                                                (const SMDS_MeshNode * n1,
  79                                                 const SMDS_MeshNode * n2,
  80                                                 const SMDS_MeshNode * n3,
  81                                                 const SMDS_MeshNode * n4,
  82                                                 const SMDS_MeshNode * n5,
  83                                                 const SMDS_MeshNode * n12,
  84                                                 const SMDS_MeshNode * n23,
  85                                                 const SMDS_MeshNode * n34,
  86                                                 const SMDS_MeshNode * n41,
  87                                                 const SMDS_MeshNode * n15,
  88                                                 const SMDS_MeshNode * n25,
  89                                                 const SMDS_MeshNode * n35,
  90                                                 const SMDS_MeshNode * n45)
  91 {
  92   //MESSAGE("*********************************************** SMDS_QuadraticVolumeOfNodes");
  93   myNodes.resize( 13 );
  94   myNodes[ 0 ] = n1;
  95   myNodes[ 1 ] = n2;
  96   myNodes[ 2 ] = n3;
  97   myNodes[ 3 ] = n4;
  98   myNodes[ 4 ] = n5;
  99   myNodes[ 5 ] = n12;
 100   myNodes[ 6 ] = n23;
 101   myNodes[ 7 ] = n34;
 102   myNodes[ 8 ] = n41;
 103   myNodes[ 9 ] = n15;
 104   myNodes[ 10 ] = n25;
 105   myNodes[ 11 ] = n35;
 106   myNodes[ 12 ] = n45;
 107 }
 108
 109
 110 //=======================================================================
 111 //function : SMDS_QuadraticVolumeOfNodes()
 112 //purpose  : Constructor Pentahedron with 15 nodes
 113 //=======================================================================
 114
 115 SMDS_QuadraticVolumeOfNodes::SMDS_QuadraticVolumeOfNodes
 116                                                (const SMDS_MeshNode * n1,
 117                                                 const SMDS_MeshNode * n2,
 118                                                 const SMDS_MeshNode * n3,
 119                                                 const SMDS_MeshNode * n4,
 120                                                 const SMDS_MeshNode * n5,
 121                                                 const SMDS_MeshNode * n6,
 122                                                 const SMDS_MeshNode * n12,
 123                                                 const SMDS_MeshNode * n23,
 124                                                 const SMDS_MeshNode * n31,
 125                                                 const SMDS_MeshNode * n45,
 126                                                 const SMDS_MeshNode * n56,
 127                                                 const SMDS_MeshNode * n64,
 128                                                 const SMDS_MeshNode * n14,
 129                                                 const SMDS_MeshNode * n25,
 130                                                 const SMDS_MeshNode * n36)
 131 {
 132   //MESSAGE("*********************************************** SMDS_QuadraticVolumeOfNodes");
 133   myNodes.resize( 15 );
 134   myNodes[ 0 ] = n1;
 135   myNodes[ 1 ] = n2;
 136   myNodes[ 2 ] = n3;
 137   myNodes[ 3 ] = n4;
 138   myNodes[ 4 ] = n5;
 139   myNodes[ 5 ] = n6;
 140   myNodes[ 6 ] = n12;
 141   myNodes[ 7 ] = n23;
 142   myNodes[ 8 ] = n31;
 143   myNodes[ 9 ] = n45;
 144   myNodes[ 10 ] = n56;
 145   myNodes[ 11 ] = n64;
 146   myNodes[ 12 ] = n14;
 147   myNodes[ 13 ] = n25;
 148   myNodes[ 14 ] = n36;
 149 }
 150
 151
 152 //=======================================================================
 153 //function : SMDS_QuadraticVolumeOfNodes()
 154 //purpose  : Constructor Hexahedrons with 20 nodes
 155 //=======================================================================
 156
 157 SMDS_QuadraticVolumeOfNodes::SMDS_QuadraticVolumeOfNodes
 158                                                (const SMDS_MeshNode * n1,
 159                                                 const SMDS_MeshNode * n2,
 160                                                 const SMDS_MeshNode * n3,
 161                                                 const SMDS_MeshNode * n4,
 162                                                 const SMDS_MeshNode * n5,
 163                                                 const SMDS_MeshNode * n6,
 164                                                 const SMDS_MeshNode * n7,
 165                                                 const SMDS_MeshNode * n8,
 166                                                 const SMDS_MeshNode * n12,
 167                                                 const SMDS_MeshNode * n23,
 168                                                 const SMDS_MeshNode * n34,
 169                                                 const SMDS_MeshNode * n41,
 170                                                 const SMDS_MeshNode * n56,
 171                                                 const SMDS_MeshNode * n67,
 172                                                 const SMDS_MeshNode * n78,
 173                                                 const SMDS_MeshNode * n85,
 174                                                 const SMDS_MeshNode * n15,
 175                                                 const SMDS_MeshNode * n26,
 176                                                 const SMDS_MeshNode * n37,
 177                                                 const SMDS_MeshNode * n48)
 178 {
 179   //MESSAGE("*********************************************** SMDS_QuadraticVolumeOfNodes");
 180   myNodes.resize( 20 );
 181   myNodes[ 0 ] = n1;
 182   myNodes[ 1 ] = n2;
 183   myNodes[ 2 ] = n3;
 184   myNodes[ 3 ] = n4;
 185   myNodes[ 4 ] = n5;
 186   myNodes[ 5 ] = n6;
 187   myNodes[ 6 ] = n7;
 188   myNodes[ 7 ] = n8;
 189   myNodes[ 8 ] = n12;
 190   myNodes[ 9 ] = n23;
 191   myNodes[ 10 ] = n34;
 192   myNodes[ 11 ] = n41;
 193   myNodes[ 12 ] = n56;
 194   myNodes[ 13 ] = n67;
 195   myNodes[ 14 ] = n78;
 196   myNodes[ 15 ] = n85;
 197   myNodes[ 16 ] = n15;
 198   myNodes[ 17 ] = n26;
 199   myNodes[ 18 ] = n37;
 200   myNodes[ 19 ] = n48;
 201 }
 202
 203
 204 //=======================================================================
 205 //function : IsMediumNode
 206 //purpose  :
 207 //=======================================================================
 208
 209 bool SMDS_QuadraticVolumeOfNodes::IsMediumNode(const SMDS_MeshNode* node) const
 210 {
 211   int nbCorners = 0;
 212   switch (myNodes.size()) {
 213   case 10: nbCorners = 4; break;
 214   case 13: nbCorners = 5; break;
 215   case 15: nbCorners = 6; break;
 216   default: nbCorners = 8;
 217   }
 218   for ( int i = nbCorners; i<myNodes.size(); i++) {
 219     if(myNodes[i]==node) return true;
 220   }
 221   return false;
 222 }
 223
 224
 225 //=======================================================================
 226 //function : ChangeNodes
 227 //purpose  :
 228 //=======================================================================
 229
 230 bool SMDS_QuadraticVolumeOfNodes::ChangeNodes(const SMDS_MeshNode* nodes[],
 231                                               const int            nbNodes)
 232 {
 233   if( nbNodes==10 || nbNodes==13 || nbNodes==15 || nbNodes==20 ) {
 234     myNodes.resize(nbNodes);
 235     int i=0;
 236     for(; i<nbNodes; i++) {
 237       myNodes[i] = nodes[i];
 238     }
 239     return true;
 240   }
 241   return false;
 242 }
 243
 244
 245 //=======================================================================
 246 //function : NbNodes
 247 //purpose  :
 248 //=======================================================================
 249 int SMDS_QuadraticVolumeOfNodes::NbNodes() const
 250 {
 251   return myNodes.size();
 252 }
 253
 254
 255 //=======================================================================
 256 //function : NbEdges
 257 //purpose  :
 258 //=======================================================================
 259 int SMDS_QuadraticVolumeOfNodes::NbEdges() const
 260 {
 261   if(myNodes.size()==10)
 262     return 6;
 263   else if(myNodes.size()==13)
 264     return 8;
 265   else if(myNodes.size()==15)
 266     return 9;
 267   else
 268     return 12;
 269 }
 270
 271
 272 //=======================================================================
 273 //function : NbFaces
 274 //purpose  :
 275 //=======================================================================
 276 int SMDS_QuadraticVolumeOfNodes::NbFaces() const
 277 {
 278   if(myNodes.size()==10)
 279     return 4;
 280   else if(myNodes.size()==20)
 281     return 6;
 282   else
 283     return 5;
 284 }
 285
 286 //=======================================================================
 287 //function : Print
 288 //purpose  :
 289 //=======================================================================
 290 void SMDS_QuadraticVolumeOfNodes::Print(ostream & OS) const
 291 {
 292   OS << "quadratic volume <" << GetID() << " > : ";
 293   int i, nbNodes = myNodes.size();
 294   for (i = 0; i < nbNodes - 1; i++)
 295     OS << myNodes[i] << ",";
 296   OS << myNodes[i] << ") " << endl;
 297 }
 298
 299
 300 //=======================================================================
 301 //private class : SMDS_QuadraticVolumeOfNodes_MyIterator
 302 //purpose  :
 303 //=======================================================================
 304
 305 class SMDS_QuadraticVolumeOfNodes_MyIterator : public SMDS_NodeVectorElemIterator
 306 {
 307 public:
 308   SMDS_QuadraticVolumeOfNodes_MyIterator(const vector<const SMDS_MeshNode *>& s):
 309     SMDS_NodeVectorElemIterator( s.begin(), s.end() ) {}
 310 };
 311
 312 /// ===================================================================
 313 /*!
 314  * \brief Iterator on faces or edges of volume
 315  */
 316 /// ===================================================================
 317
 318 class _MySubIterator : public SMDS_ElemIterator
 319 {
 320   vector< const SMDS_MeshElement* > myElems;
 321   int myIndex;
 322 public:
 323   _MySubIterator(const SMDS_MeshVolume* vol, SMDSAbs_ElementType type):myIndex(0) {
 324     SMDS_VolumeTool vTool(vol);
 325     if (type == SMDSAbs_Face)
 326       vTool.GetAllExistingFaces( myElems );
 327     else
 328       vTool.GetAllExistingFaces( myElems );
 329   }
 330   /// Return true if and only if there are other object in this iterator
 331   virtual bool more() { return myIndex < myElems.size(); }
 332
 333   /// Return the current object and step to the next one
 334   virtual const SMDS_MeshElement* next() { return myElems[ myIndex++ ]; }
 335 };
 336
 337 //=======================================================================
 338 //function : elementsIterator
 339 //purpose  :
 340 //=======================================================================
 341
 342 SMDS_ElemIteratorPtr SMDS_QuadraticVolumeOfNodes::elementsIterator
 343                                          (SMDSAbs_ElementType type) const
 344 {
 345   switch(type)
 346   {
 347   case SMDSAbs_Volume:
 348     return SMDS_MeshElement::elementsIterator(SMDSAbs_Volume);
 349   case SMDSAbs_Node:
 350     return SMDS_ElemIteratorPtr(new SMDS_QuadraticVolumeOfNodes_MyIterator(myNodes));
 351   case SMDSAbs_Edge:
 352     return SMDS_ElemIteratorPtr(new _MySubIterator(this,SMDSAbs_Edge));
 353     break;
 354   case SMDSAbs_Face:
 355     return SMDS_ElemIteratorPtr(new _MySubIterator(this,SMDSAbs_Face));
 356     break;
 357   default:
 358     return SMDS_ElemIteratorPtr
 359       (new SMDS_IteratorOfElements
 360        (this,type,SMDS_ElemIteratorPtr
 361         (new SMDS_QuadraticVolumeOfNodes_MyIterator(myNodes))));
 362   }
 363   return SMDS_ElemIteratorPtr();
 364 }
 365
 366 /*!
 367  * \brief Return node by its index
 368  * \param ind - node index
 369  * \retval const SMDS_MeshNode* - the node
 370  */
 371 const SMDS_MeshNode* SMDS_QuadraticVolumeOfNodes::GetNode(const int ind) const
 372 {
 373   return myNodes[ ind ];
 374 }
 375
 376 SMDSAbs_EntityType SMDS_QuadraticVolumeOfNodes::GetEntityType() const
 377 {
 378   SMDSAbs_EntityType aType = SMDSEntity_Quad_Tetra;
 379   switch(NbNodes())
 380   {
 381   case 10: aType = SMDSEntity_Quad_Tetra;   break;
 382   case 13: aType = SMDSEntity_Quad_Pyramid; break;
 383   case 15: aType = SMDSEntity_Quad_Penta;   break;
 384   case 20:
 385   default: aType = SMDSEntity_Quad_Hexa;    break;
 386   }
 387   return aType;
 388 }