src/HOMARD/HOMARD_Hypothesis.cxx

   1 //  HOMARD HOMARD : implementation of HOMARD idl descriptions
   2 //
   3 // Copyright (C) 2011-2013  CEA/DEN, EDF R&D
   4 //
   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.
   9 //
  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.
  14 //
  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
  18 //
  19 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  20 //
  21 //  File   : HOMARD_Hypothesis.cxx
  22 //  Author : Paul RASCLE, EDF
  23 //  Module : HOMARD
  24 //
  25 // Remarques :
  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
  31 //
  32 // Quand les 2 fonctions Setxxx et Getxxx sont presentes, Setxxx est decrit en premier
  33
  34 #include "HOMARD_Hypothesis.hxx"
  35 #include "HOMARD.hxx"
  36 #include "utilities.h"
  37
  38 //=============================================================================
  39 /*!
  40  *  default constructor:
  41  */
  42 //=============================================================================
  43 HOMARD_Hypothesis::HOMARD_Hypothesis():
  44   _Name(""), _NomCasCreation(""),
  45   _TypeAdap(-1), _TypeRaff(0), _TypeDera(0),
  46   _Field(""),
  47   _TypeThR(0), _ThreshR(0),
  48   _TypeThC(0), _ThreshC(0),
  49   _UsField(0), _UsCmpI(0),  _TypeFieldInterp(0)
  50 {
  51   MESSAGE("HOMARD_Hypothesis");
  52 }
  53
  54 //=============================================================================
  55 /*!
  56  */
  57 //=============================================================================
  58 HOMARD_Hypothesis::~HOMARD_Hypothesis()
  59 {
  60   MESSAGE("~HOMARD_Hypothesis");
  61 }
  62 //=============================================================================
  63 //=============================================================================
  64 // Generalites
  65 //=============================================================================
  66 //=============================================================================
  67 void HOMARD_Hypothesis::SetName( const char* Name )
  68 {
  69   _Name = std::string( Name );
  70 }
  71 //=============================================================================
  72 std::string HOMARD_Hypothesis::GetName() const
  73 {
  74   return _Name;
  75 }
  76 //=============================================================================
  77 std::string HOMARD_Hypothesis::GetDumpPython() const
  78 {
  79   std::ostringstream aScript;
  80   aScript << "\n# Creation of the hypothesis " << _Name << "\n" ;
  81   aScript << "\t" << _Name << " = homard.CreateHypothesis(\"" << _Name << "\")\n";
  82   aScript << "\t" << _Name << ".SetAdapRefinUnRef(" << _TypeAdap << ", " << _TypeRaff << ", " << _TypeDera << ")\n";
  83
  84 // Raffinement selon des zones geometriques
  85   std::list<std::string>::const_iterator it = _ListZone.begin();
  86   int TypeUse ;
  87   while(it != _ListZone.end())
  88   {
  89       aScript << "\t" << _Name << ".AddZone(\"" << *it;
  90       it++;
  91       if ( *it == "1" ) { TypeUse =  1 ; }
  92       else              { TypeUse = -1 ; }
  93       aScript << "\", " << TypeUse << ")\n";
  94       it++;
  95   }
  96
  97 // Raffinement selon un champ
  98   if ( _TypeAdap == 1 )
  99   {
 100     aScript << "\t" << _Name << ".SetField(\"" << _Field << "\")\n";
 101     aScript << "\t" << _Name << ".SetUseField(" << _UsField << ")\n";
 102     aScript << "\t" << _Name << ".SetUseComp(" << _UsCmpI << ")\n";
 103     std::list<std::string>::const_iterator it_comp = _ListComp.begin();
 104     while(it_comp != _ListComp.end())
 105     {
 106       aScript << "\t" << _Name << ".AddComp(\"" << *it_comp << "\")\n";
 107       it_comp++;
 108     }
 109     if ( _TypeRaff == 1 )
 110     {
 111       aScript << "\t" << _Name << ".SetRefinThr(" << _TypeThR << ", " << _ThreshR << ")\n";
 112     }
 113     if ( _TypeDera == 1 )
 114     {
 115       aScript << "\t" << _Name << ".SetUnRefThr(" << _TypeThC << ", " << _ThreshC << ")\n";
 116     }
 117   }
 118
 119 // Filtrage du raffinement par des groupes
 120    for ( it=_ListGroupSelected.begin(); it!=_ListGroupSelected.end();it++)
 121        aScript << "\t" << _Name << ".AddGroup(\""  << (*it) <<  "\")\n" ;
 122
 123 // Interpolation des champs
 124   if ( _TypeFieldInterp == 2 )
 125   {
 126     std::list<std::string>::const_iterator it_champ = _ListFieldInterp.begin();
 127     while(it_champ != _ListFieldInterp.end())
 128     {
 129       aScript << "\t" << _Name << ".AddFieldInterpType( \"" << *it_champ  <<  "\" " ;
 130       it_champ++;
 131       aScript << ", " << *it_champ << ")\n";
 132       it_champ++;
 133     }
 134   }
 135   else if ( _TypeFieldInterp != 0 )
 136   {
 137     aScript << "\t" << _Name << ".SetTypeFieldInterp(" << _TypeFieldInterp << ")\n";
 138   }
 139   if ( _NivMax > 0 )
 140   {
 141     aScript << "\t" <<_Name << ".SetNivMax(" << _NivMax << ")\n";
 142   }
 143   if ( _DiamMin > 0 )
 144   {
 145     aScript << "\t" <<_Name << ".SetDiamMin(" << _DiamMin << ")\n";
 146   }
 147   if ( _AdapInit != 0 )
 148   {
 149     aScript << "\t" <<_Name << ".SetAdapInit(" << _AdapInit << ")\n";
 150   }
 151   if ( _LevelOutput != 0 )
 152   {
 153     aScript << "\t" <<_Name << ".SetLevelOutput(" << _LevelOutput << ")\n";
 154   }
 155
 156   return aScript.str();
 157 }
 158 //=============================================================================
 159 //=============================================================================
 160 // Caracteristiques
 161 //=============================================================================
 162 //=============================================================================
 163 void HOMARD_Hypothesis::SetAdapType( int TypeAdap )
 164 {
 165   VERIFICATION( (TypeAdap>=-1) && (TypeAdap<=1) );
 166   _TypeAdap = TypeAdap;
 167 }
 168 //=============================================================================
 169 int HOMARD_Hypothesis::GetAdapType() const
 170 {
 171   return _TypeAdap;
 172 }
 173 //=============================================================================
 174 void HOMARD_Hypothesis::SetRefinTypeDera( int TypeRaff, int TypeDera )
 175 {
 176   VERIFICATION( (TypeRaff>=-1) && (TypeRaff<=1) );
 177   _TypeRaff = TypeRaff;
 178   VERIFICATION( (TypeDera>=-1) && (TypeDera<=1) );
 179   _TypeDera = TypeDera;
 180 }
 181 //=============================================================================
 182 int HOMARD_Hypothesis::GetRefinType() const
 183 {
 184   return _TypeRaff;
 185 }
 186 //=============================================================================
 187 int HOMARD_Hypothesis::GetUnRefType() const
 188 {
 189   return _TypeDera;
 190 }
 191 //=============================================================================
 192 void HOMARD_Hypothesis::SetField( const char* FieldName )
 193 {
 194   _Field = std::string( FieldName );
 195   MESSAGE( "SetField : FieldName = " << FieldName );
 196 }
 197 //=============================================================================
 198 std::string HOMARD_Hypothesis::GetFieldName() const
 199 {
 200   return _Field;
 201 }
 202 //=============================================================================
 203 void HOMARD_Hypothesis::SetUseField( int UsField )
 204 {
 205   VERIFICATION( (UsField>=0) && (UsField<=1) );
 206   _UsField = UsField;
 207 }
 208 //=============================================================================
 209 int HOMARD_Hypothesis::GetUseField() const
 210 {
 211   return _UsField;
 212 }
 213 //=============================================================================
 214 void HOMARD_Hypothesis::SetUseComp( int UsCmpI )
 215 {
 216   VERIFICATION( (UsCmpI>=0) && (UsCmpI<=2) );
 217   _UsCmpI = UsCmpI;
 218 }
 219 //=============================================================================
 220 int HOMARD_Hypothesis::GetUseComp() const
 221 {
 222   return _UsCmpI;
 223 }
 224 //=============================================================================
 225 void HOMARD_Hypothesis::AddComp( const char* NomComp )
 226 {
 227 // On commence par la supprimer au cas ou elle aurait deja ete inseree
 228 // Cela peut se produire dans un schema YACS quand on repasse plusieurs fois par la
 229 // definition de l'hypothese
 230   SupprComp( NomComp ) ;
 231 // Insertion veritable
 232   _ListComp.push_back( std::string( NomComp ) );
 233 }
 234 //=============================================================================
 235 void HOMARD_Hypothesis::SupprComp( const char* NomComp )
 236 {
 237   MESSAGE ("SupprComp pour "<<NomComp) ;
 238   std::list<std::string>::iterator it = find( _ListComp.begin(), _ListComp.end(), NomComp );
 239   if ( it != _ListComp.end() ) { it = _ListComp.erase( it ); }
 240 }
 241 //=============================================================================
 242 void HOMARD_Hypothesis::SupprComps()
 243 {
 244   _ListComp.clear();
 245 }
 246 //=============================================================================
 247 const std::list<std::string>& HOMARD_Hypothesis::GetComps() const
 248 {
 249   return _ListComp;
 250 }
 251 //=============================================================================
 252 void HOMARD_Hypothesis::SetRefinThr( int TypeThR, double ThreshR )
 253 {
 254   MESSAGE( "SetRefinThr : TypeThR = " << TypeThR << ", ThreshR = " << ThreshR );
 255   VERIFICATION( (TypeThR>=0) && (TypeThR<=4) );
 256   _TypeThR = TypeThR;
 257   _ThreshR = ThreshR;
 258 }
 259 //=============================================================================
 260 int HOMARD_Hypothesis::GetRefinThrType() const
 261 {
 262   return _TypeThR;
 263 }
 264 //=============================================================================
 265 double HOMARD_Hypothesis::GetThreshR() const
 266 {
 267   return _ThreshR;
 268 }
 269 //=============================================================================
 270 void HOMARD_Hypothesis::SetUnRefThr( int TypeThC, double ThreshC )
 271 {
 272   VERIFICATION( (TypeThC>=0) && (TypeThC<=4) );
 273   _TypeThC = TypeThC;
 274   _ThreshC = ThreshC;
 275 }
 276 //=============================================================================
 277 int HOMARD_Hypothesis::GetUnRefThrType() const
 278 {
 279   return _TypeThC;
 280 }
 281 //=============================================================================
 282 double HOMARD_Hypothesis::GetThreshC() const
 283 {
 284   return _ThreshC;
 285 }
 286 //=============================================================================
 287 void HOMARD_Hypothesis::SetNivMax( int NivMax )
 288 //=============================================================================
 289 {
 290   _NivMax = NivMax;
 291 }
 292 //=============================================================================
 293 const int HOMARD_Hypothesis::GetNivMax() const
 294 //=============================================================================
 295 {
 296   return _NivMax;
 297 }
 298 //=============================================================================
 299 void HOMARD_Hypothesis::SetDiamMin( double DiamMin )
 300 //=============================================================================
 301 {
 302   _DiamMin = DiamMin;
 303 }
 304 //=============================================================================
 305 const double HOMARD_Hypothesis::GetDiamMin() const
 306 //=============================================================================
 307 {
 308   return _DiamMin;
 309 }
 310 //=============================================================================
 311 void HOMARD_Hypothesis::SetAdapInit( int AdapInit )
 312 //=============================================================================
 313 {
 314   _AdapInit = AdapInit;
 315 }
 316 //=============================================================================
 317 const int HOMARD_Hypothesis::GetAdapInit() const
 318 //=============================================================================
 319 {
 320   return _AdapInit;
 321 }
 322 //=============================================================================
 323 void HOMARD_Hypothesis::SetLevelOutput( int LevelOutput )
 324 //=============================================================================
 325 {
 326   _LevelOutput = LevelOutput;
 327 }
 328 //=============================================================================
 329 const int HOMARD_Hypothesis::GetLevelOutput() const
 330 //=============================================================================
 331 {
 332   return _LevelOutput;
 333 }
 334 //=============================================================================
 335 void HOMARD_Hypothesis::AddGroup( const char* Group)
 336 {
 337   _ListGroupSelected.push_back(Group);
 338 }
 339 //=============================================================================
 340 void HOMARD_Hypothesis::SetGroups( const std::list<std::string>& ListGroup )
 341 {
 342   _ListGroupSelected.clear();
 343   std::list<std::string>::const_iterator it = ListGroup.begin();
 344   while(it != ListGroup.end())
 345     _ListGroupSelected.push_back((*it++));
 346 }
 347 //=============================================================================
 348 const std::list<std::string>& HOMARD_Hypothesis::GetGroups() const
 349 {
 350   return _ListGroupSelected;
 351 }
 352 //=============================================================================
 353 // Type d'interpolation des champs :
 354 //   0 : aucun champ n'est interpole
 355 //   1 : tous les champs sont interpoles
 356 //   2 : certains champs sont interpoles
 357 void HOMARD_Hypothesis::SetTypeFieldInterp( int TypeFieldInterp )
 358 {
 359   VERIFICATION( (TypeFieldInterp>=0) && (TypeFieldInterp<=2) );
 360   _TypeFieldInterp = TypeFieldInterp;
 361 }
 362 //=============================================================================
 363 int HOMARD_Hypothesis::GetTypeFieldInterp() const
 364 {
 365   return _TypeFieldInterp;
 366 }
 367 //=============================================================================
 368 void HOMARD_Hypothesis::AddFieldInterpType( const char* FieldInterp, int TypeInterp )
 369 {
 370   MESSAGE ("Dans AddFieldInterpType pour " << FieldInterp << " et TypeInterp = " << TypeInterp) ;
 371 // On commence par supprimer le champ au cas ou il aurait deja ete insere
 372 // Cela peut se produire dans un schema YACS quand on repasse plusieurs fois par la
 373 // definition de l'hypothese
 374   SupprFieldInterp( FieldInterp ) ;
 375 // Insertion veritable
 376 // . Nom du champ
 377   _ListFieldInterp.push_back( std::string( FieldInterp ) );
 378 // . Usage du champ
 379   std::stringstream saux1 ;
 380   saux1 << TypeInterp ;
 381   _ListFieldInterp.push_back( saux1.str() );
 382 // . Indication generale : certains champs sont a interpoler
 383   SetTypeFieldInterp ( 2 ) ;
 384 }
 385 //=============================================================================
 386 void HOMARD_Hypothesis::SupprFieldInterp( const char* FieldInterp )
 387 {
 388   MESSAGE ("Dans SupprFieldInterp pour " << FieldInterp) ;
 389   std::list<std::string>::iterator it = find( _ListFieldInterp.begin(), _ListFieldInterp.end(), FieldInterp ) ;
 390 // Attention a supprimer le nom du champ et le type d'usage
 391   if ( it != _ListFieldInterp.end() )
 392   {
 393     it = _ListFieldInterp.erase( it ) ;
 394     it = _ListFieldInterp.erase( it ) ;
 395   }
 396 // Decompte du nombre de champs restant a interpoler
 397   it = _ListFieldInterp.begin() ;
 398   int cpt = 0 ;
 399   while(it != _ListFieldInterp.end())
 400   {
 401     cpt += 1 ;
 402     (*it++);
 403   }
 404   MESSAGE("Nombre de champ restants = "<<cpt/2);
 405 // . Indication generale : aucun champ ne reste a interpoler
 406   if ( cpt == 0 )
 407   {
 408     SetTypeFieldInterp ( 0 ) ;
 409   }
 410 }
 411 //=============================================================================
 412 void HOMARD_Hypothesis::SupprFieldInterps()
 413 {
 414   MESSAGE ("SupprFieldInterps") ;
 415   _ListFieldInterp.clear();
 416 // . Indication generale : aucun champ ne reste a interpoler
 417   SetTypeFieldInterp ( 0 ) ;
 418 }
 419 //=============================================================================
 420 const std::list<std::string>& HOMARD_Hypothesis::GetFieldInterps() const
 421 {
 422   return _ListFieldInterp;
 423 }
 424 //=============================================================================
 425 //=============================================================================
 426 // Liens avec les autres structures
 427 //=============================================================================
 428 //=============================================================================
 429 void HOMARD_Hypothesis::SetCaseCreation( const char* NomCasCreation )
 430 {
 431   _NomCasCreation = std::string( NomCasCreation );
 432 }
 433 //=============================================================================
 434 std::string HOMARD_Hypothesis::GetCaseCreation() const
 435 {
 436   return _NomCasCreation;
 437 }
 438 //=============================================================================
 439 void HOMARD_Hypothesis::LinkIteration( const char* NomIteration )
 440 {
 441   _ListIter.push_back( std::string( NomIteration ) );
 442 }
 443 //=============================================================================
 444 void HOMARD_Hypothesis::UnLinkIteration( const char* NomIteration )
 445 {
 446   std::list<std::string>::iterator it = find( _ListIter.begin(), _ListIter.end(), NomIteration ) ;
 447   if ( it != _ListIter.end() )
 448   {
 449     MESSAGE ("Dans UnLinkIteration pour " << NomIteration) ;
 450     it = _ListIter.erase( it ) ;
 451   }
 452 }
 453 //=============================================================================
 454 void HOMARD_Hypothesis::UnLinkIterations()
 455 {
 456   _ListIter.clear();
 457 }
 458 //=============================================================================
 459 const std::list<std::string>& HOMARD_Hypothesis::GetIterations() const
 460 {
 461   return _ListIter;
 462 }
 463 //=============================================================================
 464 void HOMARD_Hypothesis::AddZone( const char* NomZone, int TypeUse )
 465 {
 466   MESSAGE ("Dans AddZone pour " << NomZone << " et TypeUse = " << TypeUse) ;
 467 // On commence par supprimer la zone au cas ou elle aurait deja ete inseree
 468 // Cela peut se produire dans un schema YACS quand on repasse plusieurs fois par la
 469 // definition de l'hypothese
 470   SupprZone( NomZone ) ;
 471 // Insertion veritable
 472 // . Nom de la zone
 473   _ListZone.push_back( std::string( NomZone ) );
 474 // . Usage de la zone
 475   std::stringstream saux1 ;
 476   saux1 << TypeUse ;
 477   _ListZone.push_back( saux1.str() );
 478 }
 479 //=============================================================================
 480 void HOMARD_Hypothesis::SupprZone( const char* NomZone )
 481 {
 482   MESSAGE ("Dans SupprZone pour " << NomZone) ;
 483   std::list<std::string>::iterator it = find( _ListZone.begin(), _ListZone.end(), NomZone );
 484 // Attention a supprimer le nom de zone et le type d'usage
 485   if ( it != _ListZone.end() )
 486   {
 487     it = _ListZone.erase( it );
 488     it = _ListZone.erase( it );
 489   }
 490 }
 491 //=============================================================================
 492 void HOMARD_Hypothesis::SupprZones()
 493 {
 494   _ListZone.clear();
 495 }
 496 //=============================================================================
 497 const std::list<std::string>& HOMARD_Hypothesis::GetZones() const
 498 {
 499   return _ListZone;
 500 }