]> SALOME platform Git repositories - modules/smesh.git/blob - src/DriverMED/DriverMED_Family.cxx
Salome HOME
Fix compilation of gcc 4.3.2
[modules/smesh.git] / src / DriverMED / DriverMED_Family.cxx
1 //  Copyright (C) 2007-2008  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 //  SMESH DriverMED : tool to split groups on families
23 //  File   : DriverMED_Family.cxx
24 //  Author : Julia DOROVSKIKH
25 //  Module : SMESH
26 //  $Header$
27 //
28 #include "DriverMED_Family.h"
29 #include "MED_Factory.hxx"
30
31 #include <sstream>      
32
33 using namespace std;
34
35 //=============================================================================
36 /*!
37  *  Default constructor
38  */
39 //=============================================================================
40 DriverMED_Family
41 ::DriverMED_Family():
42   myGroupAttributVal(0)
43 {}
44
45
46 //=============================================================================
47 const ElementsSet& 
48 DriverMED_Family
49 ::GetElements () const 
50
51   return myElements; 
52 }
53
54 int 
55 DriverMED_Family
56 ::GetId () const 
57
58   return myId; 
59 }
60
61 void 
62 DriverMED_Family
63 ::SetId (const int theId) 
64
65   myId = theId; 
66 }
67
68 void
69 DriverMED_Family
70 ::AddElement(const SMDS_MeshElement* theElement)
71 {
72   myElements.insert(theElement); 
73 }
74
75 void
76 DriverMED_Family
77 ::AddGroupName(std::string theGroupName)
78 {
79   myGroupNames.insert(theGroupName); 
80 }
81
82 void
83 DriverMED_Family
84 ::SetType(const SMDSAbs_ElementType theType) 
85
86   myType = theType; 
87 }
88
89 SMDSAbs_ElementType
90 DriverMED_Family
91 ::GetType()
92 {
93   return myType; 
94 }
95
96 bool
97 DriverMED_Family
98 ::MemberOf(std::string theGroupName) const
99
100   return myGroupNames.find(theGroupName) != myGroupNames.end(); 
101 }
102
103 const MED::TStringSet& 
104 DriverMED_Family
105 ::GetGroupNames () const 
106
107   return myGroupNames; 
108 }
109
110
111 int 
112 DriverMED_Family
113 ::GetGroupAttributVal() const 
114 {
115   return myGroupAttributVal;
116
117
118 void
119 DriverMED_Family
120 ::SetGroupAttributVal( int theValue) 
121 {
122   myGroupAttributVal = theValue;
123 }
124
125 bool
126 DriverMED_Family
127 ::IsEmpty () const 
128
129   return myElements.empty(); 
130 }
131
132 //=============================================================================
133 /*!
134  *  Split each group from list <aGroups> on some parts (families)
135  *  on the basis of the elements membership in other groups from this list.
136  *  Resulting families have no common elements.
137  */
138 //=============================================================================
139 DriverMED_FamilyPtrList 
140 DriverMED_Family
141 ::MakeFamilies(const SMESHDS_SubMeshPtrMap& theSubMeshes,
142                const SMESHDS_GroupBasePtrList& theGroups,
143                const bool doGroupOfNodes,
144                const bool doGroupOfEdges,
145                const bool doGroupOfFaces,
146                const bool doGroupOfVolumes)
147 {
148   DriverMED_FamilyPtrList aFamilies;
149
150   string anAllNodesGroupName = "Group_Of_All_Nodes";
151   string anAllEdgesGroupName = "Group_Of_All_Edges";
152   string anAllFacesGroupName = "Group_Of_All_Faces";
153   string anAllVolumesGroupName = "Group_Of_All_Volumes";
154
155   // Reserve four ids for families of free elements
156   // (1 - nodes, -1 - edges, -2 - faces, -3 - volumes).
157   // 'Free' means here not belonging to any group.
158   int aNodeFamId = FIRST_NODE_FAMILY;
159   int aElemFamId = FIRST_ELEM_FAMILY;
160
161   // Process sub-meshes
162   SMESHDS_SubMeshPtrMap::const_iterator aSMIter = theSubMeshes.begin();
163   for (; aSMIter != theSubMeshes.end(); aSMIter++)
164   {
165     const int anId = aSMIter->first;
166     SMESHDS_SubMesh* aSubMesh = aSMIter->second;
167     if ( aSubMesh->IsComplexSubmesh() )
168       continue; // submesh containing other submeshs
169     DriverMED_FamilyPtrList aSMFams = SplitByType(aSubMesh,anId);
170     DriverMED_FamilyPtrList::iterator aSMFamsIter = aSMFams.begin();
171     for (; aSMFamsIter != aSMFams.end(); aSMFamsIter++)
172     {
173       DriverMED_FamilyPtr aFam2 = (*aSMFamsIter);
174       DriverMED_FamilyPtrList::iterator aFamsIter = aFamilies.begin();
175       while (aFamsIter != aFamilies.end())
176       {
177         DriverMED_FamilyPtr aFam1 = *aFamsIter;
178         DriverMED_FamilyPtrList::iterator aCurrIter = aFamsIter++;
179         if (aFam1->myType == aFam2->myType)
180         {
181           DriverMED_FamilyPtr aCommon (new DriverMED_Family);
182           aFam1->Split(aFam2, aCommon);
183           if (!aCommon->IsEmpty())
184           {
185             aFamilies.push_back(aCommon);
186           }
187           if (aFam1->IsEmpty())
188           {
189             aFamilies.erase(aCurrIter);
190           }
191           if (aFam2->IsEmpty()) 
192             break;
193         }
194       }
195       // The rest elements of family
196       if (!aFam2->IsEmpty())
197       {
198         aFamilies.push_back(aFam2);
199       }
200     }
201   }
202
203   // Process groups
204   SMESHDS_GroupBasePtrList::const_iterator aGroupsIter = theGroups.begin();
205   for (; aGroupsIter != theGroups.end(); aGroupsIter++)
206   {
207     DriverMED_FamilyPtr aFam2 (new DriverMED_Family);
208     aFam2->Init(*aGroupsIter);
209
210     DriverMED_FamilyPtrList::iterator aFamsIter = aFamilies.begin();
211     while (aFamsIter != aFamilies.end())
212     {
213       DriverMED_FamilyPtr aFam1 = *aFamsIter;
214       DriverMED_FamilyPtrList::iterator aCurrIter = aFamsIter++;
215       if (aFam1->myType == aFam2->myType)
216       {
217         DriverMED_FamilyPtr aCommon (new DriverMED_Family);
218         aFam1->Split(aFam2, aCommon);
219         if (!aCommon->IsEmpty())
220         {
221           aCommon->SetGroupAttributVal(0);
222           aFamilies.push_back(aCommon);
223         }
224         if (aFam1->IsEmpty())
225         {
226           aFamilies.erase(aCurrIter);
227         }
228         if (aFam2->IsEmpty()) 
229           break;
230       }
231     }
232     // The rest elements of group
233     if (!aFam2->IsEmpty())
234     {
235       aFamilies.push_back(aFam2);
236     }
237   }
238
239   DriverMED_FamilyPtrList::iterator aFamsIter = aFamilies.begin();
240   for (; aFamsIter != aFamilies.end(); aFamsIter++)
241   {
242     DriverMED_FamilyPtr aFam = *aFamsIter;
243     if (aFam->myType == SMDSAbs_Node) {
244       aFam->SetId(aNodeFamId++);
245       if (doGroupOfNodes) aFam->myGroupNames.insert(anAllNodesGroupName);
246     }
247     else {
248       aFam->SetId(aElemFamId--);
249       if (aFam->myType == SMDSAbs_Edge) {
250         if (doGroupOfEdges) aFam->myGroupNames.insert(anAllEdgesGroupName);
251       }
252       else if (aFam->myType == SMDSAbs_Face) {
253         if (doGroupOfFaces) aFam->myGroupNames.insert(anAllFacesGroupName);
254       }
255       else if (aFam->myType == SMDSAbs_Volume) {
256         if (doGroupOfVolumes) aFam->myGroupNames.insert(anAllVolumesGroupName);
257       }
258     }
259   }
260
261   // Create families for elements, not belonging to any group
262   if (doGroupOfNodes)
263   {
264     DriverMED_FamilyPtr aFreeNodesFam (new DriverMED_Family);
265     aFreeNodesFam->SetId(REST_NODES_FAMILY);
266     aFreeNodesFam->myType = SMDSAbs_Node;
267     aFreeNodesFam->myGroupNames.insert(anAllNodesGroupName);
268     aFamilies.push_back(aFreeNodesFam);
269   }
270
271   if (doGroupOfEdges)
272   {
273     DriverMED_FamilyPtr aFreeEdgesFam (new DriverMED_Family);
274     aFreeEdgesFam->SetId(REST_EDGES_FAMILY);
275     aFreeEdgesFam->myType = SMDSAbs_Edge;
276     aFreeEdgesFam->myGroupNames.insert(anAllEdgesGroupName);
277     aFamilies.push_back(aFreeEdgesFam);
278   }
279
280   if (doGroupOfFaces)
281   {
282     DriverMED_FamilyPtr aFreeFacesFam (new DriverMED_Family);
283     aFreeFacesFam->SetId(REST_FACES_FAMILY);
284     aFreeFacesFam->myType = SMDSAbs_Face;
285     aFreeFacesFam->myGroupNames.insert(anAllFacesGroupName);
286     aFamilies.push_back(aFreeFacesFam);
287   }
288
289   if (doGroupOfVolumes)
290   {
291     DriverMED_FamilyPtr aFreeVolumesFam (new DriverMED_Family);
292     aFreeVolumesFam->SetId(REST_VOLUMES_FAMILY);
293     aFreeVolumesFam->myType = SMDSAbs_Volume;
294     aFreeVolumesFam->myGroupNames.insert(anAllVolumesGroupName);
295     aFamilies.push_back(aFreeVolumesFam);
296   }
297
298   DriverMED_FamilyPtr aNullFam (new DriverMED_Family);
299   aNullFam->SetId(0);
300   aNullFam->myType = SMDSAbs_All;
301   aFamilies.push_back(aNullFam);
302
303   return aFamilies;
304 }
305
306 //=============================================================================
307 /*!
308  *  Create TFamilyInfo for this family
309  */
310 //=============================================================================
311 MED::PFamilyInfo 
312 DriverMED_Family::GetFamilyInfo(const MED::PWrapper& theWrapper, 
313                                 const MED::PMeshInfo& theMeshInfo) const
314 {
315   ostringstream aStr;
316   aStr << "FAM_" << myId;
317   set<string>::const_iterator aGrIter = myGroupNames.begin();
318   for(; aGrIter != myGroupNames.end(); aGrIter++){
319     aStr << "_" << *aGrIter;
320   }
321   string aValue = aStr.str();
322   // PAL19785,0019867 - med forbids whitespace to be the last char in the name
323   int maxSize;
324   if ( theWrapper->GetVersion() == MED::eV2_1 )
325     maxSize = MED::GetNOMLength<MED::eV2_1>();
326   else
327     maxSize = MED::GetNOMLength<MED::eV2_2>();
328   int lastCharPos = min( maxSize, (int) aValue.size() ) - 1;
329   while ( isspace( aValue[ lastCharPos ] ))
330     aValue.resize( lastCharPos-- );
331
332   MED::PFamilyInfo anInfo;
333   if(myId == 0 || myGroupAttributVal == 0){
334     anInfo = theWrapper->CrFamilyInfo(theMeshInfo,
335                                       aValue,
336                                       myId,
337                                       myGroupNames);
338   }else{
339     MED::TStringVector anAttrDescs (1, "");  // 1 attribute with empty description,
340     MED::TIntVector anAttrIds (1, myId);        // Id=0,
341     MED::TIntVector anAttrVals (1, myGroupAttributVal);
342     anInfo = theWrapper->CrFamilyInfo(theMeshInfo,
343                                       aValue,
344                                       myId,
345                                       myGroupNames,
346                                       anAttrDescs,
347                                       anAttrIds,
348                                       anAttrVals);
349   }
350
351 //  cout << endl;
352 //  cout << "Groups: ";
353 //  set<string>::iterator aGrIter = myGroupNames.begin();
354 //  for (; aGrIter != myGroupNames.end(); aGrIter++)
355 //  {
356 //    cout << " " << *aGrIter;
357 //  }
358 //  cout << endl;
359 //
360 //  cout << "Elements: ";
361 //  set<const SMDS_MeshElement *>::iterator anIter = myElements.begin();
362 //  for (; anIter != myElements.end(); anIter++)
363 //  {
364 //    cout << " " << (*anIter)->GetID();
365 //  }
366 //  cout << endl;
367
368   return anInfo;
369 }
370
371 //=============================================================================
372 /*!
373  *  Initialize the tool by SMESHDS_GroupBase
374  */
375 //=============================================================================
376 void DriverMED_Family::Init (SMESHDS_GroupBase* theGroup)
377 {
378   // Elements
379   myElements.clear();
380   SMDS_ElemIteratorPtr elemIt = theGroup->GetElements();
381   while (elemIt->more())
382   {
383     myElements.insert(elemIt->next());
384   }
385
386   // Type
387   myType = theGroup->GetType();
388
389   // Groups list
390   myGroupNames.clear();
391   myGroupNames.insert(string(theGroup->GetStoreName()));
392
393   Quantity_Color aColor = theGroup->GetColor();
394   double aRed = aColor.Red();
395   double aGreen = aColor.Green();
396   double aBlue = aColor.Blue();
397   int aR = int( aRed*255   );
398   int aG = int( aGreen*255 );
399   int aB = int( aBlue*255  );
400 //   cout << "aRed = " << aR << endl;
401 //   cout << "aGreen = " << aG << endl;
402 //   cout << "aBlue = " << aB << endl;
403   myGroupAttributVal = (int)(aR*1000000 + aG*1000 + aB);
404   //cout << "myGroupAttributVal = " << myGroupAttributVal << endl;
405 }
406
407 //=============================================================================
408 /*!
409  *  Split <theSubMesh> on some parts (families)
410  *  on the basis of the elements type.
411  */
412 //=============================================================================
413 DriverMED_FamilyPtrList 
414 DriverMED_Family
415 ::SplitByType (SMESHDS_SubMesh* theSubMesh,
416                const int        theId)
417 {
418   DriverMED_FamilyPtrList aFamilies;
419   DriverMED_FamilyPtr aNodesFamily   (new DriverMED_Family);
420   DriverMED_FamilyPtr anEdgesFamily  (new DriverMED_Family);
421   DriverMED_FamilyPtr aFacesFamily   (new DriverMED_Family);
422   DriverMED_FamilyPtr aVolumesFamily (new DriverMED_Family);
423
424   char submeshGrpName[ 30 ];
425   sprintf( submeshGrpName, "SubMesh %d", theId );
426
427   SMDS_NodeIteratorPtr aNodesIter = theSubMesh->GetNodes();
428   while (aNodesIter->more())
429   {
430     const SMDS_MeshNode* aNode = aNodesIter->next();
431     aNodesFamily->AddElement(aNode);
432   }
433
434   SMDS_ElemIteratorPtr anElemsIter = theSubMesh->GetElements();
435   while (anElemsIter->more())
436   {
437     const SMDS_MeshElement* anElem = anElemsIter->next();
438     switch (anElem->GetType())
439     {
440     case SMDSAbs_Edge:
441       anEdgesFamily->AddElement(anElem);
442       break;
443     case SMDSAbs_Face:
444       aFacesFamily->AddElement(anElem);
445       break;
446     case SMDSAbs_Volume:
447       aVolumesFamily->AddElement(anElem);
448       break;
449     default:
450       break;
451     }
452   }
453
454   if (!aNodesFamily->IsEmpty()) {
455     aNodesFamily->SetType(SMDSAbs_Node);
456     aNodesFamily->AddGroupName(submeshGrpName);
457     aFamilies.push_back(aNodesFamily);
458   }
459   if (!anEdgesFamily->IsEmpty()) {
460     anEdgesFamily->SetType(SMDSAbs_Edge);
461     anEdgesFamily->AddGroupName(submeshGrpName);
462     aFamilies.push_back(anEdgesFamily);
463   }
464   if (!aFacesFamily->IsEmpty()) {
465     aFacesFamily->SetType(SMDSAbs_Face);
466     aFacesFamily->AddGroupName(submeshGrpName);
467     aFamilies.push_back(aFacesFamily);
468   }
469   if (!aVolumesFamily->IsEmpty()) {
470     aVolumesFamily->SetType(SMDSAbs_Volume);
471     aVolumesFamily->AddGroupName(submeshGrpName);
472     aFamilies.push_back(aVolumesFamily);
473   }
474
475   return aFamilies;
476 }
477
478 //=============================================================================
479 /*!
480  *  Remove from <myElements> elements, common with <by>,
481  *  Remove from <by> elements, common with <myElements>,
482  *  Create family <common> from common elements, with combined groups list.
483  */
484 //=============================================================================
485 void DriverMED_Family::Split (DriverMED_FamilyPtr by,
486                               DriverMED_FamilyPtr common)
487 {
488   // Elements
489   ElementsSet::iterator anIter = by->myElements.begin();
490   while ( anIter != by->myElements.end())
491   {
492     if (myElements.find(*anIter) != myElements.end())
493     {
494       common->myElements.insert(*anIter);
495       myElements.erase(*anIter);
496       by->myElements.erase(anIter++);
497     }
498     else
499       anIter++;
500   }
501
502   if (!common->IsEmpty())
503   {
504     // Groups list
505     common->myGroupNames = myGroupNames;
506     MED::TStringSet::iterator aGrNamesIter = by->myGroupNames.begin();
507     for (; aGrNamesIter != by->myGroupNames.end(); aGrNamesIter++)
508     {
509       common->myGroupNames.insert(*aGrNamesIter);
510     }
511
512     // Type
513     common->myType = myType;
514   }
515 }