]> SALOME platform Git repositories - modules/smesh.git/blob - src/SMDS/SMDS_QuadraticVolumeOfNodes.cxx
Salome HOME
Correction of mistakes: 0022537: EDF 2877 SMESH : wrong information about the numbre...
[modules/smesh.git] / src / SMDS / SMDS_QuadraticVolumeOfNodes.cxx
1 // Copyright (C) 2007-2014  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, or (at your option) any later version.
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 }