]> SALOME platform Git repositories - modules/smesh.git/blob - src/SMDS/SMDS_VolumeOfNodes.cxx
Salome HOME
Correction of mistakes: 0022537: EDF 2877 SMESH : wrong information about the numbre...
[modules/smesh.git] / src / SMDS / SMDS_VolumeOfNodes.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 //
25 #ifdef _MSC_VER
26 #pragma warning(disable:4786)
27 #endif
28
29 #include "SMDS_VolumeOfNodes.hxx"
30 #include "SMDS_MeshNode.hxx"
31 #include "SMDS_SetIterator.hxx"
32 #include "SMDS_VolumeTool.hxx"
33 #include "SMDS_Mesh.hxx"
34 #include "utilities.h"
35
36 using namespace std;
37
38 ///////////////////////////////////////////////////////////////////////////////
39 /// Create an hexahedron. node 1,2,3,4 and 5,6,7,8 are quadrangle and
40 /// 5,1 and 7,3 are an edges.
41 ///////////////////////////////////////////////////////////////////////////////
42 SMDS_VolumeOfNodes::SMDS_VolumeOfNodes(
43                 const SMDS_MeshNode * node1,
44                 const SMDS_MeshNode * node2,
45                 const SMDS_MeshNode * node3,
46                 const SMDS_MeshNode * node4,
47                 const SMDS_MeshNode * node5,
48                 const SMDS_MeshNode * node6,
49                 const SMDS_MeshNode * node7,
50                 const SMDS_MeshNode * node8)
51 {
52   //MESSAGE("***************************************************** SMDS_VolumeOfNodes");
53         myNbNodes = 8;
54         myNodes = new const SMDS_MeshNode* [myNbNodes];
55         myNodes[0]=node1;
56         myNodes[1]=node2;
57         myNodes[2]=node3;
58         myNodes[3]=node4;
59         myNodes[4]=node5;
60         myNodes[5]=node6;
61         myNodes[6]=node7;
62         myNodes[7]=node8;
63 }
64
65 SMDS_VolumeOfNodes::SMDS_VolumeOfNodes(
66                 const SMDS_MeshNode * node1,
67                 const SMDS_MeshNode * node2,
68                 const SMDS_MeshNode * node3,
69                 const SMDS_MeshNode * node4)
70 {
71   //MESSAGE("***************************************************** SMDS_VolumeOfNodes");
72         myNbNodes = 4;
73         myNodes = new const SMDS_MeshNode* [myNbNodes];
74         myNodes[0]=node1;
75         myNodes[1]=node2;
76         myNodes[2]=node3;
77         myNodes[3]=node4;
78 }
79
80 SMDS_VolumeOfNodes::SMDS_VolumeOfNodes(
81                 const SMDS_MeshNode * node1,
82                 const SMDS_MeshNode * node2,
83                 const SMDS_MeshNode * node3,
84                 const SMDS_MeshNode * node4,
85                 const SMDS_MeshNode * node5)
86 {
87   //MESSAGE("***************************************************** SMDS_VolumeOfNodes");
88         myNbNodes = 5;
89         myNodes = new const SMDS_MeshNode* [myNbNodes];
90         myNodes[0]=node1;
91         myNodes[1]=node2;
92         myNodes[2]=node3;
93         myNodes[3]=node4;
94         myNodes[4]=node5;
95 }
96
97 SMDS_VolumeOfNodes::SMDS_VolumeOfNodes(
98                 const SMDS_MeshNode * node1,
99                 const SMDS_MeshNode * node2,
100                 const SMDS_MeshNode * node3,
101                 const SMDS_MeshNode * node4,
102                 const SMDS_MeshNode * node5,
103                 const SMDS_MeshNode * node6)
104 {
105   //MESSAGE("***************************************************** SMDS_VolumeOfNodes");
106         myNbNodes = 6;
107         myNodes = new const SMDS_MeshNode* [myNbNodes];
108         myNodes[0]=node1;
109         myNodes[1]=node2;
110         myNodes[2]=node3;
111         myNodes[3]=node4;
112         myNodes[4]=node5;
113         myNodes[5]=node6;
114 }
115
116 bool SMDS_VolumeOfNodes::ChangeNodes(const SMDS_MeshNode* nodes[],
117                                      const int            nbNodes)
118 {
119   if (nbNodes < 4 || nbNodes > 8 || nbNodes == 7)
120     return false;
121
122   delete [] myNodes;
123   myNbNodes = nbNodes;
124   myNodes = new const SMDS_MeshNode* [myNbNodes];
125   for ( int i = 0; i < nbNodes; i++ )
126     myNodes[ i ] = nodes [ i ];
127
128   return true;
129 }
130
131 SMDS_VolumeOfNodes::~SMDS_VolumeOfNodes()
132 {
133   if (myNodes != NULL) {
134     delete [] myNodes;
135     myNodes = NULL;
136   }
137 }
138
139 void SMDS_VolumeOfNodes::Print(ostream & OS) const
140 {
141         OS << "volume <" << GetID() << "> : ";
142         int i;
143         for (i = 0; i < NbNodes()-1; ++i) OS << myNodes[i] << ",";
144         OS << myNodes[NbNodes()-1]<< ") " << endl;
145 }
146
147 int SMDS_VolumeOfNodes::NbFaces() const
148 {
149         switch(NbNodes())
150         {
151         case 4: return 4;
152         case 5: return 5;
153         case 6: return 5;
154         case 8: return 6;
155         default: MESSAGE("invalid number of nodes");
156         }
157         return 0;
158 }
159
160 int SMDS_VolumeOfNodes::NbNodes() const
161 {
162         return myNbNodes;
163 }
164
165 int SMDS_VolumeOfNodes::NbEdges() const
166 {
167         switch(NbNodes())
168         {
169         case 4: return 6;
170         case 5: return 8;
171         case 6: return 9;
172         case 8: return 12;
173         default: MESSAGE("invalid number of nodes");
174         }
175         return 0;
176 }
177
178 /*!
179  * \brief Iterator on node of volume
180  */
181 class SMDS_VolumeOfNodes_MyIterator:public SMDS_NodeArrayElemIterator
182 {
183  public:
184   SMDS_VolumeOfNodes_MyIterator(const SMDS_MeshNode* const* s, int l):
185     SMDS_NodeArrayElemIterator( s, & s[ l ]) {}
186 };
187
188 /*!
189  * \brief Iterator on faces or edges of volume
190  */
191 class _MySubIterator : public SMDS_ElemIterator
192 {
193   vector< const SMDS_MeshElement* > myElems;
194   int myIndex;
195 public:
196   _MySubIterator(const SMDS_VolumeOfNodes* vol, SMDSAbs_ElementType type):myIndex(0) {
197     SMDS_VolumeTool vTool(vol);
198     if (type == SMDSAbs_Face)
199       vTool.GetAllExistingFaces( myElems );
200     else
201       vTool.GetAllExistingFaces( myElems );
202   }
203   /// Return true if and only if there are other object in this iterator
204   virtual bool more() { return myIndex < myElems.size(); }
205
206   /// Return the current object and step to the next one
207   virtual const SMDS_MeshElement* next() { return myElems[ myIndex++ ]; }
208 };
209
210 SMDS_ElemIteratorPtr SMDS_VolumeOfNodes::elementsIterator(SMDSAbs_ElementType type) const
211 {
212   switch(type)
213   {
214   case SMDSAbs_Volume:
215     return SMDS_MeshElement::elementsIterator(SMDSAbs_Volume);
216   case SMDSAbs_Node:
217     return SMDS_ElemIteratorPtr(new SMDS_VolumeOfNodes_MyIterator(myNodes,myNbNodes));
218   case SMDSAbs_Face:
219     return SMDS_ElemIteratorPtr(new _MySubIterator(this,SMDSAbs_Face));
220   case SMDSAbs_Edge:
221     return SMDS_ElemIteratorPtr(new _MySubIterator(this,SMDSAbs_Edge));
222   default:
223     MESSAGE("ERROR : Iterator not implemented");
224     return SMDS_ElemIteratorPtr((SMDS_ElemIterator*)NULL);
225   }
226 }
227
228 SMDSAbs_ElementType SMDS_VolumeOfNodes::GetType() const
229 {
230         return SMDSAbs_Volume;
231 }
232
233 /*!
234  * \brief Return node by its index
235  * \param ind - node index
236  * \retval const SMDS_MeshNode* - the node
237  */
238 const SMDS_MeshNode* SMDS_VolumeOfNodes::GetNode(const int ind) const
239 {
240   return myNodes[ ind ];
241 }
242
243 SMDSAbs_EntityType SMDS_VolumeOfNodes::GetEntityType() const
244 {
245   SMDSAbs_EntityType aType = SMDSEntity_Tetra;
246   switch(myNbNodes)
247   {
248   case 4: aType = SMDSEntity_Tetra;   break;
249   case 5: aType = SMDSEntity_Pyramid; break;
250   case 6: aType = SMDSEntity_Penta;   break;
251   case 8:
252   default: aType = SMDSEntity_Hexa;    break;
253   }
254   return aType;
255 }
256
257 SMDSAbs_GeometryType SMDS_VolumeOfNodes::GetGeomType() const
258 {
259   SMDSAbs_GeometryType aType = SMDSGeom_NONE;
260   switch(myNbNodes)
261   {
262   case 4: aType = SMDSGeom_TETRA;   break;
263   case 5: aType = SMDSGeom_PYRAMID; break;
264   case 6: aType = SMDSGeom_PENTA;   break;
265   case 12: aType = SMDSGeom_HEXAGONAL_PRISM; break;
266   case 8:
267   default: aType = SMDSGeom_HEXA;    break;
268   }
269   return aType;
270 }
271