src/HOMARD/HOMARD_Hypothesis.cxx

   1 //  HOMARD HOMARD : implementaion of HOMARD idl descriptions
   2 //
   3 // Copyright (C) 2011  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   while(it != _ListZone.end())
  98   {
  99       aScript << "\thomard.AssociateHypoZone('"<< *it << "', '" <<_NomHypo << "')\n";
 100       it++;
 101   }
 102
 103 // Raffinement selon un champ
 104   if ( _TypeAdap == 1 )
 105   {
 106     aScript << "\t" << _NomHypo << ".SetField('" << _Field << "')\n";
 107     aScript << "\t" << _NomHypo << ".SetUseField(" << _UsField << ")\n";
 108     aScript << "\t" << _NomHypo << ".SetUseComp(" << _UsCmpI << ")\n";
 109     std::list<std::string>::const_iterator it_comp = _ListComposant.begin();
 110     while(it_comp != _ListComposant.end())
 111     {
 112       aScript << "\t" << _NomHypo << ".AddComp('" << *it_comp << "')\n";
 113       it_comp++;
 114     }
 115     if ( _TypeRaff == 1 )
 116     {
 117       aScript << "\t" << _NomHypo << ".SetRefinThr(" << _TypeThR;
 118       aScript << ", " << _ThreshR << ")\n";
 119     }
 120     if ( _TypeDera == 1 )
 121     {
 122       aScript << "\t" << _NomHypo << ".SetUnRefThr(" << _TypeThC;
 123       aScript << ", " << _ThreshC << ")\n";
 124     }
 125   }
 126
 127 // Filtrage du raffinement par des groupes
 128    for ( it=_ListGroupSelected.begin(); it!=_ListGroupSelected.end();it++)
 129        aScript << "\t" << _NomHypo << ".AddGroup('"  << (*it) <<  "')\n" ;
 130
 131 // Interpolation champ
 132   aScript << "\t" << _NomHypo << ".SetTypeFieldInterp(" << _TypeFieldInterp << ")\n";
 133   if ( _TypeFieldInterp == 2 )
 134   {
 135     std::list<std::string>::const_iterator it_champ = _ListFieldInterp.begin();
 136     while(it_champ != _ListFieldInterp.end())
 137     {
 138       aScript << "\t" << _NomHypo << ".AddFieldInterp('" << *it_champ << "')\n";
 139       it_champ++;
 140     }
 141   }
 142   if ( _NivMax > 0 )
 143   {
 144     aScript << "\t" <<_NomHypo << ".SetNivMax(";
 145     aScript << _NivMax << ")\n";
 146     aScript << "\t" <<_NomHypo << ".SetDiamMin(";
 147     aScript << _DiamMin << ")\n";
 148   }
 149
 150   return aScript.str();
 151 }
 152
 153
 154 //=============================================================================
 155 /*!
 156 */
 157 //=============================================================================
 158 void HOMARD_Hypothesis::SetAdapType( int TypeAdap )
 159 {
 160   ASSERT (!((TypeAdap < -1) or (TypeAdap > 1)));
 161   _TypeAdap = TypeAdap;
 162 }
 163
 164 //=============================================================================
 165 /*!
 166 */
 167 //=============================================================================
 168 int HOMARD_Hypothesis::GetAdapType() const
 169 {
 170   return _TypeAdap;
 171 }
 172
 173 //=============================================================================
 174 /*!
 175 */
 176 //=============================================================================
 177 void HOMARD_Hypothesis::SetRefinTypeDera( int TypeRaff, int TypeDera )
 178 {
 179   ASSERT(!(( TypeRaff < 0) or (TypeRaff > 1)));
 180   _TypeRaff = TypeRaff;
 181   ASSERT(! ((TypeDera < 0) or (TypeDera > 1)));
 182   _TypeDera = TypeDera;
 183 }
 184
 185 //=============================================================================
 186 /*!
 187 */
 188 //=============================================================================
 189 int HOMARD_Hypothesis::GetRefinType() const
 190 {
 191   return _TypeRaff;
 192 }
 193
 194 //=============================================================================
 195 /*!
 196 */
 197 //=============================================================================
 198 int HOMARD_Hypothesis::GetUnRefType() const
 199 {
 200   return _TypeDera;
 201 }
 202
 203 //=============================================================================
 204 /*!
 205 */
 206 //=============================================================================
 207 void HOMARD_Hypothesis::SetField( const char* FieldName )
 208 {
 209   _Field = std::string( FieldName );
 210   MESSAGE( "SetField : FieldName = " << FieldName );
 211 }
 212 //=============================================================================
 213 void HOMARD_Hypothesis::SetRefinThr( int TypeThR, double ThreshR )
 214 {
 215   MESSAGE( "SetRefinThr : TypeThR = " << TypeThR << ", ThreshR = " << ThreshR );
 216   ASSERT(!(( TypeThR < 0) or (TypeThR > 3 )));
 217   _TypeThR = TypeThR;
 218   _ThreshR = ThreshR;
 219 }
 220 //=============================================================================
 221 void HOMARD_Hypothesis::SetUnRefThr( int TypeThC, double ThreshC )
 222 {
 223   ASSERT(!((TypeThC < 0) or (TypeThC > 3)));
 224   _TypeThC = TypeThC;
 225   _ThreshC = ThreshC;
 226 }
 227 //=============================================================================
 228 void HOMARD_Hypothesis::SetUseComp( int UsCmpI )
 229 {
 230   ASSERT(!((UsCmpI < 0) or (UsCmpI > 2)));
 231   _UsCmpI = UsCmpI;
 232 }
 233 //=============================================================================
 234 void HOMARD_Hypothesis::SetUseField( int UsField )
 235 {
 236   ASSERT(!((UsField < 0) or (UsField > 1 )));
 237   _UsField = UsField;
 238 }
 239
 240 //=============================================================================
 241 /*!
 242 */
 243 //=============================================================================
 244 std::string HOMARD_Hypothesis::GetFieldName() const
 245 {
 246   return _Field;
 247 }
 248 //=============================================================================
 249 int HOMARD_Hypothesis::GetRefinThrType() const
 250 {
 251   return _TypeThR;
 252 }
 253 //=============================================================================
 254 double HOMARD_Hypothesis::GetThreshR() const
 255 {
 256   return _ThreshR;
 257 }
 258 //=============================================================================
 259 int HOMARD_Hypothesis::GetUnRefThrType() const
 260 {
 261   return _TypeThC;
 262 }
 263
 264 //=============================================================================
 265 double HOMARD_Hypothesis::GetThreshC() const
 266 {
 267   return _ThreshC;
 268 }
 269 //=============================================================================
 270 int HOMARD_Hypothesis::GetUseField() const
 271 {
 272   return _UsField;
 273 }
 274 //=============================================================================
 275 int HOMARD_Hypothesis::GetUseCompI() const
 276 {
 277   return _UsCmpI;
 278 }
 279 //=============================================================================
 280 /*!
 281 */
 282 //=============================================================================
 283 void HOMARD_Hypothesis::AddIteration( const char* NomIteration )
 284 {
 285   _ListIter.push_back( std::string( NomIteration ) );
 286 }
 287 //=============================================================================
 288 void HOMARD_Hypothesis::SupprIterations()
 289 {
 290   _ListIter.clear();
 291 }
 292 //=============================================================================
 293 const std::list<std::string>& HOMARD_Hypothesis::GetIterations() const
 294 {
 295   return _ListIter;
 296 }
 297 //=============================================================================
 298 /*!
 299 */
 300 //=============================================================================
 301 void HOMARD_Hypothesis::AddZone( const char* NomZone )
 302 {
 303   _ListZone.push_back( std::string( NomZone ) );
 304 }
 305 //=============================================================================
 306 void HOMARD_Hypothesis::SupprZone( const char* NomZone )
 307 {
 308   std::list<std::string>::iterator it = find( _ListZone.begin(), _ListZone.end(), NomZone );
 309   if ( it != _ListZone.end() )
 310   {
 311     _ListZone.erase( it );
 312   }
 313 }
 314 //=============================================================================
 315 void HOMARD_Hypothesis::SupprZones()
 316 {
 317   _ListZone.clear();
 318 }
 319 //=============================================================================
 320 const std::list<std::string>& HOMARD_Hypothesis::GetZones() const
 321 {
 322   return _ListZone;
 323 }
 324 //=============================================================================
 325 /*!
 326 */
 327 //=============================================================================
 328 void HOMARD_Hypothesis::AddComp( const char* NomComposant )
 329 {
 330   _ListComposant.push_back( std::string( NomComposant ) );
 331 }
 332 //=============================================================================
 333 void HOMARD_Hypothesis::SupprComp()
 334 {
 335   std::cerr << "HOMARD_Hypothesis::SupprComp" << std::endl;
 336   _ListComposant.clear();
 337 }
 338 //=============================================================================
 339 const std::list<std::string>& HOMARD_Hypothesis::GetListComp() const
 340 {
 341   return _ListComposant;
 342 }
 343 //=============================================================================
 344 /*!
 345 */
 346 //=============================================================================
 347 const std::list<std::string>& HOMARD_Hypothesis::GetGroups() const
 348 {
 349   return _ListGroupSelected;
 350 }
 351 //=============================================================================
 352 void HOMARD_Hypothesis::SetGroups( const std::list<std::string>& ListGroup )
 353 {
 354   _ListGroupSelected.clear();
 355   std::list<std::string>::const_iterator it = ListGroup.begin();
 356   while(it != ListGroup.end())
 357     _ListGroupSelected.push_back((*it++));
 358 }
 359 //=============================================================================
 360 void HOMARD_Hypothesis::AddGroup( const char* Group)
 361 {
 362   _ListGroupSelected.push_back(Group);
 363 }
 364 //=============================================================================
 365 /*!
 366 */
 367 //=============================================================================
 368 void HOMARD_Hypothesis::SetTypeFieldInterp( int TypeFieldInterp )
 369 {
 370   ASSERT (!((TypeFieldInterp < -1) or (TypeFieldInterp > 2)));
 371   _TypeFieldInterp = TypeFieldInterp;
 372 }
 373
 374 //=============================================================================
 375 /*!
 376 */
 377 //=============================================================================
 378 int HOMARD_Hypothesis::GetTypeFieldInterp() const
 379 {
 380   return _TypeFieldInterp;
 381 }
 382 /*!
 383 */
 384 //=============================================================================
 385 void HOMARD_Hypothesis::AddFieldInterp( const char* FieldInterp )
 386 {
 387   _ListFieldInterp.push_back( std::string( FieldInterp ) );
 388 }
 389 //=============================================================================
 390 void HOMARD_Hypothesis::SupprFieldInterp()
 391 {
 392   std::cerr << "HOMARD_Hypothesis::SupprFieldInterpp" << std::endl;
 393   _ListFieldInterp.clear();
 394 }
 395 //=============================================================================
 396 const std::list<std::string>& HOMARD_Hypothesis::GetListFieldInterp() const
 397 {
 398   return _ListFieldInterp;
 399 }
 400 //=============================================================================
 401 void HOMARD_Hypothesis::SetNivMax( int NivMax )
 402 //=============================================================================
 403 {
 404   _NivMax = NivMax;
 405 }
 406 //=============================================================================
 407 const int HOMARD_Hypothesis::GetNivMax() const
 408 //=============================================================================
 409 {
 410   return _NivMax;
 411 }
 412 //=============================================================================
 413 void HOMARD_Hypothesis::SetDiamMin( double DiamMin )
 414 //=============================================================================
 415 {
 416   _DiamMin = DiamMin;
 417   if ( _NivMax < 0 )
 418   {
 419     _NivMax = 99 ;
 420   }
 421 }
 422 //=============================================================================
 423 const double HOMARD_Hypothesis::GetDiamMin() const
 424 //=============================================================================
 425 {
 426   return _DiamMin;
 427 }