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