src/HOMARD/HOMARD_Hypothesis.cxx

   1 //  HOMARD HOMARD : implementaion of HOMARD idl descriptions
   2 //
   3 // Copyright (C) 2011-2012  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 #include "HOMARD_Hypothesis.hxx"
  26 #include "utilities.h"
  27
  28 //=============================================================================
  29 /*!
  30  *  default constructor:
  31  */
  32 //=============================================================================
  33 HOMARD_Hypothesis::HOMARD_Hypothesis():
  34   _NomHypo(""), _NomCasCreation(""),
  35   _TypeAdap(-1), _TypeRaff(0), _TypeDera(0),
  36   _Field(""),
  37   _TypeThR(0), _ThreshR(0),
  38   _TypeThC(0), _ThreshC(0),
  39   _UsField(0), _UsCmpI(0),  _TypeFieldInterp(0)
  40 {
  41   MESSAGE("HOMARD_Hypothesis");
  42 }
  43
  44 //=============================================================================
  45 /*!
  46  */
  47 //=============================================================================
  48 HOMARD_Hypothesis::~HOMARD_Hypothesis()
  49 {
  50   MESSAGE("~HOMARD_Hypothesis");
  51 }
  52
  53 //=============================================================================
  54 /*!
  55  */
  56 //=============================================================================
  57 void HOMARD_Hypothesis::SetCaseCreation( const char* NomCasCreation )
  58 {
  59   _NomCasCreation = std::string( NomCasCreation );
  60 }
  61
  62 //=============================================================================
  63 /*!
  64 */
  65 //=============================================================================
  66 std::string HOMARD_Hypothesis::GetCaseCreation() const
  67 {
  68   return _NomCasCreation;
  69 }
  70 //=============================================================================
  71 /*!
  72 */
  73 //=============================================================================
  74 void HOMARD_Hypothesis::SetName( const char* NomHypo )
  75 {
  76   _NomHypo = std::string( NomHypo );
  77 }
  78
  79 //=============================================================================
  80 /*!
  81 */
  82 //=============================================================================
  83 std::string HOMARD_Hypothesis::GetName() const
  84 {
  85   return _NomHypo;
  86 }
  87 //=============================================================================
  88 std::string HOMARD_Hypothesis::GetDumpPython() const
  89 {
  90   std::ostringstream aScript;
  91   aScript << "\n# Creation of the hypothesis " << _NomHypo << "\n" ;
  92   aScript << "\t" << _NomHypo << " = homard.CreateHypothesis(\"" << _NomHypo << "\")\n";
  93   aScript << "\t" << _NomHypo << ".SetAdapRefinUnRef(" << _TypeAdap << ", " << _TypeRaff << ", " << _TypeDera << ")\n";
  94
  95 // Raffinement selon des zones geometriques
  96   std::list<std::string>::const_iterator it = _ListZone.begin();
  97   int TypeUse ;
  98   while(it != _ListZone.end())
  99   {
 100       aScript << "\thomard.AssociateHypoZone(\""<< _NomHypo << "\", \"" << *it;
 101       it++;
 102       if ( *it == "1" ) { TypeUse =  1 ; }
 103       else              { TypeUse = -1 ; }
 104       aScript << "\", " << TypeUse << ")\n";
 105       it++;
 106   }
 107
 108 // Raffinement selon un champ
 109   if ( _TypeAdap == 1 )
 110   {
 111     aScript << "\t" << _NomHypo << ".SetField(\"" << _Field << "\")\n";
 112     aScript << "\t" << _NomHypo << ".SetUseField(" << _UsField << ")\n";
 113     aScript << "\t" << _NomHypo << ".SetUseComp(" << _UsCmpI << ")\n";
 114     std::list<std::string>::const_iterator it_comp = _ListComposant.begin();
 115     while(it_comp != _ListComposant.end())
 116     {
 117       aScript << "\t" << _NomHypo << ".AddComp(\"" << *it_comp << "\")\n";
 118       it_comp++;
 119     }
 120     if ( _TypeRaff == 1 )
 121     {
 122       aScript << "\t" << _NomHypo << ".SetRefinThr(" << _TypeThR;
 123       aScript << ", " << _ThreshR << ")\n";
 124     }
 125     if ( _TypeDera == 1 )
 126     {
 127       aScript << "\t" << _NomHypo << ".SetUnRefThr(" << _TypeThC;
 128       aScript << ", " << _ThreshC << ")\n";
 129     }
 130   }
 131
 132 // Filtrage du raffinement par des groupes
 133    for ( it=_ListGroupSelected.begin(); it!=_ListGroupSelected.end();it++)
 134        aScript << "\t" << _NomHypo << ".AddGroup(\""  << (*it) <<  "\")\n" ;
 135
 136 // Interpolation champ
 137   aScript << "\t" << _NomHypo << ".SetTypeFieldInterp(" << _TypeFieldInterp << ")\n";
 138   if ( _TypeFieldInterp == 2 )
 139   {
 140     std::list<std::string>::const_iterator it_champ = _ListFieldInterp.begin();
 141     while(it_champ != _ListFieldInterp.end())
 142     {
 143       aScript << "\t" << _NomHypo << ".AddFieldInterp(\"" << *it_champ << "\")\n";
 144       it_champ++;
 145     }
 146   }
 147   if ( _NivMax > 0 )
 148   {
 149     aScript << "\tNivMax = " << _NivMax << "\n";
 150     aScript << "\t" <<_NomHypo << ".SetNivMax(NivMax)\n";
 151   }
 152   if ( _DiamMin > 0 )
 153   {
 154     aScript << "\tDiamMin = " << _DiamMin << "\n";
 155     aScript << "\t" <<_NomHypo << ".SetDiamMin(DiamMin)\n";
 156   }
 157   if ( _AdapInit != 0 )
 158   {
 159     aScript << "\tAdapInit = " << _AdapInit << "\n";
 160     aScript << "\t" <<_NomHypo << ".SetAdapInit(AdapInit)\n";
 161   }
 162
 163   return aScript.str();
 164 }
 165
 166
 167 //=============================================================================
 168 /*!
 169 */
 170 //=============================================================================
 171 void HOMARD_Hypothesis::SetAdapType( int TypeAdap )
 172 {
 173   ASSERT (!((TypeAdap < -1) or (TypeAdap > 1)));
 174   _TypeAdap = TypeAdap;
 175 }
 176
 177 //=============================================================================
 178 /*!
 179 */
 180 //=============================================================================
 181 int HOMARD_Hypothesis::GetAdapType() const
 182 {
 183   return _TypeAdap;
 184 }
 185
 186 //=============================================================================
 187 /*!
 188 */
 189 //=============================================================================
 190 void HOMARD_Hypothesis::SetRefinTypeDera( int TypeRaff, int TypeDera )
 191 {
 192   ASSERT(!(( TypeRaff < 0) or (TypeRaff > 1)));
 193   _TypeRaff = TypeRaff;
 194   ASSERT(! ((TypeDera < 0) or (TypeDera > 1)));
 195   _TypeDera = TypeDera;
 196 }
 197
 198 //=============================================================================
 199 /*!
 200 */
 201 //=============================================================================
 202 int HOMARD_Hypothesis::GetRefinType() const
 203 {
 204   return _TypeRaff;
 205 }
 206
 207 //=============================================================================
 208 /*!
 209 */
 210 //=============================================================================
 211 int HOMARD_Hypothesis::GetUnRefType() const
 212 {
 213   return _TypeDera;
 214 }
 215
 216 //=============================================================================
 217 /*!
 218 */
 219 //=============================================================================
 220 void HOMARD_Hypothesis::SetField( const char* FieldName )
 221 {
 222   _Field = std::string( FieldName );
 223   MESSAGE( "SetField : FieldName = " << FieldName );
 224 }
 225 //=============================================================================
 226 void HOMARD_Hypothesis::SetRefinThr( int TypeThR, double ThreshR )
 227 {
 228   MESSAGE( "SetRefinThr : TypeThR = " << TypeThR << ", ThreshR = " << ThreshR );
 229   ASSERT(!(( TypeThR < 0) or (TypeThR > 3 )));
 230   _TypeThR = TypeThR;
 231   _ThreshR = ThreshR;
 232 }
 233 //=============================================================================
 234 void HOMARD_Hypothesis::SetUnRefThr( int TypeThC, double ThreshC )
 235 {
 236   ASSERT(!((TypeThC < 0) or (TypeThC > 3)));
 237   _TypeThC = TypeThC;
 238   _ThreshC = ThreshC;
 239 }
 240 //=============================================================================
 241 void HOMARD_Hypothesis::SetUseComp( int UsCmpI )
 242 {
 243   ASSERT(!((UsCmpI < 0) or (UsCmpI > 2)));
 244   _UsCmpI = UsCmpI;
 245 }
 246 //=============================================================================
 247 void HOMARD_Hypothesis::SetUseField( int UsField )
 248 {
 249   ASSERT(!((UsField < 0) or (UsField > 1 )));
 250   _UsField = UsField;
 251 }
 252
 253 //=============================================================================
 254 /*!
 255 */
 256 //=============================================================================
 257 std::string HOMARD_Hypothesis::GetFieldName() const
 258 {
 259   return _Field;
 260 }
 261 //=============================================================================
 262 int HOMARD_Hypothesis::GetRefinThrType() const
 263 {
 264   return _TypeThR;
 265 }
 266 //=============================================================================
 267 double HOMARD_Hypothesis::GetThreshR() const
 268 {
 269   return _ThreshR;
 270 }
 271 //=============================================================================
 272 int HOMARD_Hypothesis::GetUnRefThrType() const
 273 {
 274   return _TypeThC;
 275 }
 276
 277 //=============================================================================
 278 double HOMARD_Hypothesis::GetThreshC() const
 279 {
 280   return _ThreshC;
 281 }
 282 //=============================================================================
 283 int HOMARD_Hypothesis::GetUseField() const
 284 {
 285   return _UsField;
 286 }
 287 //=============================================================================
 288 int HOMARD_Hypothesis::GetUseCompI() const
 289 {
 290   return _UsCmpI;
 291 }
 292 //=============================================================================
 293 /*!
 294 */
 295 //=============================================================================
 296 void HOMARD_Hypothesis::AddIteration( const char* NomIteration )
 297 {
 298   _ListIter.push_back( std::string( NomIteration ) );
 299 }
 300 //=============================================================================
 301 void HOMARD_Hypothesis::SupprIterations()
 302 {
 303   _ListIter.clear();
 304 }
 305 //=============================================================================
 306 const std::list<std::string>& HOMARD_Hypothesis::GetIterations() const
 307 {
 308   return _ListIter;
 309 }
 310 //=============================================================================
 311 /*!
 312 */
 313 //=============================================================================
 314 void HOMARD_Hypothesis::AddZone( const char* NomZone, int TypeUse )
 315 {
 316   _ListZone.push_back( std::string( NomZone ) );
 317   std::stringstream saux1 ;
 318   saux1 << TypeUse ;
 319   std::string saux2 = saux1.str() ;
 320   _ListZone.push_back( saux2 );
 321 }
 322 //=============================================================================
 323 void HOMARD_Hypothesis::SupprZone( const char* NomZone )
 324 {
 325   std::list<std::string>::iterator it = find( _ListZone.begin(), _ListZone.end(), NomZone );
 326   if ( it != _ListZone.end() )
 327   {
 328     _ListZone.erase( it );
 329   }
 330 }
 331 //=============================================================================
 332 void HOMARD_Hypothesis::SupprZones()
 333 {
 334   _ListZone.clear();
 335 }
 336 //=============================================================================
 337 const std::list<std::string>& HOMARD_Hypothesis::GetZones() const
 338 {
 339   return _ListZone;
 340 }
 341 //=============================================================================
 342 /*!
 343 */
 344 //=============================================================================
 345 void HOMARD_Hypothesis::AddComp( const char* NomComposant )
 346 {
 347   _ListComposant.push_back( std::string( NomComposant ) );
 348 }
 349 //=============================================================================
 350 void HOMARD_Hypothesis::SupprComp()
 351 {
 352   std::cerr << "HOMARD_Hypothesis::SupprComp" << std::endl;
 353   _ListComposant.clear();
 354 }
 355 //=============================================================================
 356 const std::list<std::string>& HOMARD_Hypothesis::GetListComp() const
 357 {
 358   return _ListComposant;
 359 }
 360 //=============================================================================
 361 /*!
 362 */
 363 //=============================================================================
 364 const std::list<std::string>& HOMARD_Hypothesis::GetGroups() const
 365 {
 366   return _ListGroupSelected;
 367 }
 368 //=============================================================================
 369 void HOMARD_Hypothesis::SetGroups( const std::list<std::string>& ListGroup )
 370 {
 371   _ListGroupSelected.clear();
 372   std::list<std::string>::const_iterator it = ListGroup.begin();
 373   while(it != ListGroup.end())
 374     _ListGroupSelected.push_back((*it++));
 375 }
 376 //=============================================================================
 377 void HOMARD_Hypothesis::AddGroup( const char* Group)
 378 {
 379   _ListGroupSelected.push_back(Group);
 380 }
 381 //=============================================================================
 382 /*!
 383 */
 384 //=============================================================================
 385 void HOMARD_Hypothesis::SetTypeFieldInterp( int TypeFieldInterp )
 386 {
 387   ASSERT (!((TypeFieldInterp < -1) or (TypeFieldInterp > 2)));
 388   _TypeFieldInterp = TypeFieldInterp;
 389 }
 390
 391 //=============================================================================
 392 /*!
 393 */
 394 //=============================================================================
 395 int HOMARD_Hypothesis::GetTypeFieldInterp() const
 396 {
 397   return _TypeFieldInterp;
 398 }
 399 /*!
 400 */
 401 //=============================================================================
 402 void HOMARD_Hypothesis::AddFieldInterp( const char* FieldInterp )
 403 {
 404   _ListFieldInterp.push_back( std::string( FieldInterp ) );
 405 }
 406 //=============================================================================
 407 void HOMARD_Hypothesis::SupprFieldInterp()
 408 {
 409   std::cerr << "HOMARD_Hypothesis::SupprFieldInterpp" << std::endl;
 410   _ListFieldInterp.clear();
 411 }
 412 //=============================================================================
 413 const std::list<std::string>& HOMARD_Hypothesis::GetListFieldInterp() const
 414 {
 415   return _ListFieldInterp;
 416 }
 417 //=============================================================================
 418 void HOMARD_Hypothesis::SetNivMax( int NivMax )
 419 //=============================================================================
 420 {
 421   _NivMax = NivMax;
 422 }
 423 //=============================================================================
 424 const int HOMARD_Hypothesis::GetNivMax() const
 425 //=============================================================================
 426 {
 427   return _NivMax;
 428 }
 429 //=============================================================================
 430 void HOMARD_Hypothesis::SetAdapInit( int AdapInit )
 431 //=============================================================================
 432 {
 433   _AdapInit = AdapInit;
 434 }
 435 //=============================================================================
 436 const int HOMARD_Hypothesis::GetAdapInit() const
 437 //=============================================================================
 438 {
 439   return _AdapInit;
 440 }
 441 //=============================================================================
 442 void HOMARD_Hypothesis::SetDiamMin( double DiamMin )
 443 //=============================================================================
 444 {
 445   _DiamMin = DiamMin;
 446 }
 447 //=============================================================================
 448 const double HOMARD_Hypothesis::GetDiamMin() const
 449 //=============================================================================
 450 {
 451   return _DiamMin;
 452 }