1 // HOMARD HOMARD : implementation of HOMARD idl descriptions
3 // Copyright (C) 2011-2023 CEA, EDF
5 // This library is free software; you can redistribute it and/or
6 // modify it under the terms of the GNU Lesser General Public
7 // License as published by the Free Software Foundation; either
8 // version 2.1 of the License, or (at your option) any later version.
10 // This library is distributed in the hope that it will be useful,
11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 // Lesser General Public License for more details.
15 // You should have received a copy of the GNU Lesser General Public
16 // License along with this library; if not, write to the Free Software
17 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
21 // File : HOMARD_Hypothesis.cxx
22 // Author : Gerald NICOLAS, EDF
26 // L'ordre de description des fonctions est le meme dans tous les fichiers
27 // HOMARD_aaaa.idl, HOMARD_aaaa.hxx, HOMARD_aaaa.cxx, HOMARD_aaaa_i.hxx, HOMARD_aaaa_i.cxx :
28 // 1. Les generalites : Name, Delete, DumpPython, Dump, Restore
29 // 2. Les caracteristiques
30 // 3. Le lien avec les autres structures
32 // Quand les 2 fonctions Setxxx et Getxxx sont presentes, Setxxx est decrit en premier
34 #include "HOMARD_Hypothesis.hxx"
36 #include "utilities.h"
38 //=============================================================================
40 * default constructor:
42 //=============================================================================
43 HOMARD_Hypothesis::HOMARD_Hypothesis():
44 _Name(""), _NomCasCreation(""),
45 _TypeAdap(-1), _TypeRaff(0), _TypeDera(0),
47 _TypeThR(0), _ThreshR(0),
48 _TypeThC(0), _ThreshC(0),
49 _UsField(0), _UsCmpI(0), _TypeFieldInterp(0)
51 MESSAGE("HOMARD_Hypothesis");
54 //=============================================================================
57 //=============================================================================
58 HOMARD_Hypothesis::~HOMARD_Hypothesis()
60 MESSAGE("~HOMARD_Hypothesis");
62 //=============================================================================
63 //=============================================================================
65 //=============================================================================
66 //=============================================================================
67 void HOMARD_Hypothesis::SetName( const char* Name )
69 _Name = std::string( Name );
71 //=============================================================================
72 std::string HOMARD_Hypothesis::GetName() const
76 //=============================================================================
77 std::string HOMARD_Hypothesis::GetDumpPython() const
79 std::ostringstream aScript;
80 aScript << "\n# Creation of the hypothesis " << _Name << "\n" ;
81 aScript << "\t" << _Name << " = homard.CreateHypothesis(\"" << _Name << "\")\n";
82 if ( _TypeAdap == -1 )
85 if ( _TypeRaff == 1 ) { TypeRaffDera = 1 ; }
86 else { TypeRaffDera = -1 ; }
87 aScript << "\t" << _Name << ".SetUnifRefinUnRef(" << TypeRaffDera << ")\n";
90 // Raffinement selon des zones geometriques
91 std::list<std::string>::const_iterator it = _ListZone.begin();
93 while(it != _ListZone.end())
95 aScript << "\t" << _Name << ".AddZone(\"" << *it;
97 if ( *it == "1" ) { TypeUse = 1 ; }
98 else { TypeUse = -1 ; }
99 aScript << "\", " << TypeUse << ")\n";
103 // Raffinement selon un champ
104 if ( _TypeAdap == 1 )
106 aScript << "\t" << _Name << ".SetField(\"" << _Field << "\")\n";
107 aScript << "\t" << _Name << ".SetUseField(" << _UsField << ")\n";
108 aScript << "\t" << _Name << ".SetUseComp(" << _UsCmpI << ")\n";
109 std::list<std::string>::const_iterator it_comp = _ListComp.begin();
110 while(it_comp != _ListComp.end())
112 aScript << "\t" << _Name << ".AddComp(\"" << *it_comp << "\")\n";
115 if ( _TypeRaff == 1 )
117 aScript << "\t" << _Name << ".SetRefinThr(" << _TypeThR << ", " << _ThreshR << ")\n";
119 if ( _TypeDera == 1 )
121 aScript << "\t" << _Name << ".SetUnRefThr(" << _TypeThC << ", " << _ThreshC << ")\n";
125 // Filtrage du raffinement par des groupes
126 for ( it=_ListGroupSelected.begin(); it!=_ListGroupSelected.end();it++)
127 aScript << "\t" << _Name << ".AddGroup(\"" << (*it) << "\")\n" ;
129 // Interpolation des champs
130 if ( _TypeFieldInterp == 2 )
132 std::list<std::string>::const_iterator it_champ = _ListFieldInterp.begin();
133 while(it_champ != _ListFieldInterp.end())
135 aScript << "\t" << _Name << ".AddFieldInterpType( \"" << *it_champ << "\" " ;
137 aScript << ", " << *it_champ << ")\n";
141 else if ( _TypeFieldInterp != 0 )
143 aScript << "\t" << _Name << ".SetTypeFieldInterp(" << _TypeFieldInterp << ")\n";
147 aScript << "\t" <<_Name << ".SetNivMax(" << _NivMax << ")\n";
151 aScript << "\t" <<_Name << ".SetDiamMin(" << _DiamMin << ")\n";
153 if ( _AdapInit != 0 )
155 aScript << "\t" <<_Name << ".SetAdapInit(" << _AdapInit << ")\n";
157 if ( _ExtraOutput != 1 )
159 aScript << "\t" <<_Name << ".SetExtraOutput(" << _ExtraOutput << ")\n";
162 return aScript.str();
164 //=============================================================================
165 //=============================================================================
167 //=============================================================================
168 //=============================================================================
169 void HOMARD_Hypothesis::SetAdapType( int TypeAdap )
171 VERIFICATION( (TypeAdap>=-1) && (TypeAdap<=1) );
172 _TypeAdap = TypeAdap;
174 //=============================================================================
175 int HOMARD_Hypothesis::GetAdapType() const
179 //=============================================================================
180 void HOMARD_Hypothesis::SetRefinTypeDera( int TypeRaff, int TypeDera )
182 VERIFICATION( (TypeRaff>=-1) && (TypeRaff<=1) );
183 _TypeRaff = TypeRaff;
184 VERIFICATION( (TypeDera>=-1) && (TypeDera<=1) );
185 _TypeDera = TypeDera;
187 //=============================================================================
188 int HOMARD_Hypothesis::GetRefinType() const
192 //=============================================================================
193 int HOMARD_Hypothesis::GetUnRefType() const
197 //=============================================================================
198 void HOMARD_Hypothesis::SetField( const char* FieldName )
200 _Field = std::string( FieldName );
201 MESSAGE( "SetField : FieldName = " << FieldName );
203 //=============================================================================
204 std::string HOMARD_Hypothesis::GetFieldName() const
208 //=============================================================================
209 void HOMARD_Hypothesis::SetUseField( int UsField )
211 VERIFICATION( (UsField>=0) && (UsField<=1) );
214 //=============================================================================
215 int HOMARD_Hypothesis::GetUseField() const
219 //=============================================================================
220 void HOMARD_Hypothesis::SetUseComp( int UsCmpI )
222 MESSAGE ("SetUseComp pour UsCmpI = "<<UsCmpI) ;
223 VERIFICATION( (UsCmpI>=0) && (UsCmpI<=2) );
226 //=============================================================================
227 int HOMARD_Hypothesis::GetUseComp() const
231 //=============================================================================
232 void HOMARD_Hypothesis::AddComp( const char* NomComp )
234 // On commence par supprimer la composante au cas ou elle aurait deja ete inseree
235 // Cela peut se produire dans un schema YACS quand on repasse plusieurs fois par la
236 // definition de l'hypothese
237 SupprComp( NomComp ) ;
238 // Insertion veritable
239 _ListComp.push_back( std::string( NomComp ) );
241 //=============================================================================
242 void HOMARD_Hypothesis::SupprComp( const char* NomComp )
244 MESSAGE ("SupprComp pour "<<NomComp) ;
245 std::list<std::string>::iterator it = find( _ListComp.begin(), _ListComp.end(), NomComp );
246 if ( it != _ListComp.end() ) { it = _ListComp.erase( it ); }
248 //=============================================================================
249 void HOMARD_Hypothesis::SupprComps()
253 //=============================================================================
254 const std::list<std::string>& HOMARD_Hypothesis::GetComps() const
258 //=============================================================================
259 void HOMARD_Hypothesis::SetRefinThr( int TypeThR, double ThreshR )
261 MESSAGE( "SetRefinThr : TypeThR = " << TypeThR << ", ThreshR = " << ThreshR );
262 VERIFICATION( (TypeThR>=0) && (TypeThR<=4) );
266 //=============================================================================
267 int HOMARD_Hypothesis::GetRefinThrType() const
271 //=============================================================================
272 double HOMARD_Hypothesis::GetThreshR() const
276 //=============================================================================
277 void HOMARD_Hypothesis::SetUnRefThr( int TypeThC, double ThreshC )
279 VERIFICATION( (TypeThC>=0) && (TypeThC<=4) );
283 //=============================================================================
284 int HOMARD_Hypothesis::GetUnRefThrType() const
288 //=============================================================================
289 double HOMARD_Hypothesis::GetThreshC() const
293 //=============================================================================
294 void HOMARD_Hypothesis::SetNivMax( int NivMax )
295 //=============================================================================
299 //=============================================================================
300 const int HOMARD_Hypothesis::GetNivMax() const
301 //=============================================================================
305 //=============================================================================
306 void HOMARD_Hypothesis::SetDiamMin( double DiamMin )
307 //=============================================================================
311 //=============================================================================
312 const double HOMARD_Hypothesis::GetDiamMin() const
313 //=============================================================================
317 //=============================================================================
318 void HOMARD_Hypothesis::SetAdapInit( int AdapInit )
319 //=============================================================================
321 _AdapInit = AdapInit;
323 //=============================================================================
324 const int HOMARD_Hypothesis::GetAdapInit() const
325 //=============================================================================
329 //=============================================================================
330 void HOMARD_Hypothesis::SetExtraOutput( int ExtraOutput )
331 //=============================================================================
333 _ExtraOutput = ExtraOutput;
335 //=============================================================================
336 const int HOMARD_Hypothesis::GetExtraOutput() const
337 //=============================================================================
341 //=============================================================================
342 void HOMARD_Hypothesis::AddGroup( const char* Group)
344 // On commence par supprimer le groupe au cas ou il aurait deja ete insere
345 // Cela peut se produire dans un schema YACS quand on repasse plusieurs fois par la
346 // definition de l'hypothese
347 SupprGroup( Group ) ;
348 // Insertion veritable
349 _ListGroupSelected.push_back(Group);
351 //=============================================================================
352 void HOMARD_Hypothesis::SupprGroup( const char* Group )
354 MESSAGE ("SupprGroup pour "<<Group) ;
355 std::list<std::string>::iterator it = find( _ListGroupSelected.begin(), _ListGroupSelected.end(), Group );
356 if ( it != _ListGroupSelected.end() ) { it = _ListGroupSelected.erase( it ); }
358 //=============================================================================
359 void HOMARD_Hypothesis::SupprGroups()
361 _ListGroupSelected.clear();
363 //=============================================================================
364 void HOMARD_Hypothesis::SetGroups( const std::list<std::string>& ListGroup )
366 _ListGroupSelected.clear();
367 std::list<std::string>::const_iterator it = ListGroup.begin();
368 while(it != ListGroup.end())
369 _ListGroupSelected.push_back((*it++));
371 //=============================================================================
372 const std::list<std::string>& HOMARD_Hypothesis::GetGroups() const
374 return _ListGroupSelected;
376 //=============================================================================
377 // Type d'interpolation des champs :
378 // 0 : aucun champ n'est interpole
379 // 1 : tous les champs sont interpoles
380 // 2 : certains champs sont interpoles
381 void HOMARD_Hypothesis::SetTypeFieldInterp( int TypeFieldInterp )
383 VERIFICATION( (TypeFieldInterp>=0) && (TypeFieldInterp<=2) );
384 _TypeFieldInterp = TypeFieldInterp;
386 //=============================================================================
387 int HOMARD_Hypothesis::GetTypeFieldInterp() const
389 return _TypeFieldInterp;
391 //=============================================================================
392 void HOMARD_Hypothesis::AddFieldInterpType( const char* FieldInterp, int TypeInterp )
394 MESSAGE ("Dans AddFieldInterpType pour " << FieldInterp << " et TypeInterp = " << TypeInterp) ;
395 // On commence par supprimer le champ au cas ou il aurait deja ete insere
396 // Cela peut se produire dans un schema YACS quand on repasse plusieurs fois par la
397 // definition de l'hypothese
398 SupprFieldInterp( FieldInterp ) ;
399 // Insertion veritable
401 _ListFieldInterp.push_back( std::string( FieldInterp ) );
403 std::stringstream saux1 ;
404 saux1 << TypeInterp ;
405 _ListFieldInterp.push_back( saux1.str() );
406 // . Indication generale : certains champs sont a interpoler
407 SetTypeFieldInterp ( 2 ) ;
409 //=============================================================================
410 void HOMARD_Hypothesis::SupprFieldInterp( const char* FieldInterp )
412 MESSAGE ("Dans SupprFieldInterp pour " << FieldInterp) ;
413 std::list<std::string>::iterator it = find( _ListFieldInterp.begin(), _ListFieldInterp.end(), FieldInterp ) ;
414 // Attention a supprimer le nom du champ et le type d'usage
415 if ( it != _ListFieldInterp.end() )
417 it = _ListFieldInterp.erase( it ) ;
418 it = _ListFieldInterp.erase( it ) ;
420 // Decompte du nombre de champs restant a interpoler
421 it = _ListFieldInterp.begin() ;
423 while(it != _ListFieldInterp.end())
428 MESSAGE("Nombre de champ restants = "<<cpt/2);
429 // . Indication generale : aucun champ ne reste a interpoler
432 SetTypeFieldInterp ( 0 ) ;
435 //=============================================================================
436 void HOMARD_Hypothesis::SupprFieldInterps()
438 MESSAGE ("SupprFieldInterps") ;
439 _ListFieldInterp.clear();
440 // . Indication generale : aucun champ ne reste a interpoler
441 SetTypeFieldInterp ( 0 ) ;
443 //=============================================================================
444 const std::list<std::string>& HOMARD_Hypothesis::GetFieldInterps() const
446 return _ListFieldInterp;
448 //=============================================================================
449 //=============================================================================
450 // Liens avec les autres structures
451 //=============================================================================
452 //=============================================================================
453 void HOMARD_Hypothesis::SetCaseCreation( const char* NomCasCreation )
455 _NomCasCreation = std::string( NomCasCreation );
457 //=============================================================================
458 std::string HOMARD_Hypothesis::GetCaseCreation() const
460 return _NomCasCreation;
462 //=============================================================================
463 void HOMARD_Hypothesis::LinkIteration( const char* NomIteration )
465 _ListIter.push_back( std::string( NomIteration ) );
467 //=============================================================================
468 void HOMARD_Hypothesis::UnLinkIteration( const char* NomIteration )
470 std::list<std::string>::iterator it = find( _ListIter.begin(), _ListIter.end(), NomIteration ) ;
471 if ( it != _ListIter.end() )
473 MESSAGE ("Dans UnLinkIteration pour " << NomIteration) ;
474 it = _ListIter.erase( it ) ;
477 //=============================================================================
478 void HOMARD_Hypothesis::UnLinkIterations()
482 //=============================================================================
483 const std::list<std::string>& HOMARD_Hypothesis::GetIterations() const
487 //=============================================================================
488 void HOMARD_Hypothesis::AddZone( const char* NomZone, int TypeUse )
490 MESSAGE ("Dans AddZone pour " << NomZone << " et TypeUse = " << TypeUse) ;
491 // On commence par supprimer la zone au cas ou elle aurait deja ete inseree
492 // Cela peut se produire dans un schema YACS quand on repasse plusieurs fois par la
493 // definition de l'hypothese
494 SupprZone( NomZone ) ;
495 // Insertion veritable
497 _ListZone.push_back( std::string( NomZone ) );
498 // . Usage de la zone
499 std::stringstream saux1 ;
501 _ListZone.push_back( saux1.str() );
503 //=============================================================================
504 void HOMARD_Hypothesis::SupprZone( const char* NomZone )
506 MESSAGE ("Dans SupprZone pour " << NomZone) ;
507 std::list<std::string>::iterator it = find( _ListZone.begin(), _ListZone.end(), NomZone );
508 // Attention a supprimer le nom de zone et le type d'usage
509 if ( it != _ListZone.end() )
511 it = _ListZone.erase( it );
512 it = _ListZone.erase( it );
515 //=============================================================================
516 void HOMARD_Hypothesis::SupprZones()
520 //=============================================================================
521 const std::list<std::string>& HOMARD_Hypothesis::GetZones() const