src/SMDS/SMDS_QuadraticVolumeOfNodes.cxx

   1 //  SMESH SMDS : implementaion of Salome mesh data structure
   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:      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   myNodes.resize( 10 );
  58   myNodes[ 0 ] = n1;
  59   myNodes[ 1 ] = n2;
  60   myNodes[ 2 ] = n3;
  61   myNodes[ 3 ] = n4;
  62   myNodes[ 4 ] = n12;
  63   myNodes[ 5 ] = n23;
  64   myNodes[ 6 ] = n31;
  65   myNodes[ 7 ] = n14;
  66   myNodes[ 8 ] = n24;
  67   myNodes[ 9 ] = n34;
  68 }
  69
  70
  71 //=======================================================================
  72 //function : SMDS_QuadraticVolumeOfNodes()
  73 //purpose  : Constructor pyramid of 13 nodes
  74 //=======================================================================
  75
  76 SMDS_QuadraticVolumeOfNodes::SMDS_QuadraticVolumeOfNodes
  77                                                (const SMDS_MeshNode * n1,
  78                                                 const SMDS_MeshNode * n2,
  79                                                 const SMDS_MeshNode * n3,
  80                                                 const SMDS_MeshNode * n4,
  81                                                 const SMDS_MeshNode * n5,
  82                                                 const SMDS_MeshNode * n12,
  83                                                 const SMDS_MeshNode * n23,
  84                                                 const SMDS_MeshNode * n34,
  85                                                 const SMDS_MeshNode * n41,
  86                                                 const SMDS_MeshNode * n15,
  87                                                 const SMDS_MeshNode * n25,
  88                                                 const SMDS_MeshNode * n35,
  89                                                 const SMDS_MeshNode * n45)
  90 {
  91   myNodes.resize( 13 );
  92   myNodes[ 0 ] = n1;
  93   myNodes[ 1 ] = n2;
  94   myNodes[ 2 ] = n3;
  95   myNodes[ 3 ] = n4;
  96   myNodes[ 4 ] = n5;
  97   myNodes[ 5 ] = n12;
  98   myNodes[ 6 ] = n23;
  99   myNodes[ 7 ] = n34;
 100   myNodes[ 8 ] = n41;
 101   myNodes[ 9 ] = n15;
 102   myNodes[ 10 ] = n25;
 103   myNodes[ 11 ] = n35;
 104   myNodes[ 12 ] = n45;
 105 }
 106
 107
 108 //=======================================================================
 109 //function : SMDS_QuadraticVolumeOfNodes()
 110 //purpose  : Constructor Pentahedron with 15 nodes
 111 //=======================================================================
 112
 113 SMDS_QuadraticVolumeOfNodes::SMDS_QuadraticVolumeOfNodes
 114                                                (const SMDS_MeshNode * n1,
 115                                                 const SMDS_MeshNode * n2,
 116                                                 const SMDS_MeshNode * n3,
 117                                                 const SMDS_MeshNode * n4,
 118                                                 const SMDS_MeshNode * n5,
 119                                                 const SMDS_MeshNode * n6,
 120                                                 const SMDS_MeshNode * n12,
 121                                                 const SMDS_MeshNode * n23,
 122                                                 const SMDS_MeshNode * n31,
 123                                                 const SMDS_MeshNode * n45,
 124                                                 const SMDS_MeshNode * n56,
 125                                                 const SMDS_MeshNode * n64,
 126                                                 const SMDS_MeshNode * n14,
 127                                                 const SMDS_MeshNode * n25,
 128                                                 const SMDS_MeshNode * n36)
 129 {
 130   myNodes.resize( 15 );
 131   myNodes[ 0 ] = n1;
 132   myNodes[ 1 ] = n2;
 133   myNodes[ 2 ] = n3;
 134   myNodes[ 3 ] = n4;
 135   myNodes[ 4 ] = n5;
 136   myNodes[ 5 ] = n6;
 137   myNodes[ 6 ] = n12;
 138   myNodes[ 7 ] = n23;
 139   myNodes[ 8 ] = n31;
 140   myNodes[ 9 ] = n45;
 141   myNodes[ 10 ] = n56;
 142   myNodes[ 11 ] = n64;
 143   myNodes[ 12 ] = n14;
 144   myNodes[ 13 ] = n25;
 145   myNodes[ 14 ] = n36;
 146 }
 147
 148
 149 //=======================================================================
 150 //function : SMDS_QuadraticVolumeOfNodes()
 151 //purpose  : Constructor Hexahedrons with 20 nodes
 152 //=======================================================================
 153
 154 SMDS_QuadraticVolumeOfNodes::SMDS_QuadraticVolumeOfNodes
 155                                                (const SMDS_MeshNode * n1,
 156                                                 const SMDS_MeshNode * n2,
 157                                                 const SMDS_MeshNode * n3,
 158                                                 const SMDS_MeshNode * n4,
 159                                                 const SMDS_MeshNode * n5,
 160                                                 const SMDS_MeshNode * n6,
 161                                                 const SMDS_MeshNode * n7,
 162                                                 const SMDS_MeshNode * n8,
 163                                                 const SMDS_MeshNode * n12,
 164                                                 const SMDS_MeshNode * n23,
 165                                                 const SMDS_MeshNode * n34,
 166                                                 const SMDS_MeshNode * n41,
 167                                                 const SMDS_MeshNode * n56,
 168                                                 const SMDS_MeshNode * n67,
 169                                                 const SMDS_MeshNode * n78,
 170                                                 const SMDS_MeshNode * n85,
 171                                                 const SMDS_MeshNode * n15,
 172                                                 const SMDS_MeshNode * n26,
 173                                                 const SMDS_MeshNode * n37,
 174                                                 const SMDS_MeshNode * n48)
 175 {
 176   myNodes.resize( 20 );
 177   myNodes[ 0 ] = n1;
 178   myNodes[ 1 ] = n2;
 179   myNodes[ 2 ] = n3;
 180   myNodes[ 3 ] = n4;
 181   myNodes[ 4 ] = n5;
 182   myNodes[ 5 ] = n6;
 183   myNodes[ 6 ] = n7;
 184   myNodes[ 7 ] = n8;
 185   myNodes[ 8 ] = n12;
 186   myNodes[ 9 ] = n23;
 187   myNodes[ 10 ] = n34;
 188   myNodes[ 11 ] = n41;
 189   myNodes[ 12 ] = n56;
 190   myNodes[ 13 ] = n67;
 191   myNodes[ 14 ] = n78;
 192   myNodes[ 15 ] = n85;
 193   myNodes[ 16 ] = n15;
 194   myNodes[ 17 ] = n26;
 195   myNodes[ 18 ] = n37;
 196   myNodes[ 19 ] = n48;
 197 }
 198
 199
 200 //=======================================================================
 201 //function : IsMediumNode
 202 //purpose  :
 203 //=======================================================================
 204
 205 bool SMDS_QuadraticVolumeOfNodes::IsMediumNode(const SMDS_MeshNode* node) const
 206 {
 207   int nbCorners = 0;
 208   switch (myNodes.size()) {
 209   case 10: nbCorners = 4; break;
 210   case 13: nbCorners = 5; break;
 211   case 15: nbCorners = 6; break;
 212   default: nbCorners = 8;
 213   }
 214   for ( int i = nbCorners; i<myNodes.size(); i++) {
 215     if(myNodes[i]==node) return true;
 216   }
 217   return false;
 218 }
 219
 220
 221 //=======================================================================
 222 //function : ChangeNodes
 223 //purpose  :
 224 //=======================================================================
 225
 226 bool SMDS_QuadraticVolumeOfNodes::ChangeNodes(const SMDS_MeshNode* nodes[],
 227                                               const int            nbNodes)
 228 {
 229   if( nbNodes==10 || nbNodes==13 || nbNodes==15 || nbNodes==20 ) {
 230     myNodes.resize(nbNodes);
 231     int i=0;
 232     for(; i<nbNodes; i++) {
 233       myNodes[i] = nodes[i];
 234     }
 235     return true;
 236   }
 237   return false;
 238 }
 239
 240
 241 //=======================================================================
 242 //function : NbNodes
 243 //purpose  :
 244 //=======================================================================
 245 int SMDS_QuadraticVolumeOfNodes::NbNodes() const
 246 {
 247   return myNodes.size();
 248 }
 249
 250
 251 //=======================================================================
 252 //function : NbEdges
 253 //purpose  :
 254 //=======================================================================
 255 int SMDS_QuadraticVolumeOfNodes::NbEdges() const
 256 {
 257   if(myNodes.size()==10)
 258     return 6;
 259   else if(myNodes.size()==13)
 260     return 8;
 261   else if(myNodes.size()==15)
 262     return 9;
 263   else
 264     return 12;
 265 }
 266
 267
 268 //=======================================================================
 269 //function : NbFaces
 270 //purpose  :
 271 //=======================================================================
 272 int SMDS_QuadraticVolumeOfNodes::NbFaces() const
 273 {
 274   if(myNodes.size()==10)
 275     return 4;
 276   else if(myNodes.size()==20)
 277     return 6;
 278   else
 279     return 5;
 280 }
 281
 282 //=======================================================================
 283 //function : Print
 284 //purpose  :
 285 //=======================================================================
 286 void SMDS_QuadraticVolumeOfNodes::Print(ostream & OS) const
 287 {
 288   OS << "quadratic volume <" << GetID() << " > : ";
 289   int i, nbNodes = myNodes.size();
 290   for (i = 0; i < nbNodes - 1; i++)
 291     OS << myNodes[i] << ",";
 292   OS << myNodes[i] << ") " << endl;
 293 }
 294
 295
 296 //=======================================================================
 297 //private class : SMDS_QuadraticVolumeOfNodes_MyIterator
 298 //purpose  :
 299 //=======================================================================
 300
 301 class SMDS_QuadraticVolumeOfNodes_MyIterator : public SMDS_NodeVectorElemIterator
 302 {
 303 public:
 304   SMDS_QuadraticVolumeOfNodes_MyIterator(const vector<const SMDS_MeshNode *>& s):
 305     SMDS_NodeVectorElemIterator( s.begin(), s.end() ) {}
 306 };
 307
 308 /// ===================================================================
 309 /*!
 310  * \brief Iterator on faces or edges of volume
 311  */
 312 /// ===================================================================
 313
 314 class _MySubIterator : public SMDS_ElemIterator
 315 {
 316   vector< const SMDS_MeshElement* > myElems;
 317   int myIndex;
 318 public:
 319   _MySubIterator(const SMDS_MeshVolume* vol, SMDSAbs_ElementType type):myIndex(0) {
 320     SMDS_VolumeTool vTool(vol);
 321     if (type == SMDSAbs_Face)
 322       vTool.GetAllExistingFaces( myElems );
 323     else
 324       vTool.GetAllExistingFaces( myElems );
 325   }
 326   /// Return true if and only if there are other object in this iterator
 327   virtual bool more() { return myIndex < myElems.size(); }
 328
 329   /// Return the current object and step to the next one
 330   virtual const SMDS_MeshElement* next() { return myElems[ myIndex++ ]; }
 331 };
 332
 333 //=======================================================================
 334 //function : elementsIterator
 335 //purpose  :
 336 //=======================================================================
 337
 338 SMDS_ElemIteratorPtr SMDS_QuadraticVolumeOfNodes::elementsIterator
 339                                          (SMDSAbs_ElementType type) const
 340 {
 341   switch(type)
 342   {
 343   case SMDSAbs_Volume:
 344     return SMDS_MeshElement::elementsIterator(SMDSAbs_Volume);
 345   case SMDSAbs_Node:
 346     return SMDS_ElemIteratorPtr(new SMDS_QuadraticVolumeOfNodes_MyIterator(myNodes));
 347   case SMDSAbs_Edge:
 348     return SMDS_ElemIteratorPtr(new _MySubIterator(this,SMDSAbs_Edge));
 349     break;
 350   case SMDSAbs_Face:
 351     return SMDS_ElemIteratorPtr(new _MySubIterator(this,SMDSAbs_Face));
 352     break;
 353   default:
 354     return SMDS_ElemIteratorPtr
 355       (new SMDS_IteratorOfElements
 356        (this,type,SMDS_ElemIteratorPtr
 357         (new SMDS_QuadraticVolumeOfNodes_MyIterator(myNodes))));
 358   }
 359   return SMDS_ElemIteratorPtr();
 360 }
 361
 362 /*!
 363  * \brief Return node by its index
 364  * \param ind - node index
 365  * \retval const SMDS_MeshNode* - the node
 366  *
 367  * Index is wrapped if it is out of a valid range
 368  */
 369 const SMDS_MeshNode* SMDS_QuadraticVolumeOfNodes::GetNode(const int ind) const
 370 {
 371   return myNodes[ WrappedIndex( ind )];
 372 }
 373