]> SALOME platform Git repositories - modules/hydro.git/blob - src/HYDROData/HYDROData_PriorityQueue.cxx
Salome HOME
Merge branch 'BR_H2018_2' of https://codev-tuleap.cea.fr/plugins/git/salome/hydro...
[modules/hydro.git] / src / HYDROData / HYDROData_PriorityQueue.cxx
1 // Copyright (C) 2014-2015  EDF-R&D
2 // This library is free software; you can redistribute it and/or
3 // modify it under the terms of the GNU Lesser General Public
4 // License as published by the Free Software Foundation; either
5 // version 2.1 of the License, or (at your option) any later version.
6 //
7 // This library is distributed in the hope that it will be useful,
8 // but WITHOUT ANY WARRANTY; without even the implied warranty of
9 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
10 // Lesser General Public License for more details.
11 //
12 // You should have received a copy of the GNU Lesser General Public
13 // License along with this library; if not, write to the Free Software
14 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
15 //
16 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
17 //
18
19 #include <HYDROData_PriorityQueue.h>
20 #include <HYDROData_CalculationCase.h>
21 #include <HYDROData_Iterator.h>
22 #include <TDataStd_ReferenceList.hxx>
23 #include <TDataStd_Integer.hxx>
24 #include <TDF_ChildIterator.hxx>
25
26 HYDROData_PriorityQueue::HYDROData_PriorityQueue( HYDROData_CalculationCase* theCalcCase,
27                                                   Standard_Integer aTag )
28 {
29   myObjects = theCalcCase->GetGeometryObjects();
30   for( int i=myObjects.Lower(), n=myObjects.Upper(); i<=n; i++ )
31   {
32     Handle(HYDROData_Entity) anObj = myObjects.Value( i );
33     if( !anObj.IsNull() )
34     {
35       QString anObjName = anObj->GetName();
36       myNames[anObjName] = anObj;
37     }
38   }
39
40   myRules = GetRules( theCalcCase->Label().FindChild( aTag ) );
41 }
42
43 HYDROData_PriorityQueue::~HYDROData_PriorityQueue()
44 {
45 }
46
47 Handle(HYDROData_Entity) HYDROData_PriorityQueue::GetMostPriorityObject( const QStringList& theZoneObjects,
48                                                                          HYDROData_Zone::MergeType& theMergeType ) const
49 {
50   QStringList aSortedZoneObjects;
51   for( int i=myObjects.Lower(), n=myObjects.Upper(); i<=n; i++ )
52   {
53     QString aName = myObjects.Value( i )->GetName();
54     if( theZoneObjects.contains( aName ) )
55       aSortedZoneObjects.append( aName );
56   }
57
58   Handle(HYDROData_Entity) aMostPriorityObj;
59   theMergeType = HYDROData_Zone::Merge_UNKNOWN;
60   QStringList::const_iterator anIt = aSortedZoneObjects.begin(), aLast = aSortedZoneObjects.end();
61   for( ; anIt!=aLast; anIt++ )
62   {
63     HYDROData_Zone::MergeType aLocalMerge = HYDROData_Zone::Merge_UNKNOWN;
64     Handle(HYDROData_Entity) anObj = myNames[*anIt];
65     if( !anObj.IsNull() )
66     {
67       if( aMostPriorityObj.IsNull() )
68       {
69         aMostPriorityObj = anObj;
70         continue;
71       }
72
73       bool isMorePriority = IsMorePriority( anObj, aMostPriorityObj, aLocalMerge );
74
75       if( isMorePriority )
76         aMostPriorityObj = anObj;
77
78       if( aLocalMerge != HYDROData_Zone::Merge_UNKNOWN && 
79           ( theMergeType==HYDROData_Zone::Merge_UNKNOWN || isMorePriority ) )
80         theMergeType = aLocalMerge;
81     }
82   }
83   return aMostPriorityObj;
84 }
85
86 bool HYDROData_PriorityQueue::IsMorePriority( const Handle(HYDROData_Entity)& theObj1,
87                                               const Handle(HYDROData_Entity)& theObj2,
88                                               HYDROData_Zone::MergeType& theMergeType ) const
89 {
90   // 1. First we check custom rules
91   HYDROData_ListOfRules::const_iterator anIt = myRules.begin(), aLast = myRules.end();
92   for( ; anIt!=aLast; anIt++ )
93   {
94     if( anIt->Object1->Label()==theObj1->Label() && anIt->Object2->Label()==theObj2->Label() )
95     {
96       theMergeType = anIt->MergeType;
97       return anIt->Priority==GREATER;
98     }
99     if( anIt->Object1->Label()==theObj2->Label() && anIt->Object2->Label()==theObj1->Label() )
100     {
101       theMergeType = anIt->MergeType;
102       return anIt->Priority==LESS;
103     }
104   }
105
106   // 2. If no custom rule found, the standard ordering list is applied
107   for( int i=myObjects.Lower(), n=myObjects.Upper(); i<=n; i++ )
108   {
109     if( myObjects.Value( i )->Label() == theObj1->Label() )
110     {
111       theMergeType = HYDROData_Zone::Merge_Object;
112       return true;
113     }
114     if( myObjects.Value( i )->Label() == theObj2->Label() )
115     {
116       theMergeType = HYDROData_Zone::Merge_Object;
117       return false;
118     }
119   }
120   return false;
121 }
122
123 void HYDROData_PriorityQueue::ClearRules( TDF_Label& theRulesLabel )
124 {
125   theRulesLabel.ForgetAllAttributes( true );
126 }
127
128 enum HYDROData_PriorityQueueTag
129 {
130   Object1_Tag,
131   Priority_Tag,
132   Object2_Tag,
133   Merge_Tag,
134 };
135
136 void HYDROData_PriorityQueue::AddRule( TDF_Label&                      theRulesLabel,
137                                        const Handle(HYDROData_Entity)& theObject1,
138                                        HYDROData_PriorityType          thePriority,
139                                        const Handle(HYDROData_Entity)& theObject2,
140                                        HYDROData_Zone::MergeType       theMergeType )
141 {
142   // Get the last rule index
143   Standard_Integer aRuleIndex = 0;
144   Handle(TDataStd_Integer) anIntVal;
145   if ( theRulesLabel.FindAttribute( TDataStd_Integer::GetID(), anIntVal ) ) {
146     aRuleIndex = anIntVal->Get();
147   }
148
149   TDF_Label aNewRuleLab = theRulesLabel.FindChild( aRuleIndex );
150
151   TDF_Label anObj1Lab = aNewRuleLab.FindChild( Object1_Tag );
152   Handle(TDataStd_ReferenceList) aRefs = TDataStd_ReferenceList::Set( anObj1Lab );
153   aRefs->SetID(TDataStd_ReferenceList::GetID());
154   aRefs->Append( theObject1->Label() );
155   
156   TDF_Label aPriorityLab = aNewRuleLab.FindChild( Priority_Tag );
157   Handle(TDataStd_Integer) anPLAttr = TDataStd_Integer::Set( aPriorityLab, thePriority );
158   anPLAttr->SetID(TDataStd_Integer::GetID());
159
160   TDF_Label anObj2Lab = aNewRuleLab.FindChild( Object2_Tag );
161   aRefs = TDataStd_ReferenceList::Set( anObj2Lab );
162   aRefs->SetID(TDataStd_ReferenceList::GetID());
163   aRefs->Append( theObject2->Label() );
164
165   TDF_Label aMergeLab = aNewRuleLab.FindChild( Merge_Tag );
166   Handle(TDataStd_Integer) anMLAttr = TDataStd_Integer::Set( aMergeLab, theMergeType );
167   anMLAttr->SetID(TDataStd_Integer::GetID());
168
169   // Increment the last rule index
170   Handle(TDataStd_Integer) anRLAttr = TDataStd_Integer::Set( theRulesLabel, aRuleIndex + 1 );
171   anRLAttr->SetID(TDataStd_Integer::GetID());
172 }
173
174 HYDROData_ListOfRules HYDROData_PriorityQueue::GetRules( const TDF_Label& theRulesLabel )
175 {
176   HYDROData_ListOfRules aRules;
177
178   Handle(TDataStd_ReferenceList) aRefs1, aRefs2;
179   Handle(TDataStd_Integer) aPriorityAttr, aMergeAttr;
180
181   TDF_ChildIterator anIt( theRulesLabel );
182   for( ; anIt.More(); anIt.Next() )
183   {
184     TDF_Label aRuleLabel = anIt.Value();
185
186     bool isObj1OK = aRuleLabel.FindChild    ( Object1_Tag ). FindAttribute( TDataStd_ReferenceList::GetID(), aRefs1 );
187     bool isPriorityOK = aRuleLabel.FindChild( Priority_Tag ).FindAttribute( TDataStd_Integer::GetID(),       aPriorityAttr );
188     bool isObj2OK = aRuleLabel.FindChild    ( Object2_Tag ). FindAttribute( TDataStd_ReferenceList::GetID(), aRefs2 );
189     bool isMergeOK = aRuleLabel.FindChild   ( Merge_Tag ).   FindAttribute( TDataStd_Integer::GetID(),       aMergeAttr );
190
191     if( isObj1OK && isPriorityOK && isObj2OK && isMergeOK )
192     {
193       HYDROData_CustomRule aRule;
194       aRule.Object1 = HYDROData_Iterator::Object( aRefs1->First() );
195       aRule.Priority = ( HYDROData_PriorityType ) aPriorityAttr->Get();
196       aRule.Object2 = HYDROData_Iterator::Object( aRefs2->First() );
197       aRule.MergeType = ( HYDROData_Zone::MergeType ) aMergeAttr->Get();
198       aRules.append( aRule );
199     }
200   }
201
202   return aRules;
203 }
204
205 QString HYDROData_PriorityQueue::DumpRules( const TDF_Label& theRulesLab )
206 {
207   QString aDump = "Rules:\n";
208
209   HYDROData_ListOfRules aRules = GetRules( theRulesLab );
210   HYDROData_ListOfRules::const_iterator anIt = aRules.begin(), aLast = aRules.end();
211   for( ; anIt!=aLast; anIt++ )
212   {
213     QString aRule = anIt->Object1->GetName() + " ";
214     aRule += ( anIt->Priority == LESS ? "<" : ">" ) + QString( " " );
215     aRule += anIt->Object2->GetName() + " ";
216
217     switch( anIt->MergeType )
218     {
219     case HYDROData_Zone::Merge_UNKNOWN:
220       aRule += "unknown";
221       break;
222     case HYDROData_Zone::Merge_ZMIN:
223       aRule += "zmin";
224       break;
225     case HYDROData_Zone::Merge_ZMAX:
226       aRule += "zmax";
227       break;
228     case HYDROData_Zone::Merge_Object:
229       aRule += "object";
230       break;
231     }
232     aDump += aRule + "\n";
233   }
234   return aDump;
235 }
236
237 void HYDROData_PriorityQueue::DumpRulesToPython( const TDF_Label& theRulesLab,
238                                                  const QString& theCalcCaseName,
239                                                  QStringList& theScript )
240 {
241   HYDROData_ListOfRules aRules = GetRules( theRulesLab );
242   HYDROData_ListOfRules::const_iterator anIt = aRules.begin(), aLast = aRules.end();
243   for( ; anIt!=aLast; anIt++ )
244   {
245     QString anObj1 = anIt->Object1->GetObjPyName();
246     QString anObj2 = anIt->Object2->GetObjPyName();
247     QString aPriority = anIt->Priority == LESS ? "LESS" : "GREATER";
248     QString aMergeType;
249
250     HYDROData_CalculationCase::DataTag aDataTag = HYDROData_CalculationCase::DataTag_CustomRules;
251
252     switch( anIt->MergeType )
253     {
254     case HYDROData_Zone::Merge_UNKNOWN:
255       aMergeType = "HYDROData_Zone.Merge_UNKNOWN";
256       break;
257     case HYDROData_Zone::Merge_ZMIN:
258       aMergeType = "HYDROData_Zone.Merge_ZMIN";
259       break;
260     case HYDROData_Zone::Merge_ZMAX:
261       aMergeType = "HYDROData_Zone.Merge_ZMAX";
262       break;
263     case HYDROData_Zone::Merge_Object:
264       aMergeType = "HYDROData_Zone.Merge_Object";
265       break;
266     }
267
268     QString aRule = QString( "%0.AddRule( %1, %2, %3, %4, %5 )" ).
269       arg( theCalcCaseName ).arg( anObj1 ).arg( aPriority ).arg( anObj2 ).arg( aMergeType ).arg( aDataTag );
270
271     theScript << aRule;
272   }
273 }
274
275 bool HYDROData_PriorityQueue::GetRule( const TDF_Label& theRulesLab,
276                                        int theIndex, 
277                                        Handle(HYDROData_Entity)&  theObject1,
278                                        HYDROData_PriorityType&    thePriority,
279                                        Handle(HYDROData_Entity)&  theObject2,
280                                        HYDROData_Zone::MergeType& theMergeType )
281 {
282   TDF_Label aRuleLabel = theRulesLab.FindChild( theIndex );
283
284   Handle(TDataStd_ReferenceList) aRefs1, aRefs2;
285   Handle(TDataStd_Integer) aPriorityAttr, aMergeAttr;
286
287   bool isObj1OK = aRuleLabel.FindChild    ( Object1_Tag ). FindAttribute( TDataStd_ReferenceList::GetID(), aRefs1 );
288   bool isPriorityOK = aRuleLabel.FindChild( Priority_Tag ).FindAttribute( TDataStd_Integer::GetID(),       aPriorityAttr );
289   bool isObj2OK = aRuleLabel.FindChild    ( Object2_Tag ). FindAttribute( TDataStd_ReferenceList::GetID(), aRefs2 );
290   bool isMergeOK = aRuleLabel.FindChild   ( Merge_Tag ).   FindAttribute( TDataStd_Integer::GetID(),       aMergeAttr );
291
292   bool isOK = isObj1OK && isPriorityOK && isObj2OK && isMergeOK;
293   if( isOK )
294   {
295     theObject1   = HYDROData_Iterator::Object( aRefs1->First() );
296     thePriority  = ( HYDROData_PriorityType ) aPriorityAttr->Get();
297     theObject2   = HYDROData_Iterator::Object( aRefs2->First() );
298     theMergeType = ( HYDROData_Zone::MergeType ) aMergeAttr->Get();
299   }
300   return isOK;
301 }