src/SMDS/SMDS_QuadraticVolumeOfNodes.cxx

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