]> SALOME platform Git repositories - modules/smesh.git/blob - src/SMESHDS/SMESHDS_Command.cxx
Salome HOME
Fix for bugs IPAL12061, PAL9227
[modules/smesh.git] / src / SMESHDS / SMESHDS_Command.cxx
1 //  SMESH SMESHDS : management of mesh data and SMESH document
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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org 
21 //
22 //
23 //
24 //  File   : SMESH_Command.cxx
25 //  Author : Yves FRICAUD, OCC
26 //  Module : SMESH
27 //  $Header: 
28
29 #include "SMESHDS_Command.hxx"
30
31 #include "utilities.h"
32
33 using namespace std;
34
35 //=======================================================================
36 //function : Constructor
37 //purpose  : 
38 //=======================================================================
39 SMESHDS_Command::SMESHDS_Command(const SMESHDS_CommandType aType):myType(aType),
40 myNumber(0)
41 {
42 }
43
44 //=======================================================================
45 //function : Destructor
46 //purpose  : 
47 //=======================================================================
48 SMESHDS_Command::~SMESHDS_Command()
49 {
50 }
51
52 //=======================================================================
53 //function : 
54 //purpose  : 
55 //=======================================================================
56 void SMESHDS_Command::AddNode(int NewNodeID, double x, double y, double z)
57 {
58         if (!myType == SMESHDS_AddNode)
59         {
60                 MESSAGE("SMESHDS_Command::AddNode : Bad Type");
61                 return;
62         }
63         myIntegers.push_back(NewNodeID);
64         myReals.push_back(x);
65         myReals.push_back(y);
66         myReals.push_back(z);
67         myNumber++;
68 }
69
70 //=======================================================================
71 //function : 
72 //purpose  : 
73 //=======================================================================
74 void SMESHDS_Command::MoveNode(int NodeID, double x, double y, double z)
75 {
76         if (!myType == SMESHDS_MoveNode)
77         {
78                 MESSAGE("SMESHDS_Command::MoveNode : Bad Type");
79                 return;
80         }
81         myIntegers.push_back(NodeID);
82         myReals.push_back(x);
83         myReals.push_back(y);
84         myReals.push_back(z);
85         myNumber++;
86 }
87
88 //=======================================================================
89 //function : 
90 //purpose  : 
91 //=======================================================================
92 void SMESHDS_Command::AddEdge(int NewEdgeID, int idnode1, int idnode2)
93 {
94         if (!myType == SMESHDS_AddEdge)
95         {
96                 MESSAGE("SMESHDS_Command::AddEdge : Bad Type");
97                 return;
98         }
99         myIntegers.push_back(NewEdgeID);
100         myIntegers.push_back(idnode1);
101         myIntegers.push_back(idnode2);
102         myNumber++;
103 }
104
105 //=======================================================================
106 //function : 
107 //purpose  : 
108 //=======================================================================
109 void SMESHDS_Command::AddFace(int NewFaceID,
110         int idnode1, int idnode2, int idnode3)
111 {
112         if (!myType == SMESHDS_AddTriangle)
113         {
114                 MESSAGE("SMESHDS_Command::AddFace : Bad Type");
115                 return;
116         }
117         myIntegers.push_back(NewFaceID);
118         myIntegers.push_back(idnode1);
119         myIntegers.push_back(idnode2);
120         myIntegers.push_back(idnode3);
121         myNumber++;
122 }
123
124 //=======================================================================
125 //function : 
126 //purpose  : 
127 //=======================================================================
128 void SMESHDS_Command::AddFace(int NewFaceID,
129         int idnode1, int idnode2, int idnode3, int idnode4)
130 {
131         if (!myType == SMESHDS_AddQuadrangle)
132         {
133                 MESSAGE("SMESHDS_Command::AddFace : Bad Type");
134                 return;
135         }
136         myIntegers.push_back(NewFaceID);
137         myIntegers.push_back(idnode1);
138         myIntegers.push_back(idnode2);
139         myIntegers.push_back(idnode3);
140         myIntegers.push_back(idnode4);
141         myNumber++;
142 }
143
144 //=======================================================================
145 //function : 
146 //purpose  : 
147 //=======================================================================
148 void SMESHDS_Command::AddVolume(int NewVolID,
149         int idnode1, int idnode2, int idnode3, int idnode4)
150 {
151         if (!myType == SMESHDS_AddTetrahedron)
152         {
153                 MESSAGE("SMESHDS_Command::AddVolume : Bad Type");
154                 return;
155         }
156         myIntegers.push_back(NewVolID);
157         myIntegers.push_back(idnode1);
158         myIntegers.push_back(idnode2);
159         myIntegers.push_back(idnode3);
160         myIntegers.push_back(idnode4);
161         myNumber++;
162 }
163
164 //=======================================================================
165 //function : 
166 //purpose  : 
167 //=======================================================================
168 void SMESHDS_Command::AddVolume(int NewVolID,
169         int idnode1, int idnode2, int idnode3, int idnode4, int idnode5)
170 {
171         if (!myType == SMESHDS_AddPyramid)
172         {
173                 MESSAGE("SMESHDS_Command::AddVolume : Bad Type");
174                 return;
175         }
176         myIntegers.push_back(NewVolID);
177         myIntegers.push_back(idnode1);
178         myIntegers.push_back(idnode2);
179         myIntegers.push_back(idnode3);
180         myIntegers.push_back(idnode4);
181         myIntegers.push_back(idnode5);
182         myNumber++;
183 }
184
185 //=======================================================================
186 //function : 
187 //purpose  : 
188 //=======================================================================
189 void SMESHDS_Command::AddVolume(int NewVolID,
190         int idnode1,
191         int idnode2, int idnode3, int idnode4, int idnode5, int idnode6)
192 {
193         if (!myType == SMESHDS_AddPrism)
194         {
195                 MESSAGE("SMESHDS_Command::AddVolume : Bad Type");
196                 return;
197         }
198         myIntegers.push_back(NewVolID);
199         myIntegers.push_back(idnode1);
200         myIntegers.push_back(idnode2);
201         myIntegers.push_back(idnode3);
202         myIntegers.push_back(idnode4);
203         myIntegers.push_back(idnode5);
204         myIntegers.push_back(idnode6);
205         myNumber++;
206 }
207
208 //=======================================================================
209 //function : 
210 //purpose  : 
211 //=======================================================================
212 void SMESHDS_Command::AddVolume(int NewVolID,
213         int idnode1,
214         int idnode2,
215         int idnode3,
216         int idnode4, int idnode5, int idnode6, int idnode7, int idnode8)
217 {
218         if (!myType == SMESHDS_AddHexahedron)
219         {
220                 MESSAGE("SMESHDS_Command::AddVolume : Bad Type");
221                 return;
222         }
223         myIntegers.push_back(NewVolID);
224         myIntegers.push_back(idnode1);
225         myIntegers.push_back(idnode2);
226         myIntegers.push_back(idnode3);
227         myIntegers.push_back(idnode4);
228         myIntegers.push_back(idnode5);
229         myIntegers.push_back(idnode6);
230         myIntegers.push_back(idnode7);
231         myIntegers.push_back(idnode8);
232         myNumber++;
233 }
234
235 //=======================================================================
236 //function : AddPolygonalFace
237 //purpose  : 
238 //=======================================================================
239 void SMESHDS_Command::AddPolygonalFace (const int        ElementID,
240                                         std::vector<int> nodes_ids)
241 {
242   if (!myType == SMESHDS_AddPolygon) {
243     MESSAGE("SMESHDS_Command::AddPolygonalFace : Bad Type");
244     return;
245   }
246   myIntegers.push_back(ElementID);
247
248   int i, nbNodes = nodes_ids.size();
249   myIntegers.push_back(nbNodes);
250   for (i = 0; i < nbNodes; i++) {
251     myIntegers.push_back(nodes_ids[i]);
252   }
253
254   myNumber++;
255 }
256
257 //=======================================================================
258 //function : AddPolyhedralVolume
259 //purpose  : 
260 //=======================================================================
261 void SMESHDS_Command::AddPolyhedralVolume (const int        ElementID,
262                                            std::vector<int> nodes_ids,
263                                            std::vector<int> quantities)
264 {
265   if (!myType == SMESHDS_AddPolyhedron) {
266     MESSAGE("SMESHDS_Command::AddPolyhedralVolume : Bad Type");
267     return;
268   }
269   myIntegers.push_back(ElementID);
270
271   int i, nbNodes = nodes_ids.size();
272   myIntegers.push_back(nbNodes);
273   for (i = 0; i < nbNodes; i++) {
274     myIntegers.push_back(nodes_ids[i]);
275   }
276
277   int nbFaces = quantities.size();
278   myIntegers.push_back(nbFaces);
279   for (i = 0; i < nbFaces; i++) {
280     myIntegers.push_back(quantities[i]);
281   }
282
283   myNumber++;
284 }
285
286 //=======================================================================
287 //function : 
288 //purpose  : 
289 //=======================================================================
290 void SMESHDS_Command::RemoveNode(int NodeID)
291 {
292         if (!myType == SMESHDS_RemoveNode)
293         {
294                 MESSAGE("SMESHDS_Command::RemoveNode : Bad Type");
295                 return;
296         }
297         myIntegers.push_back(NodeID);
298         myNumber++;
299 }
300
301 //=======================================================================
302 //function : 
303 //purpose  : 
304 //=======================================================================
305 void SMESHDS_Command::RemoveElement(int ElementID)
306 {
307         if (!myType == SMESHDS_RemoveElement)
308         {
309                 MESSAGE("SMESHDS_Command::RemoveElement : Bad Type");
310                 return;
311         }
312         myIntegers.push_back(ElementID);
313         myNumber++;
314 }
315
316 //=======================================================================
317 //function : ChangeElementNodes
318 //purpose  : 
319 //=======================================================================
320
321 void SMESHDS_Command::ChangeElementNodes(int ElementID, int nodes[], int nbnodes)
322 {
323   if (!myType == SMESHDS_ChangeElementNodes)
324   {
325     MESSAGE("SMESHDS_Command::ChangeElementNodes : Bad Type");
326     return;
327   }
328   myIntegers.push_back(ElementID);
329   myIntegers.push_back(nbnodes);
330   for ( int i = 0; i < nbnodes; i++ )
331     myIntegers.push_back( nodes[ i ] );
332
333   myNumber++;
334 }
335
336 //=======================================================================
337 //function : ChangePolyhedronNodes
338 //purpose  : 
339 //=======================================================================
340 void SMESHDS_Command::ChangePolyhedronNodes (const int ElementID,
341                                              std::vector<int> nodes_ids,
342                                              std::vector<int> quantities)
343 {
344   if (myType != SMESHDS_ChangePolyhedronNodes)
345   {
346     MESSAGE("SMESHDS_Command::ChangePolyhedronNodes : Bad Type");
347     return;
348   }
349   myIntegers.push_back(ElementID);
350
351   int i, nbNodes = nodes_ids.size();
352   myIntegers.push_back(nbNodes);
353   for (i = 0; i < nbNodes; i++) {
354     myIntegers.push_back(nodes_ids[i]);
355   }
356
357   int nbFaces = quantities.size();
358   myIntegers.push_back(nbFaces);
359   for (i = 0; i < nbFaces; i++) {
360     myIntegers.push_back(quantities[i]);
361   }
362
363   myNumber++;
364 }
365
366 //=======================================================================
367 //function : Renumber
368 //purpose  : 
369 //=======================================================================
370
371 void SMESHDS_Command::Renumber (const bool isNodes, const int startID, const int deltaID)
372 {
373   if (!myType == SMESHDS_Renumber)
374   {
375     MESSAGE("SMESHDS_Command::Renumber : Bad Type");
376     return;
377   }
378   myIntegers.push_back(isNodes);
379   myIntegers.push_back(startID);
380   myIntegers.push_back(deltaID);
381   myNumber++;
382 }
383
384 //=======================================================================
385 //function : 
386 //purpose  : 
387 //=======================================================================
388 SMESHDS_CommandType SMESHDS_Command::GetType()
389 {
390         return myType;
391 }
392
393 //=======================================================================
394 //function : 
395 //purpose  : 
396 //=======================================================================
397 int SMESHDS_Command::GetNumber()
398 {
399         return myNumber;
400 }
401
402 //=======================================================================
403 //function : 
404 //purpose  : 
405 //=======================================================================
406 const list < int >&SMESHDS_Command::GetIndexes()
407 {
408         return myIntegers;
409 }
410
411 //=======================================================================
412 //function : 
413 //purpose  : 
414 //=======================================================================
415 const list < double >&SMESHDS_Command::GetCoords()
416 {
417         return myReals;
418 }
419
420
421 //********************************************************************
422 //*****             Methods for quadratic elements              ******
423 //********************************************************************
424
425 //=======================================================================
426 //function : AddEdge
427 //purpose  : 
428 //=======================================================================
429 void SMESHDS_Command::AddEdge(int NewEdgeID, int n1, int n2, int n12)
430 {
431   if (!myType == SMESHDS_AddQuadEdge) {
432     MESSAGE("SMESHDS_Command::AddEdge : Bad Type");
433     return;
434   }
435   myIntegers.push_back(NewEdgeID);
436   myIntegers.push_back(n1);
437   myIntegers.push_back(n2);
438   myIntegers.push_back(n12);
439   myNumber++;
440 }
441
442 //=======================================================================
443 //function : AddFace
444 //purpose  : 
445 //=======================================================================
446 void SMESHDS_Command::AddFace(int NewFaceID,
447                               int n1, int n2, int n3,
448                               int n12, int n23, int n31)
449 {
450   if (!myType == SMESHDS_AddQuadTriangle) {
451     MESSAGE("SMESHDS_Command::AddFace : Bad Type");
452     return;
453   }
454   myIntegers.push_back(NewFaceID);
455   myIntegers.push_back(n1);
456   myIntegers.push_back(n2);
457   myIntegers.push_back(n3);
458   myIntegers.push_back(n12);
459   myIntegers.push_back(n23);
460   myIntegers.push_back(n31);
461   myNumber++;
462 }
463
464 //=======================================================================
465 //function : AddFace
466 //purpose  : 
467 //=======================================================================
468 void SMESHDS_Command::AddFace(int NewFaceID,
469                               int n1, int n2, int n3, int n4,
470                               int n12, int n23, int n34, int n41)
471 {
472   if (!myType == SMESHDS_AddQuadQuadrangle) {
473     MESSAGE("SMESHDS_Command::AddFace : Bad Type");
474     return;
475   }
476   myIntegers.push_back(NewFaceID);
477   myIntegers.push_back(n1);
478   myIntegers.push_back(n2);
479   myIntegers.push_back(n3);
480   myIntegers.push_back(n4);
481   myIntegers.push_back(n12);
482   myIntegers.push_back(n23);
483   myIntegers.push_back(n34);
484   myIntegers.push_back(n41);
485   myNumber++;
486 }
487
488 //=======================================================================
489 //function : AddVolume
490 //purpose  : 
491 //=======================================================================
492 void SMESHDS_Command::AddVolume(int NewVolID, int n1, int n2, int n3, int n4,
493                                 int n12, int n23, int n31,
494                                 int n14, int n24, int n34)
495 {
496   if (!myType == SMESHDS_AddQuadTetrahedron) {
497     MESSAGE("SMESHDS_Command::AddVolume : Bad Type");
498     return;
499   }
500   myIntegers.push_back(NewVolID);
501   myIntegers.push_back(n1);
502   myIntegers.push_back(n2);
503   myIntegers.push_back(n3);
504   myIntegers.push_back(n4);
505   myIntegers.push_back(n12);
506   myIntegers.push_back(n23);
507   myIntegers.push_back(n31);
508   myIntegers.push_back(n14);
509   myIntegers.push_back(n24);
510   myIntegers.push_back(n34);
511   myNumber++;
512 }
513
514 //=======================================================================
515 //function : AddVolume
516 //purpose  : 
517 //=======================================================================
518 void SMESHDS_Command::AddVolume(int NewVolID, int n1, int n2,
519                                 int n3, int n4, int n5,
520                                 int n12, int n23, int n34, int n41,
521                                 int n15, int n25, int n35, int n45)
522 {
523   if (!myType == SMESHDS_AddQuadPyramid) {
524     MESSAGE("SMESHDS_Command::AddVolume : Bad Type");
525     return;
526   }
527   myIntegers.push_back(NewVolID);
528   myIntegers.push_back(n1);
529   myIntegers.push_back(n2);
530   myIntegers.push_back(n3);
531   myIntegers.push_back(n4);
532   myIntegers.push_back(n5);
533   myIntegers.push_back(n12);
534   myIntegers.push_back(n23);
535   myIntegers.push_back(n34);
536   myIntegers.push_back(n41);
537   myIntegers.push_back(n15);
538   myIntegers.push_back(n25);
539   myIntegers.push_back(n35);
540   myIntegers.push_back(n45);
541   myNumber++;
542 }
543
544 //=======================================================================
545 //function : AddVolume
546 //purpose  : 
547 //=======================================================================
548 void SMESHDS_Command::AddVolume(int NewVolID, int n1, int n2,
549                                 int n3, int n4, int n5,int n6,
550                                 int n12, int n23, int n31,
551                                 int n45, int n56, int n64,
552                                 int n14, int n25, int n36)
553 {
554   if (!myType == SMESHDS_AddQuadPentahedron) {
555     MESSAGE("SMESHDS_Command::AddVolume : Bad Type");
556     return;
557   }
558   myIntegers.push_back(NewVolID);
559   myIntegers.push_back(n1);
560   myIntegers.push_back(n2);
561   myIntegers.push_back(n3);
562   myIntegers.push_back(n4);
563   myIntegers.push_back(n5);
564   myIntegers.push_back(n6);
565   myIntegers.push_back(n12);
566   myIntegers.push_back(n23);
567   myIntegers.push_back(n31);
568   myIntegers.push_back(n45);
569   myIntegers.push_back(n56);
570   myIntegers.push_back(n64);
571   myIntegers.push_back(n14);
572   myIntegers.push_back(n25);
573   myIntegers.push_back(n36);
574   myNumber++;
575 }
576
577 //=======================================================================
578 //function : AddVolume
579 //purpose  : 
580 //=======================================================================
581 void SMESHDS_Command::AddVolume(int NewVolID, int n1, int n2, int n3,
582                                 int n4, int n5, int n6, int n7, int n8,
583                                 int n12, int n23, int n34, int n41,
584                                 int n56, int n67, int n78, int n85,
585                                 int n15, int n26, int n37, int n48)
586 {
587   if (!myType == SMESHDS_AddQuadHexahedron) {
588     MESSAGE("SMESHDS_Command::AddVolume : Bad Type");
589     return;
590   }
591   myIntegers.push_back(NewVolID);
592   myIntegers.push_back(n1);
593   myIntegers.push_back(n2);
594   myIntegers.push_back(n3);
595   myIntegers.push_back(n4);
596   myIntegers.push_back(n5);
597   myIntegers.push_back(n6);
598   myIntegers.push_back(n7);
599   myIntegers.push_back(n8);
600   myIntegers.push_back(n12);
601   myIntegers.push_back(n23);
602   myIntegers.push_back(n34);
603   myIntegers.push_back(n41);
604   myIntegers.push_back(n56);
605   myIntegers.push_back(n67);
606   myIntegers.push_back(n78);
607   myIntegers.push_back(n85);
608   myIntegers.push_back(n15);
609   myIntegers.push_back(n26);
610   myIntegers.push_back(n37);
611   myIntegers.push_back(n48);
612   myNumber++;
613 }
614