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
 143   return aScript.str();
 144 }
 145
 146
 147 //=============================================================================
 148 /*!
 149 */
 150 //=============================================================================
 151 void HOMARD_Hypothesis::SetAdapType( int TypeAdap )
 152 {
 153   ASSERT (!((TypeAdap < -1) or (TypeAdap > 1)));
 154   _TypeAdap = TypeAdap;
 155 }
 156
 157 //=============================================================================
 158 /*!
 159 */
 160 //=============================================================================
 161 int HOMARD_Hypothesis::GetAdapType() const
 162 {
 163   return _TypeAdap;
 164 }
 165
 166 //=============================================================================
 167 /*!
 168 */
 169 //=============================================================================
 170 void HOMARD_Hypothesis::SetRefinTypeDera( int TypeRaff, int TypeDera )
 171 {
 172   ASSERT(!(( TypeRaff < 0) or (TypeRaff > 1)));
 173   _TypeRaff = TypeRaff;
 174   ASSERT(! ((TypeDera < 0) or (TypeDera > 1)));
 175   _TypeDera = TypeDera;
 176 }
 177
 178 //=============================================================================
 179 /*!
 180 */
 181 //=============================================================================
 182 int HOMARD_Hypothesis::GetRefinType() const
 183 {
 184   return _TypeRaff;
 185 }
 186
 187 //=============================================================================
 188 /*!
 189 */
 190 //=============================================================================
 191 int HOMARD_Hypothesis::GetUnRefType() const
 192 {
 193   return _TypeDera;
 194 }
 195
 196 //=============================================================================
 197 /*!
 198 */
 199 //=============================================================================
 200 void HOMARD_Hypothesis::SetField( const char* FieldName )
 201 {
 202   _Field = std::string( FieldName );
 203   MESSAGE( "SetField : FieldName = " << FieldName );
 204 }
 205 //=============================================================================
 206 void HOMARD_Hypothesis::SetRefinThr( int TypeThR, double ThreshR )
 207 {
 208   MESSAGE( "SetRefinThr : TypeThR = " << TypeThR << ", ThreshR = " << ThreshR );
 209   ASSERT(!(( TypeThR < 0) or (TypeThR > 3 )));
 210   _TypeThR = TypeThR;
 211   _ThreshR = ThreshR;
 212 }
 213 //=============================================================================
 214 void HOMARD_Hypothesis::SetUnRefThr( int TypeThC, double ThreshC )
 215 {
 216   ASSERT(!((TypeThC < 0) or (TypeThC > 3)));
 217   _TypeThC = TypeThC;
 218   _ThreshC = ThreshC;
 219 }
 220 //=============================================================================
 221 void HOMARD_Hypothesis::SetUseComp( int UsCmpI )
 222 {
 223   ASSERT(!((UsCmpI < 0) or (UsCmpI > 2)));
 224   _UsCmpI = UsCmpI;
 225 }
 226 //=============================================================================
 227 void HOMARD_Hypothesis::SetUseField( int UsField )
 228 {
 229   ASSERT(!((UsField < 0) or (UsField > 1 )));
 230   _UsField = UsField;
 231 }
 232
 233 //=============================================================================
 234 /*!
 235 */
 236 //=============================================================================
 237 std::string HOMARD_Hypothesis::GetFieldName() const
 238 {
 239   return _Field;
 240 }
 241 //=============================================================================
 242 int HOMARD_Hypothesis::GetRefinThrType() const
 243 {
 244   return _TypeThR;
 245 }
 246 //=============================================================================
 247 double HOMARD_Hypothesis::GetThreshR() const
 248 {
 249   return _ThreshR;
 250 }
 251 //=============================================================================
 252 int HOMARD_Hypothesis::GetUnRefThrType() const
 253 {
 254   return _TypeThC;
 255 }
 256
 257 //=============================================================================
 258 double HOMARD_Hypothesis::GetThreshC() const
 259 {
 260   return _ThreshC;
 261 }
 262 //=============================================================================
 263 int HOMARD_Hypothesis::GetUseField() const
 264 {
 265   return _UsField;
 266 }
 267 //=============================================================================
 268 int HOMARD_Hypothesis::GetUseCompI() const
 269 {
 270   return _UsCmpI;
 271 }
 272 //=============================================================================
 273 /*!
 274 */
 275 //=============================================================================
 276 void HOMARD_Hypothesis::AddIteration( const char* NomIteration )
 277 {
 278   _ListIter.push_back( std::string( NomIteration ) );
 279 }
 280 //=============================================================================
 281 void HOMARD_Hypothesis::SupprIterations()
 282 {
 283   _ListIter.clear();
 284 }
 285 //=============================================================================
 286 const std::list<std::string>& HOMARD_Hypothesis::GetIterations() const
 287 {
 288   return _ListIter;
 289 }
 290 //=============================================================================
 291 /*!
 292 */
 293 //=============================================================================
 294 void HOMARD_Hypothesis::AddZone( const char* NomZone )
 295 {
 296   _ListZone.push_back( std::string( NomZone ) );
 297 }
 298 //=============================================================================
 299 void HOMARD_Hypothesis::SupprZone( const char* NomZone )
 300 {
 301   std::list<std::string>::iterator it = find( _ListZone.begin(), _ListZone.end(), NomZone );
 302   if ( it != _ListZone.end() )
 303   {
 304     _ListZone.erase( it );
 305   }
 306 }
 307 //=============================================================================
 308 void HOMARD_Hypothesis::SupprZones()
 309 {
 310   _ListZone.clear();
 311 }
 312 //=============================================================================
 313 const std::list<std::string>& HOMARD_Hypothesis::GetZones() const
 314 {
 315   return _ListZone;
 316 }
 317 //=============================================================================
 318 /*!
 319 */
 320 //=============================================================================
 321 void HOMARD_Hypothesis::AddComp( const char* NomComposant )
 322 {
 323   _ListComposant.push_back( std::string( NomComposant ) );
 324 }
 325 //=============================================================================
 326 void HOMARD_Hypothesis::SupprComp()
 327 {
 328   std::cerr << "HOMARD_Hypothesis::SupprComp" << std::endl;
 329   _ListComposant.clear();
 330 }
 331 //=============================================================================
 332 const std::list<std::string>& HOMARD_Hypothesis::GetListComp() const
 333 {
 334   return _ListComposant;
 335 }
 336 //=============================================================================
 337 /*!
 338 */
 339 //=============================================================================
 340 const std::list<std::string>& HOMARD_Hypothesis::GetGroups() const
 341 {
 342   return _ListGroupSelected;
 343 }
 344 //=============================================================================
 345 void HOMARD_Hypothesis::SetGroups( const std::list<std::string>& ListGroup )
 346 {
 347   _ListGroupSelected.clear();
 348   std::list<std::string>::const_iterator it = ListGroup.begin();
 349   while(it != ListGroup.end())
 350     _ListGroupSelected.push_back((*it++));
 351 }
 352 //=============================================================================
 353 void HOMARD_Hypothesis::AddGroup( const char* Group)
 354 {
 355   _ListGroupSelected.push_back(Group);
 356 }
 357 //=============================================================================
 358 /*!
 359 */
 360 //=============================================================================
 361 void HOMARD_Hypothesis::SetTypeFieldInterp( int TypeFieldInterp )
 362 {
 363   ASSERT (!((TypeFieldInterp < -1) or (TypeFieldInterp > 2)));
 364   _TypeFieldInterp = TypeFieldInterp;
 365 }
 366
 367 //=============================================================================
 368 /*!
 369 */
 370 //=============================================================================
 371 int HOMARD_Hypothesis::GetTypeFieldInterp() const
 372 {
 373   return _TypeFieldInterp;
 374 }
 375 /*!
 376 */
 377 //=============================================================================
 378 void HOMARD_Hypothesis::AddFieldInterp( const char* FieldInterp )
 379 {
 380   _ListFieldInterp.push_back( std::string( FieldInterp ) );
 381 }
 382 //=============================================================================
 383 void HOMARD_Hypothesis::SupprFieldInterp()
 384 {
 385   std::cerr << "HOMARD_Hypothesis::SupprFieldInterpp" << std::endl;
 386   _ListFieldInterp.clear();
 387 }
 388 //=============================================================================
 389 const std::list<std::string>& HOMARD_Hypothesis::GetListFieldInterp() const
 390 {
 391   return _ListFieldInterp;
 392 }
 393