src/HOMARD/HOMARD_Hypothesis.cxx

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