]> SALOME platform Git repositories - modules/smesh.git/blob - src/SMDS/SMDS_QuadraticVolumeOfNodes.cxx
Salome HOME
0021196: [CEA 456] Integration and merge modification for debian packages
[modules/smesh.git] / src / SMDS / SMDS_QuadraticVolumeOfNodes.cxx
1 //  Copyright (C) 2007-2010  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   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 const SMDS_MeshNode* SMDS_QuadraticVolumeOfNodes::GetNode(const int ind) const
368 {
369   return myNodes[ ind ];
370 }
371
372 SMDSAbs_EntityType SMDS_QuadraticVolumeOfNodes::GetEntityType() const
373 {
374   SMDSAbs_EntityType aType = SMDSEntity_Quad_Tetra;
375   switch(NbNodes())
376   {
377   case 10: aType = SMDSEntity_Quad_Tetra;   break;
378   case 13: aType = SMDSEntity_Quad_Pyramid; break;
379   case 15: aType = SMDSEntity_Quad_Penta;   break;
380   case 20:
381   default: aType = SMDSEntity_Quad_Hexa;    break;
382   }
383   return aType;
384 }