]> SALOME platform Git repositories - modules/smesh.git/blob - src/SMDS/SMDS_QuadraticFaceOfNodes.cxx
Salome HOME
0021196: [CEA 456] Integration and merge modification for debian packages
[modules/smesh.git] / src / SMDS / SMDS_QuadraticFaceOfNodes.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_QuadraticFaceOfNodes.cxx
25 // Created:   16.01.06 17:12:58
26 // Author:    Sergey KUUL
27 //
28 #include "SMDS_QuadraticFaceOfNodes.hxx"
29
30 #include "SMDS_SetIterator.hxx"
31 #include "SMDS_IteratorOfElements.hxx"
32 #include "SMDS_MeshNode.hxx"
33 #include "SMDS_Mesh.hxx"
34
35 #include "utilities.h"
36
37 using namespace std;
38
39
40 //=======================================================================
41 //function : SMDS_QuadraticFaceOfNodes()
42 //purpose  : Constructor
43 //=======================================================================
44
45 SMDS_QuadraticFaceOfNodes::SMDS_QuadraticFaceOfNodes(const SMDS_MeshNode * n1,
46                                                      const SMDS_MeshNode * n2,
47                                                      const SMDS_MeshNode * n3,
48                                                      const SMDS_MeshNode * n12,
49                                                      const SMDS_MeshNode * n23,
50                                                      const SMDS_MeshNode * n31)
51 {
52   myNodes.resize( 6 );
53   myNodes[ 0 ] = n1;
54   myNodes[ 1 ] = n2;
55   myNodes[ 2 ] = n3;
56   myNodes[ 3 ] = n12;
57   myNodes[ 4 ] = n23;
58   myNodes[ 5 ] = n31;
59 }
60
61
62 //=======================================================================
63 //function : SMDS_QuadraticFaceOfNodes()
64 //purpose  : Constructor
65 //=======================================================================
66
67 SMDS_QuadraticFaceOfNodes::SMDS_QuadraticFaceOfNodes(const SMDS_MeshNode * n1,
68                                                      const SMDS_MeshNode * n2,
69                                                      const SMDS_MeshNode * n3,
70                                                      const SMDS_MeshNode * n4,
71                                                      const SMDS_MeshNode * n12,
72                                                      const SMDS_MeshNode * n23,
73                                                      const SMDS_MeshNode * n34,
74                                                      const SMDS_MeshNode * n41)
75 {
76   myNodes.resize( 8 );
77   myNodes[ 0 ] = n1;
78   myNodes[ 1 ] = n2;
79   myNodes[ 2 ] = n3;
80   myNodes[ 3 ] = n4;
81   myNodes[ 4 ] = n12;
82   myNodes[ 5 ] = n23;
83   myNodes[ 6 ] = n34;
84   myNodes[ 7 ] = n41;
85 }
86
87
88 //=======================================================================
89 //function : IsMediumNode
90 //purpose  : 
91 //=======================================================================
92
93 bool SMDS_QuadraticFaceOfNodes::IsMediumNode(const SMDS_MeshNode * node) const
94 {
95   int i=NbNodes()/2;
96   for(; i<NbNodes(); i++) {
97     if(myNodes[i]==node) return true;
98   }
99   return false;
100 }
101
102
103 //=======================================================================
104 //function : ChangeNodes
105 //purpose  : 
106 //=======================================================================
107
108 bool SMDS_QuadraticFaceOfNodes::ChangeNodes(const SMDS_MeshNode* nodes[],
109                                             const int            nbNodes)
110 {
111   if( nbNodes==6 || nbNodes==8 ) {
112     myNodes.resize(nbNodes);
113     int i=0;
114     for(; i<nbNodes; i++) {
115       myNodes[i] = nodes[i];
116     }
117     return true;
118   }
119   return false;
120 }
121
122
123 //=======================================================================
124 //function : NbNodes
125 //purpose  : 
126 //=======================================================================
127 int SMDS_QuadraticFaceOfNodes::NbNodes() const
128 {
129   return myNodes.size();
130 }
131
132
133 //=======================================================================
134 //function : NbEdges
135 //purpose  : 
136 //=======================================================================
137 int SMDS_QuadraticFaceOfNodes::NbEdges() const
138 {
139   return NbNodes()/2;
140 }
141
142
143 //=======================================================================
144 //function : NbFaces
145 //purpose  : 
146 //=======================================================================
147 int SMDS_QuadraticFaceOfNodes::NbFaces() const
148 {
149   return 1;
150 }
151
152 //=======================================================================
153 //function : Print
154 //purpose  : 
155 //=======================================================================
156 void SMDS_QuadraticFaceOfNodes::Print(ostream & OS) const
157 {
158   OS << "quadratic face <" << GetID() << " > : ";
159   int i, nbNodes = myNodes.size();
160   for (i = 0; i < nbNodes - 1; i++)
161     OS << myNodes[i] << ",";
162   OS << myNodes[i] << ") " << endl;
163 }
164
165 namespace {
166
167   //=======================================================================
168   //class : _MyInterlacedNodeIterator
169   //purpose  : 
170   //=======================================================================
171
172   class _MyInterlacedNodeIterator:public SMDS_NodeIterator
173   {
174     const vector<const SMDS_MeshNode *>& mySet;
175     int myIndex;
176     const int * myInterlace;
177   public:
178     _MyInterlacedNodeIterator(const vector<const SMDS_MeshNode *>& s,
179                               const int * interlace):
180       mySet(s),myIndex(0),myInterlace(interlace) {}
181
182     bool more()
183     {
184       return myIndex < mySet.size();
185     }
186
187     const SMDS_MeshNode* next()
188     {
189       return mySet[ myInterlace[ myIndex++ ]];
190     }
191   };
192
193   //=======================================================================
194   //class : _MyInterlacedNodeElemIterator
195   //purpose  : 
196   //=======================================================================
197
198   class _MyInterlacedNodeElemIterator : public SMDS_ElemIterator
199   {
200     SMDS_NodeIteratorPtr myItr;
201   public:
202     _MyInterlacedNodeElemIterator(SMDS_NodeIteratorPtr interlacedNodeItr):
203       myItr( interlacedNodeItr ) {}
204     bool more()                    { return myItr->more(); }
205     const SMDS_MeshElement* next() { return myItr->next(); }
206   };
207
208   //=======================================================================
209   //class : _MyNodeIterator
210   //purpose  : 
211   //=======================================================================
212
213   class _MyNodeIterator : public SMDS_NodeVectorElemIterator
214   {
215   public:
216     _MyNodeIterator(const vector<const SMDS_MeshNode *>& s):
217       SMDS_NodeVectorElemIterator( s.begin(), s.end() ) {}
218   };
219   
220 }
221
222 //=======================================================================
223 //function : interlacedNodesIterator
224 //purpose  : 
225 //=======================================================================
226
227 SMDS_NodeIteratorPtr SMDS_QuadraticFaceOfNodes::interlacedNodesIterator() const
228 {
229   static int triaInterlace [] = { 0, 3, 1, 4, 2, 5 };
230   static int quadInterlace [] = { 0, 4, 1, 5, 2, 6, 3, 7 };
231   return SMDS_NodeIteratorPtr
232     (new _MyInterlacedNodeIterator (myNodes, myNodes.size()==6 ? triaInterlace : quadInterlace));
233 }
234
235 //=======================================================================
236 //function : interlacedNodesElemIterator
237 //purpose  : 
238 //=======================================================================
239
240 SMDS_ElemIteratorPtr SMDS_QuadraticFaceOfNodes::interlacedNodesElemIterator() const
241 {
242   return SMDS_ElemIteratorPtr
243     (new _MyInterlacedNodeElemIterator ( interlacedNodesIterator() ));
244 }
245 /// ===================================================================
246 /*!
247  * \brief Iterator on edges of face
248  */
249 /// ===================================================================
250
251 class _MyEdgeIterator : public SMDS_ElemIterator
252 {
253   vector< const SMDS_MeshElement* > myElems;
254   int myIndex;
255 public:
256   _MyEdgeIterator(const SMDS_QuadraticFaceOfNodes* face):myIndex(0) {
257     myElems.reserve( face->NbNodes() );
258     SMDS_ElemIteratorPtr nIt = face->interlacedNodesElemIterator();
259     const SMDS_MeshNode* n0 = face->GetNodeWrap( -1 );
260     while ( nIt->more() ) {
261       const SMDS_MeshNode* n1 = static_cast<const SMDS_MeshNode*>( nIt->next() );
262       const SMDS_MeshElement* edge = SMDS_Mesh::FindEdge( n0, n1 );
263       if ( edge )
264         myElems.push_back( edge );
265       n0 = n1;
266     }
267   }
268   /// Return true if and only if there are other object in this iterator
269   virtual bool more() { return myIndex < myElems.size(); }
270
271   /// Return the current object and step to the next one
272   virtual const SMDS_MeshElement* next() { return myElems[ myIndex++ ]; }
273 };
274
275 //=======================================================================
276 //function : elementsIterator
277 //purpose  : 
278 //=======================================================================
279
280 SMDS_ElemIteratorPtr SMDS_QuadraticFaceOfNodes::elementsIterator
281                                          (SMDSAbs_ElementType type) const
282 {
283   switch(type)
284   {
285   case SMDSAbs_Face:
286     return SMDS_MeshElement::elementsIterator(SMDSAbs_Face);
287   case SMDSAbs_Node:
288     return SMDS_ElemIteratorPtr(new _MyNodeIterator(myNodes));
289   case SMDSAbs_Edge:
290     return SMDS_ElemIteratorPtr(new _MyEdgeIterator( this ));
291     break;
292   default:
293     return SMDS_ElemIteratorPtr
294       (new SMDS_IteratorOfElements
295        (this,type,SMDS_ElemIteratorPtr (new _MyNodeIterator(myNodes))));
296   }
297   return SMDS_ElemIteratorPtr();
298 }
299
300 /*!
301  * \brief Return node by its index
302  * \param ind - node index
303  * \retval const SMDS_MeshNode* - the node
304  */
305 const SMDS_MeshNode* SMDS_QuadraticFaceOfNodes::GetNode(const int ind) const
306 {
307   return myNodes[ ind ];
308 }
309
310 SMDSAbs_EntityType SMDS_QuadraticFaceOfNodes::GetEntityType() const
311 {
312   return NbNodes() == 6 ? SMDSEntity_Quad_Triangle : SMDSEntity_Quad_Quadrangle;
313 }