src/HexoticPlugin/HexoticPlugin_Hypothesis.cxx

   1 // Copyright (C) 2007-2013  CEA/DEN, EDF R&D
   2 //
   3 // This library is free software; you can redistribute it and/or
   4 // modify it under the terms of the GNU Lesser General Public
   5 // License as published by the Free Software Foundation; either
   6 // version 2.1 of the License.
   7 //
   8 // This library is distributed in the hope that it will be useful,
   9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11 // Lesser General Public License for more details.
  12 //
  13 // You should have received a copy of the GNU Lesser General Public
  14 // License along with this library; if not, write to the Free Software
  15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  16 //
  17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  18 //
  19
  20 // ---
  21 // File   : HexoticPlugin_Hypothesis.cxx
  22 // Author : Lioka RAZAFINDRAZAKA (CEA)
  23 // ---
  24 //
  25 #include "HexoticPlugin_Hypothesis.hxx"
  26 #include <utilities.h>
  27
  28 #include <TCollection_AsciiString.hxx>
  29
  30 //=============================================================================
  31 /*!
  32  *
  33  */
  34 //=============================================================================
  35 HexoticPlugin_Hypothesis::HexoticPlugin_Hypothesis (int hypId, int studyId,
  36                                                     SMESH_Gen* gen)
  37   : SMESH_Hypothesis(hypId, studyId, gen),
  38     _hexesMinLevel( GetDefaultHexesMinLevel() ),
  39     _hexesMaxLevel( GetDefaultHexesMaxLevel() ),
  40     _minSize( GetDefaultMinSize() ),
  41     _maxSize( GetDefaultMaxSize() ),
  42     _hexoticIgnoreRidges( GetDefaultHexoticIgnoreRidges() ),
  43     _hexoticInvalidElements( GetDefaultHexoticInvalidElements() ),
  44     _hexoticSharpAngleThreshold( GetDefaultHexoticSharpAngleThreshold() ),
  45     _hexoticNbProc( GetDefaultHexoticNbProc() ),
  46     _hexoticWorkingDirectory( GetDefaultHexoticWorkingDirectory() ),
  47     _hexoticSdMode(GetDefaultHexoticSdMode()),
  48     _hexoticVerbosity(GetDefaultHexoticVerbosity()),
  49     _hexoticMaxMemory(GetDefaultHexoticMaxMemory()),
  50     _sizeMaps(GetDefaultHexoticSizeMaps())
  51 {
  52   MESSAGE("HexoticPlugin_Hypothesis::HexoticPlugin_Hypothesis");
  53   _name = "Hexotic_Parameters";
  54   _param_algo_dim = 3;
  55 }
  56
  57 //=============================================================================
  58 /*!
  59  *
  60  */
  61 //=============================================================================
  62
  63 void HexoticPlugin_Hypothesis::SetHexesMinLevel(int theVal) {
  64   if (theVal != _hexesMinLevel) {
  65     _hexesMinLevel = theVal;
  66     NotifySubMeshesHypothesisModification();
  67   }
  68 }
  69
  70 void HexoticPlugin_Hypothesis::SetHexesMaxLevel(int theVal) {
  71   if (theVal != _hexesMaxLevel) {
  72     _hexesMaxLevel = theVal;
  73     NotifySubMeshesHypothesisModification();
  74   }
  75 }
  76
  77 void HexoticPlugin_Hypothesis::SetMinSize(double theVal) {
  78   if (theVal != _minSize) {
  79           _minSize = theVal;
  80     NotifySubMeshesHypothesisModification();
  81   }
  82 }
  83
  84 void HexoticPlugin_Hypothesis::SetMaxSize(double theVal) {
  85   if (theVal != _maxSize) {
  86           _maxSize = theVal;
  87     NotifySubMeshesHypothesisModification();
  88   }
  89 }
  90
  91 void HexoticPlugin_Hypothesis::SetHexoticIgnoreRidges(bool theVal) {
  92   if (theVal != _hexoticIgnoreRidges) {
  93     _hexoticIgnoreRidges = theVal;
  94     NotifySubMeshesHypothesisModification();
  95   }
  96 }
  97
  98 void HexoticPlugin_Hypothesis::SetHexoticInvalidElements(bool theVal) {
  99   if (theVal != _hexoticInvalidElements) {
 100     _hexoticInvalidElements = theVal;
 101     NotifySubMeshesHypothesisModification();
 102   }
 103 }
 104
 105 void HexoticPlugin_Hypothesis::SetHexoticSharpAngleThreshold(double theVal) {
 106   if (theVal != _hexoticSharpAngleThreshold) {
 107     _hexoticSharpAngleThreshold = theVal;
 108     NotifySubMeshesHypothesisModification();
 109   }
 110 }
 111
 112 void HexoticPlugin_Hypothesis::SetHexoticNbProc(int theVal) {
 113   if (theVal != _hexoticNbProc) {
 114     _hexoticNbProc = theVal;
 115     NotifySubMeshesHypothesisModification();
 116   }
 117 }
 118
 119 void HexoticPlugin_Hypothesis::SetHexoticWorkingDirectory(const std::string& path)
 120 {
 121   if ( _hexoticWorkingDirectory != path ) {
 122     _hexoticWorkingDirectory = path;
 123     NotifySubMeshesHypothesisModification();
 124   }
 125 }
 126
 127 void HexoticPlugin_Hypothesis::SetHexoticSdMode(int theVal) {
 128   if (theVal != _hexoticSdMode) {
 129     _hexoticSdMode = theVal;
 130     NotifySubMeshesHypothesisModification();
 131   }
 132 }
 133
 134 void HexoticPlugin_Hypothesis::SetHexoticVerbosity(int theVal) {
 135   if (theVal != _hexoticVerbosity) {
 136     _hexoticVerbosity = theVal;
 137     NotifySubMeshesHypothesisModification();
 138   }
 139 }
 140
 141 void HexoticPlugin_Hypothesis::SetHexoticMaxMemory(int theVal) {
 142   if (theVal != _hexoticMaxMemory) {
 143     _hexoticMaxMemory = theVal;
 144     NotifySubMeshesHypothesisModification();
 145   }
 146 }
 147
 148 bool HexoticPlugin_Hypothesis::AddSizeMap(std::string theEntry, double theSize) {
 149   THexoticSizeMaps::iterator it;
 150   it=_sizeMaps.find(theEntry);
 151
 152   if(theSize <= 0)
 153     return false;
 154
 155   if( it == _sizeMaps.end() ) // If no size map is defined on the given object
 156   {
 157     _sizeMaps[theEntry] = theSize;
 158     MESSAGE("NEW size map, entry :"<<theEntry<<", size : "<<theSize);
 159     NotifySubMeshesHypothesisModification();
 160     return true;
 161   }
 162   else if( it->second != theSize ) // If a size map exists with a different size value
 163   {
 164     it->second = theSize;
 165     MESSAGE("MODIFIED size map, entry :"<<theEntry<<"with size : "<<theSize);
 166     NotifySubMeshesHypothesisModification();
 167     return true;
 168   }
 169   else
 170   {
 171     MESSAGE("NO size map added")
 172     return false; // No size map added
 173   }
 174 }
 175
 176 bool HexoticPlugin_Hypothesis::UnsetSizeMap(std::string theEntry) {
 177   THexoticSizeMaps::iterator it;
 178   it=_sizeMaps.find(theEntry);
 179   if( it != _sizeMaps.end() )
 180   {
 181     _sizeMaps.erase(it);
 182     return true;
 183   }
 184   else
 185     return false;
 186 }
 187
 188 //=============================================================================
 189 /*!
 190  *
 191  */
 192 //=============================================================================
 193 std::ostream& HexoticPlugin_Hypothesis::SaveTo(std::ostream& save)
 194 {
 195   //explicit outputs for future code compatibility of saved .hdf
 196   //save without any whitespaces!
 197   int dummy = -1;
 198   save<<"hexesMinLevel="<<_hexesMinLevel<<";";
 199   save<<"hexesMaxLevel="<<_hexesMaxLevel<<";";
 200   save<<"hexoticIgnoreRidges="<<(int)_hexoticIgnoreRidges<<";";
 201   save<<"hexoticInvalidElements="<<(int)_hexoticInvalidElements<<";";
 202   save<<"hexoticSharpAngleThreshold="<<_hexoticSharpAngleThreshold<<";";
 203   save<<"hexoticNbProc="<<_hexoticNbProc<<";";
 204   save<<"hexoticWorkingDirectory="<<_hexoticWorkingDirectory<<";";
 205   save<<"minSize="<<_minSize<<";";
 206   save<<"maxSize="<<_maxSize<<";";
 207   save<<"hexoticSdMode="<<_hexoticSdMode<<";";
 208   save<<"hexoticVerbosity="<<_hexoticVerbosity<<";";
 209   save<<"hexoticMaxMemory="<<_hexoticMaxMemory<<";";
 210   return save;
 211 }
 212
 213 //=============================================================================
 214 /*!
 215  *
 216  */
 217 //=============================================================================
 218 std::istream& HexoticPlugin_Hypothesis::LoadFrom(std::istream& load)
 219 {
 220    //explicit inputs for future code compatibility of saved .hdf
 221    bool isOK = true;
 222    std::string str1,str2,str3,str4;
 223
 224    //save without any whitespaces!
 225    isOK = (load >> str1);
 226    if (!(isOK)) {
 227      //defaults values assumed
 228      load.clear(std::ios::badbit | load.rdstate());
 229      return load;
 230    }
 231    int pos = 0;
 232    int len = str1.length();
 233    while (pos < len) {
 234       int found = str1.find(';',pos);
 235       str2 = str1.substr(pos,found-pos);
 236       int eqpos = str2.find('=',0);
 237       str3 = str2.substr(0,eqpos);
 238       str4 = str2.substr(eqpos+1);
 239       pos = found + 1;
 240
 241       if (str3=="hexesMinLevel") _hexesMinLevel = atoi(str4.c_str());
 242       if (str3=="hexesMaxLevel") _hexesMaxLevel = atoi(str4.c_str());
 243       if (str3=="hexoticQuadrangles") {}
 244       if (str3=="hexoticIgnoreRidges") _hexoticIgnoreRidges = (bool) atoi(str4.c_str());
 245       if (str3=="hexoticInvalidElements") _hexoticInvalidElements = (bool) atoi(str4.c_str());
 246       if (str3=="hexoticSharpAngleThreshold") _hexoticSharpAngleThreshold = atof(str4.c_str());
 247       if (str3=="hexoticNbProc") _hexoticNbProc = atoi(str4.c_str());
 248       if (str3=="hexoticWorkingDirectory") _hexoticWorkingDirectory = str4;
 249       if (str3=="minSize") _minSize = atof(str4.c_str());
 250       if (str3=="maxSize") _maxSize = atof(str4.c_str());
 251       if (str3=="hexoticSdMode") _hexoticSdMode = atoi(str4.c_str());
 252       if (str3=="hexoticVerbosity") _hexoticVerbosity = atoi(str4.c_str());
 253       if (str3=="hexoticMaxMemory") _hexoticMaxMemory = atoi(str4.c_str());
 254    }
 255    return load;
 256 }
 257
 258 //=============================================================================
 259 /*!
 260  *
 261  */
 262 //=============================================================================
 263 std::ostream& operator <<(std::ostream& save, HexoticPlugin_Hypothesis& hyp)
 264 {
 265   return hyp.SaveTo( save );
 266 }
 267
 268 //=============================================================================
 269 /*!
 270  *
 271  */
 272 //=============================================================================
 273 std::istream& operator >>(std::istream& load, HexoticPlugin_Hypothesis& hyp)
 274 {
 275   return hyp.LoadFrom( load );
 276 }
 277
 278
 279 //================================================================================
 280 /*!
 281  * \brief Does nothing
 282  * \param theMesh - the built mesh
 283  * \param theShape - the geometry of interest
 284  * \retval bool - always false
 285  */
 286 //================================================================================
 287 bool HexoticPlugin_Hypothesis::SetParametersByMesh(const SMESH_Mesh*   theMesh,
 288                                                    const TopoDS_Shape& theShape)
 289 {
 290   return false;
 291 }
 292 //================================================================================
 293 /*!
 294  * \brief Initialize my parameter values by default parameters.
 295  *  \retval bool - true if parameter values have been successfully defined
 296  */
 297 //================================================================================
 298
 299 bool HexoticPlugin_Hypothesis::SetParametersByDefaults(const TDefaults&  /*dflts*/,
 300                                                        const SMESH_Mesh* /*theMesh*/)
 301 {
 302   return false;
 303 }
 304
 305 //=============================================================================
 306 int HexoticPlugin_Hypothesis::GetDefaultHexesMinLevel()
 307 {
 308   return 6;
 309 }
 310
 311 int HexoticPlugin_Hypothesis::GetDefaultHexesMaxLevel()
 312 {
 313   return 10;
 314 }
 315
 316 double HexoticPlugin_Hypothesis::GetDefaultMinSize()
 317 {
 318   return 0.0;
 319 }
 320
 321 double HexoticPlugin_Hypothesis::GetDefaultMaxSize()
 322 {
 323   return 0.0;
 324 }
 325
 326 bool HexoticPlugin_Hypothesis::GetDefaultHexoticIgnoreRidges()
 327 {
 328   return false;
 329 }
 330
 331 bool HexoticPlugin_Hypothesis::GetDefaultHexoticInvalidElements()
 332 {
 333   return false;
 334 }
 335
 336 double HexoticPlugin_Hypothesis::GetDefaultHexoticSharpAngleThreshold()
 337 {
 338   return 60.0;
 339 }
 340
 341 int HexoticPlugin_Hypothesis::GetDefaultHexoticNbProc()
 342 {
 343   return 4;
 344 }
 345
 346 std::string HexoticPlugin_Hypothesis::GetDefaultHexoticWorkingDirectory()
 347 {
 348   std::string aTmpDir;
 349
 350   char *Tmp_dir = getenv("SALOME_TMP_DIR");
 351 #ifdef WIN32
 352   if(Tmp_dir == NULL) {
 353     Tmp_dir = getenv("TEMP");
 354     if( Tmp_dir== NULL )
 355       Tmp_dir = getenv("TMP");
 356   }
 357 #endif
 358   if( Tmp_dir != NULL ) {
 359     aTmpDir = std::string(Tmp_dir);
 360 #ifdef WIN32
 361     if(aTmpDir[aTmpDir.size()-1] != '\\') aTmpDir+='\\';
 362 #else
 363     if(aTmpDir[aTmpDir.size()-1] != '/') aTmpDir+='/';
 364 #endif
 365   }
 366   else {
 367 #ifdef WIN32
 368     aTmpDir = "C:\\";
 369 #else
 370     aTmpDir = "/tmp/";
 371 #endif
 372   }
 373   return aTmpDir;
 374 }
 375
 376 int HexoticPlugin_Hypothesis::GetDefaultHexoticSdMode()
 377 {
 378   return 4;
 379 }
 380
 381 int HexoticPlugin_Hypothesis::GetDefaultHexoticVerbosity()
 382 {
 383   return 1;
 384 }
 385
 386 int HexoticPlugin_Hypothesis::GetDefaultHexoticMaxMemory()
 387 {
 388   return 2048;
 389 }
 390
 391 HexoticPlugin_Hypothesis::THexoticSizeMaps HexoticPlugin_Hypothesis::GetDefaultHexoticSizeMaps()
 392 {
 393   return THexoticSizeMaps();
 394 }
 395
 396