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