src/HOMARD/HOMARD_DriverTools.cxx

   1 // Copyright (C) 2011-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 //  File   : HOMARD_DriverTools.cxx
  20 //  Author : Vadim SANDLER, Open CASCADE S.A.S. (vadim.sandler@opencascade.com)
  21 //
  22 // ----------------------------------------------------------------------------
  23
  24 #include "HOMARD_DriverTools.hxx"
  25 #include "HOMARD_Boundary.hxx"
  26 #include "HOMARD_Cas.hxx"
  27 #include "HOMARD_Hypothesis.hxx"
  28 #include "HOMARD_Iteration.hxx"
  29 #include "HOMARD_Zone.hxx"
  30 #include "HOMARD_YACS.hxx"
  31 #include <sstream>
  32 #include <cstdlib>
  33 #include "utilities.h"
  34
  35 namespace HOMARD
  36 {
  37
  38   std::string SEPARATOR = "|" ;
  39
  40   /*!
  41     \brief Read next chunk of data from the string
  42     \internal
  43
  44     The function tries to read next chunk of the data from the input string \a str.
  45     The parameter \a start specifies the start position of next chunk. If the operation
  46     read the chunk successfully, after its completion this parameter will refer to the
  47     start position of the next chunk. The function returns resulting chunk as a string.
  48     The status of the operation is returned via \a ok parameter.
  49
  50     \param str source data stream string
  51     \param start start position to get next chunk
  52     \param ok in this variable the status of the chunk reading operation is returned
  53     \return next chunk read from the string
  54   */
  55   static std::string getNextChunk( const std::string& str, std::string::size_type& start, bool& ok )
  56   {
  57     std::string chunk = "";
  58     ok = false;
  59     if ( start <= str.size() ) {
  60       std::string::size_type end = str.find( separator(), start );
  61       chunk = str.substr( start, end == std::string::npos ? std::string::npos : end-start );
  62       start = end == std::string::npos ? str.size()+1 : end + separator().size();
  63       ok = true;
  64     }
  65     return chunk;
  66   }
  67
  68   /*!
  69     \brief Get persistence signature
  70     \param type persistence entity type
  71     \return persistence signature
  72   */
  73   std::string GetSignature( SignatureType type )
  74   {
  75     std::string signature = "";
  76     switch ( type ) {
  77     case Case:       signature = "CASE"; break;
  78     case Zone:       signature = "ZONE"; break;
  79     case Hypothesis: signature = "HYPO"; break;
  80     case Iteration:  signature = "ITER"; break;
  81     case Boundary:   signature = "BOUNDARY"; break;
  82     case YACS:       signature = "YACS"; break;
  83     default: break;
  84     }
  85     signature += separator();
  86     return signature;
  87   }
  88
  89   /*!
  90     \brief Get data separator
  91     \return string that is used to separate data entities in the stream
  92   */
  93   std::string separator()
  94   {
  95     return SEPARATOR ;
  96   }
  97
  98 // =======================
  99 // 1.1. Case
 100 // =======================
 101   /*!
 102     \brief Dump case to the string
 103     \param cas case being dumped
 104     \return string representation of the case
 105   */
 106   std::string Dump( const HOMARD_Cas& cas )
 107   {
 108     std::stringstream os;
 109     std::string saux ;
 110     // ...
 111     MESSAGE( ". Sauvegarde du cas "<<cas.GetName());
 112     os << cas.GetName();
 113     os << separator() << cas.GetDirName();
 114     os << separator() << cas.GetConfType();
 115
 116     std::vector<double> coor = cas.GetBoundingBox();
 117     os << separator() << coor.size();
 118     for ( int i = 0; i < coor.size(); i++ )
 119           os << separator() << coor[i];
 120
 121     std::list<std::string> ListString = cas.GetIterations();
 122     os << separator() << ListString.size();
 123     std::list<std::string>::const_iterator it;
 124     for ( it = ListString.begin(); it != ListString.end(); ++it )
 125           os << separator() << *it;
 126
 127     ListString = cas.GetGroups();
 128     os << separator() << ListString.size();
 129     for ( it = ListString.begin(); it != ListString.end(); ++it )
 130          os << separator() << *it;
 131     ListString = cas.GetBoundaryGroup();
 132     os << separator() << ListString.size();
 133     for ( it = ListString.begin(); it != ListString.end(); ++it )
 134          os << separator() << *it;
 135
 136     os << separator() << cas.GetPyram();
 137
 138     saux = os.str();
 139 //     MESSAGE( ". Fin avec "<<saux);
 140     return saux ;
 141   }
 142 //
 143 // ==============
 144 // 1.2. Iteration
 145 // ==============
 146 //
 147   /*!
 148     \brief Dump iteration to the string
 149     \param iteration iteration being dumped
 150     \return string representation of the iteration
 151   */
 152   std::string Dump( const HOMARD_Iteration& iteration )
 153   {
 154     std::stringstream os;
 155     std::string saux ;
 156     // ...
 157     MESSAGE( ". Sauvegarde de l'iteration "<<iteration.GetName());
 158     os << iteration.GetName();
 159     os << separator() << iteration.GetState();
 160     os << separator() << iteration.GetNumber();
 161     os << separator() << iteration.GetMeshFile();
 162     os << separator() << iteration.GetLogFile();
 163     os << separator() << iteration.GetMeshName();
 164     os << separator() << iteration.GetFieldFile();
 165     os << separator() << iteration.GetTimeStep();
 166     os << separator() << iteration.GetRank();
 167     os << separator() << iteration.GetIterParentName();
 168     //
 169     std::list<std::string> ListString = iteration.GetIterations();
 170     os << separator() << ListString.size();
 171     std::list<std::string>::const_iterator it;
 172     for ( it = ListString.begin(); it != ListString.end(); ++it )
 173       os << separator() << *it;
 174
 175     os << separator() << iteration.GetHypoName();
 176     os << separator() << iteration.GetCaseName();
 177     os << separator() << iteration.GetDirNameLoc();
 178
 179     saux = os.str();
 180 //     MESSAGE( ". Fin avec "<<saux);
 181     return saux ;
 182   }
 183 //
 184 // ==============
 185 // 1.3. hypothese
 186 // ==============
 187   /*!
 188     \brief Dump hypothesis to the string
 189     \param hypothesis hypothesis being dumped
 190     \return string representation of the hypothesis
 191   */
 192   std::string Dump( const HOMARD_Hypothesis& hypothesis )
 193   {
 194     std::stringstream os;
 195     std::string saux ;
 196     // ...
 197     MESSAGE( ". Sauvegarde de l'hypothese "<<hypothesis.GetName());
 198     os << hypothesis.GetName();
 199     os << separator() << hypothesis.GetCaseCreation();
 200     os << separator() << hypothesis.GetAdapType();
 201     os << separator() << hypothesis.GetRefinType();
 202     os << separator() << hypothesis.GetUnRefType();
 203     os << separator() << hypothesis.GetFieldName();
 204     os << separator() << hypothesis.GetRefinThrType();
 205     os << separator() << hypothesis.GetThreshR();
 206     os << separator() << hypothesis.GetUnRefThrType();
 207     os << separator() << hypothesis.GetThreshC();
 208     os << separator() << hypothesis.GetUseField();
 209     os << separator() << hypothesis.GetUseComp();
 210     os << separator() << hypothesis.GetTypeFieldInterp();
 211
 212     std::list<std::string> ListString = hypothesis.GetIterations();
 213     std::list<std::string>::const_iterator it;
 214     os << separator() << ListString.size();
 215     for ( it = ListString.begin(); it != ListString.end(); ++it )
 216          os << separator() << *it;
 217
 218     ListString = hypothesis.GetZones();
 219     os << separator() << ListString.size();
 220     for ( it = ListString.begin(); it != ListString.end(); ++it )
 221           os << separator() << *it;
 222
 223     ListString = hypothesis.GetComps();
 224     os << separator() << ListString.size();
 225     for ( it = ListString.begin(); it != ListString.end(); ++it )
 226          os << separator() << *it;
 227
 228     ListString = hypothesis.GetGroups();
 229     os << separator() << ListString.size();
 230     for ( it = ListString.begin(); it != ListString.end(); ++it )
 231           os << separator() << *it;
 232
 233     ListString = hypothesis.GetListFieldInterp();
 234     os << separator() << ListString.size();
 235     for ( it = ListString.begin(); it != ListString.end(); ++it )
 236           os << separator() << *it;
 237
 238     os << separator() << hypothesis.GetNivMax();
 239     os << separator() << hypothesis.GetDiamMin();
 240     os << separator() << hypothesis.GetAdapInit();
 241     os << separator() << hypothesis.GetLevelOutput();
 242
 243     saux = os.str();
 244 //     MESSAGE( ". Fin avec "<<saux);
 245     return saux ;
 246   }
 247 //
 248 // =========
 249 // 1.4. Zone
 250 // =========
 251
 252   /*!
 253     \brief Dump zone to the string
 254     \param zone zone being dumped
 255     \return string representation of the zone
 256   */
 257   std::string Dump( const HOMARD_Zone& zone )
 258   {
 259     std::stringstream os;
 260     std::string saux ;
 261     MESSAGE( ". Sauvegarde de la zone "<<zone.GetName());
 262     os << zone.GetName();
 263     os << separator() << zone.GetType();
 264
 265     std::vector<double> coords = zone.GetCoords();
 266     for ( int i = 0; i < coords.size(); i++ )
 267       os << separator() << ( i < coords.size() ? coords[i] : 0. );
 268
 269     std::vector<double> limit = zone.GetLimit();
 270     for ( int i = 0; i < 3; i++ )
 271       os << separator() << ( i < limit.size() ? limit[i] : 0. );
 272
 273     std::list<std::string> hypos = zone.GetHypo();
 274     os << separator() << hypos.size();
 275     std::list<std::string>::const_iterator it;
 276     for ( it = hypos.begin(); it != hypos.end(); ++it )
 277       os << separator() << *it;
 278
 279     saux = os.str();
 280 //     MESSAGE( ". Fin avec "<<saux);
 281     return saux ;
 282   }
 283 //
 284 // ==============================
 285 // 1.5. Archivage d'une frontiere
 286 // ==============================
 287
 288   /*!
 289     \brief Dump boundary to the string
 290     \param boundary boundary being dumped
 291     \return string representation of the boundary
 292   */
 293   std::string Dump( const HOMARD_Boundary& boundary )
 294   {
 295     std::stringstream os;
 296     std::string saux ;
 297     MESSAGE( ". Sauvegarde de la frontiere "<<boundary.GetName());
 298
 299     int BoundaryType = boundary.GetType() ;
 300
 301     os << boundary.GetName() ;
 302     os << separator() << BoundaryType ;
 303     os << separator() << boundary.GetCaseCreation() ;
 304
 305     if ( BoundaryType == 0 )
 306     {
 307       os << separator() << boundary.GetMeshName();
 308       os << separator() << boundary.GetMeshFile();
 309     }
 310     else {
 311       std::vector<double> coor = boundary.GetCoords() ;
 312       for ( int i = 0; i < coor.size(); i++ )
 313             os << separator() << coor[i];
 314       std::vector<double> limit = boundary.GetLimit();
 315       for ( int i = 0; i < limit.size(); i++ )
 316             os << separator() << limit[i];
 317     }
 318
 319     std::list<std::string> ListString = boundary.GetGroups();
 320     std::list<std::string>::const_iterator it;
 321     os << separator() << ListString.size();
 322     for ( it = ListString.begin(); it != ListString.end(); ++it )
 323           os << separator() << *it;
 324
 325     saux = os.str();
 326 //     MESSAGE( ". Fin avec "<<saux);
 327     return saux ;
 328   }
 329
 330 //
 331 // =========
 332 // 1.6. YACS
 333 // =========
 334
 335   /*!
 336     \brief Dump YACS to the string
 337     \param yacs yacs being dumped
 338     \return string representation of the zone
 339   */
 340   std::string Dump( const HOMARD_YACS& yacs )
 341   {
 342     std::stringstream os;
 343     std::string saux ;
 344     MESSAGE( ". Sauvegarde du schema YACS "<<yacs.GetName());
 345     os << yacs.GetName();
 346     os << separator() << yacs.GetType();
 347
 348     saux = os.str();
 349 //     MESSAGE( ". Fin avec "<<saux);
 350     return saux ;
 351   }
 352 //
 353 // 2. Restauration des objets
 354 // ==========================
 355 // 2.1. Case
 356 // ==========================
 357 //
 358   /*!
 359     \brief Restore case from the string
 360     \param cas case being restored
 361     \param stream string representation of the case
 362     \return \c true if case is correctly restored or \c false otherwise
 363   */
 364   bool Restore( HOMARD_Cas& cas, const std::string& stream )
 365   {
 366     MESSAGE( ". Restoration du cas ");
 367     std::string::size_type start = 0;
 368     std::string chunk, chunkNext;
 369     bool ok;
 370     // ...
 371     chunk = getNextChunk( stream, start, ok );
 372     if ( !ok ) return false;
 373     cas.SetName( chunk.c_str() );
 374
 375     chunk = getNextChunk( stream, start, ok );
 376     if ( !ok ) return false;
 377     cas.SetDirName( chunk.c_str() );
 378
 379     chunk = getNextChunk( stream, start, ok );
 380     if ( !ok ) return false;
 381     cas.SetConfType( atoi( chunk.c_str() ) );
 382
 383     chunk = getNextChunk( stream, start, ok );
 384     if ( !ok ) return false;
 385
 386     int size = atoi( chunk.c_str() );
 387     std::vector<double> boite;
 388     boite.resize( size );
 389     for ( int i = 0; i < size; i++ ) {
 390       chunk = getNextChunk( stream, start, ok );
 391       if ( !ok ) return false;
 392       boite[i] = strtod( chunk.c_str(), 0 );
 393     }
 394     cas.SetBoundingBox( boite );
 395
 396     chunk = getNextChunk( stream, start, ok );
 397     if ( !ok ) return false;
 398
 399     size = atoi( chunk.c_str() );
 400     for ( int i = 0; i < size; i++ ) {
 401       chunk = getNextChunk( stream, start, ok );
 402       if ( !ok ) return false;
 403       cas.AddIteration( chunk.c_str() );
 404     }
 405
 406     chunk = getNextChunk( stream, start, ok );
 407     if ( !ok ) return false;
 408     size = atoi( chunk.c_str() );
 409     for ( int i = 0; i < size; i++ )
 410     {
 411       chunk = getNextChunk( stream, start, ok );
 412       if ( !ok ) return false;
 413       cas.AddGroup( chunk.c_str() );
 414     }
 415
 416     chunk = getNextChunk( stream, start, ok );
 417     if ( !ok ) return false;
 418     size = atoi( chunk.c_str() );
 419     for ( int i = 0; i < size; i++ ) {
 420       chunk = getNextChunk( stream, start, ok );
 421       if ( !ok ) return false;
 422       i++;
 423       chunkNext = getNextChunk( stream, start, ok );
 424       if ( !ok ) return false;
 425       cas.AddBoundaryGroup( chunk.c_str(), chunkNext.c_str() );
 426     }
 427
 428     chunk = getNextChunk( stream, start, ok );
 429     if ( !ok ) return false;
 430     cas.SetPyram( atoi( chunk.c_str() ) );
 431
 432     return true;
 433   }
 434 //
 435 // ==============
 436 // 2.2. Iteration
 437 // ==============
 438   /*!
 439     \brief Restore iteration from the string
 440     \param iteration iteration being restored
 441     \param stream string representation of the iteration
 442     \return \c true if iteration is correctly restored or \c false otherwise
 443   */
 444   bool Restore( HOMARD_Iteration& iteration, const std::string& stream )
 445   {
 446     std::string::size_type start = 0;
 447     std::string chunk;
 448     bool ok;
 449     chunk = getNextChunk( stream, start, ok );
 450     if ( !ok ) return false;
 451
 452     iteration.SetName( chunk.c_str() );
 453     chunk = getNextChunk( stream, start, ok );
 454     if ( !ok ) return false;
 455     iteration.SetState( atoi( chunk.c_str() ) );
 456     chunk = getNextChunk( stream, start, ok );
 457     if ( !ok ) return false;
 458     iteration.SetNumber( atoi( chunk.c_str() ) );
 459     chunk = getNextChunk( stream, start, ok );
 460     if ( !ok ) return false;
 461     iteration.SetMeshFile( chunk.c_str() );
 462     chunk = getNextChunk( stream, start, ok );
 463     if ( !ok ) return false;
 464     iteration.SetLogFile( chunk.c_str() );
 465     chunk = getNextChunk( stream, start, ok );
 466     if ( !ok ) return false;
 467     iteration.SetMeshName( chunk.c_str() );
 468     chunk = getNextChunk( stream, start, ok );
 469     if ( !ok ) return false;
 470     iteration.SetFieldFile( chunk.c_str() );
 471     // .
 472     int timestep, rank;
 473     chunk = getNextChunk( stream, start, ok );
 474     if ( !ok ) return false;
 475     timestep = atoi( chunk.c_str() );
 476     chunk = getNextChunk( stream, start, ok );
 477     if ( !ok ) return false;
 478     rank = atoi( chunk.c_str() );
 479     iteration.SetTimeStepRank( timestep, rank );
 480     chunk = getNextChunk( stream, start, ok );
 481     if ( !ok ) return false;
 482     iteration.SetIterParentName( chunk.c_str() );
 483     //
 484     chunk = getNextChunk( stream, start, ok );
 485     if ( !ok ) return false;
 486     int size = atoi( chunk.c_str() );
 487     for ( int i = 0; i < size; i++ ) {
 488       chunk = getNextChunk( stream, start, ok );
 489       if ( !ok ) return false;
 490       iteration.LinkNextIteration( chunk.c_str() );
 491     }
 492     //
 493     chunk = getNextChunk( stream, start, ok );
 494     if ( !ok ) return false;
 495     iteration.SetHypoName( chunk.c_str() );
 496     chunk = getNextChunk( stream, start, ok );
 497     if ( !ok ) return false;
 498     iteration.SetCaseName( chunk.c_str() );
 499     chunk = getNextChunk( stream, start, ok );
 500     if ( !ok ) return false;
 501     iteration.SetDirNameLoc( chunk.c_str() );
 502     return true;
 503   }
 504
 505 //
 506 // ==============
 507 // 2.3. hypothese
 508 // ==============
 509   /*!
 510     \brief Restore hypothesis from the string
 511     \param hypothesis hypothesis being restored
 512     \param stream string representation of the hypothesis
 513     \return \c true if hypothesis is correctly restored or \c false otherwise
 514   */
 515   bool Restore( HOMARD_Hypothesis& hypothesis, const std::string& stream )
 516   {
 517     std::string::size_type start = 0;
 518     std::string chunk, chunkNext;
 519     bool ok;
 520
 521     chunk = getNextChunk( stream, start, ok );
 522     if ( !ok ) return false;
 523     hypothesis.SetName( chunk.c_str() );
 524
 525     chunk = getNextChunk( stream, start, ok );
 526     if ( !ok ) return false;
 527     hypothesis.SetCaseCreation( chunk.c_str() );
 528
 529     chunk = getNextChunk( stream, start, ok );
 530     if ( !ok ) return false;
 531     hypothesis.SetAdapType( atoi( chunk.c_str() ) );
 532
 533     chunk = getNextChunk( stream, start, ok );
 534     if ( !ok ) return false;
 535     int typeraff = atoi( chunk.c_str() );
 536     chunk = getNextChunk( stream, start, ok );
 537     if ( !ok ) return false;
 538     int typedera = atoi( chunk.c_str() );
 539     hypothesis.SetRefinTypeDera( typeraff, typedera );
 540
 541     chunk = getNextChunk( stream, start, ok );
 542     if ( !ok ) return false;
 543     hypothesis.SetField( chunk.c_str() );
 544
 545     chunk = getNextChunk( stream, start, ok );
 546     if ( !ok ) return false;
 547     int typethr = atoi( chunk.c_str() );
 548     chunk = getNextChunk( stream, start, ok );
 549     if ( !ok ) return false;
 550     double threshr = strtod( chunk.c_str(), 0 );
 551     hypothesis.SetRefinThr( typethr, threshr );
 552
 553     chunk = getNextChunk( stream, start, ok );
 554     if ( !ok ) return false;
 555     int typethc = atoi( chunk.c_str() );
 556     chunk = getNextChunk( stream, start, ok );
 557     if ( !ok ) return false;
 558     double threshc = strtod( chunk.c_str(), 0 );
 559     hypothesis.SetUnRefThr( typethc, threshc );
 560
 561     chunk = getNextChunk( stream, start, ok );
 562     if ( !ok ) return false;
 563     hypothesis.SetUseField(atoi(chunk.c_str()));
 564
 565     chunk = getNextChunk( stream, start, ok );
 566     if ( !ok ) return false;
 567     hypothesis.SetUseComp(atoi(chunk.c_str()));
 568
 569     chunk = getNextChunk( stream, start, ok );
 570     if ( !ok ) return false;
 571     hypothesis.SetTypeFieldInterp(atoi(chunk.c_str()));
 572
 573     chunk = getNextChunk( stream, start, ok );
 574     if ( !ok ) return false;
 575     int size = atoi( chunk.c_str() );
 576     for ( int i = 0; i < size; i++ ) {
 577       chunk = getNextChunk( stream, start, ok );
 578       if ( !ok ) return false;
 579       hypothesis.LinkIteration( chunk.c_str() );
 580     }
 581
 582     chunk = getNextChunk( stream, start, ok );
 583     if ( !ok ) return false;
 584     size = atoi( chunk.c_str() );
 585     for ( int i = 0; i < size; i++ ) {
 586       chunk = getNextChunk( stream, start, ok );
 587       if ( !ok ) return false;
 588       i++;
 589       chunkNext = getNextChunk( stream, start, ok );
 590       int typeuse = atoi( chunkNext.c_str() );
 591       if ( !ok ) return false;
 592       hypothesis.AddZone( chunk.c_str(), typeuse );
 593     }
 594
 595     chunk = getNextChunk( stream, start, ok );
 596     if ( !ok ) return false;
 597     size = atoi( chunk.c_str() );
 598     for ( int i = 0; i < size; i++ ) {
 599       chunk = getNextChunk( stream, start, ok );
 600       if ( !ok ) return false;
 601       hypothesis.AddComp( chunk.c_str() );
 602     }
 603
 604     chunk = getNextChunk( stream, start, ok );
 605     if ( !ok ) return false;
 606     size = atoi( chunk.c_str() );
 607     for ( int i = 0; i < size; i++ ) {
 608       chunk = getNextChunk( stream, start, ok );
 609       if ( !ok ) return false;
 610       hypothesis.AddGroup( chunk.c_str() );
 611     }
 612
 613     chunk = getNextChunk( stream, start, ok );
 614     if ( !ok ) return false;
 615     size = atoi( chunk.c_str() );
 616     for ( int i = 0; i < size; i++ ) {
 617       chunk = getNextChunk( stream, start, ok );
 618       if ( !ok ) return false;
 619       hypothesis.AddFieldInterp( chunk.c_str() );
 620     }
 621
 622     chunk = getNextChunk( stream, start, ok );
 623     if ( !ok ) return false;
 624     hypothesis.SetNivMax( atoi( chunk.c_str() ) );
 625
 626     chunk = getNextChunk( stream, start, ok );
 627     if ( !ok ) return false;
 628     hypothesis.SetDiamMin( strtod( chunk.c_str(), 0 ) );
 629
 630     chunk = getNextChunk( stream, start, ok );
 631     if ( !ok ) return false;
 632     hypothesis.SetAdapInit( strtod( chunk.c_str(), 0 ) );
 633
 634     chunk = getNextChunk( stream, start, ok );
 635     if ( !ok ) return false;
 636     hypothesis.SetLevelOutput( strtod( chunk.c_str(), 0 ) );
 637
 638     return true;
 639   }
 640
 641 //
 642 // =========
 643 // 2.4. Zone
 644 // =========
 645   /*!
 646     \brief Restore zone from the string
 647     \param zone zone being restored
 648     \param stream string representation of the zone
 649     \return \c true if zone is correctly restored or \c false otherwise
 650   */
 651   bool Restore( HOMARD_Zone& zone, const std::string& stream )
 652   {
 653     std::string::size_type start = 0;
 654     std::string chunk;
 655     bool ok;
 656     //
 657     chunk = getNextChunk( stream, start, ok );
 658     if ( !ok ) return false;
 659     zone.SetName( chunk.c_str() );
 660     //
 661     chunk = getNextChunk( stream, start, ok );
 662     if ( !ok ) return false;
 663     int ZoneType = atoi( chunk.c_str() ) ;
 664     zone.SetType( ZoneType );
 665     // Les coordonnees des zones : le nombre depend du type
 666     std::vector<double> coords;
 667     int lgcoords ;
 668     if ( ZoneType == 2 or ( ZoneType >= 11 and ZoneType <= 13 ) ) { lgcoords = 6 ; }
 669     else if ( ZoneType == 4 ) { lgcoords = 4 ; }
 670     else if ( ZoneType == 5 or ( ZoneType >= 31 and ZoneType <= 33 ) ) { lgcoords = 8 ; }
 671     else if ( ZoneType == 7 or ( ZoneType >= 61 and ZoneType <= 63 ) ) { lgcoords = 9 ; }
 672     else return false;
 673     coords.resize( lgcoords );
 674     for ( int i = 0; i < lgcoords; i++ ) {
 675       chunk = getNextChunk( stream, start, ok );
 676       if ( !ok ) return false;
 677       coords[i] = strtod( chunk.c_str(), 0 );
 678     }
 679     if ( ZoneType == 2 or ( ZoneType >= 11 and ZoneType <= 13 ) )
 680     { zone.SetBox( coords[0], coords[1], coords[2], coords[3], coords[4], coords[5] ); }
 681     else if ( ZoneType == 4 )
 682     { zone.SetSphere( coords[0], coords[1], coords[2], coords[3] ); }
 683     else if ( ZoneType == 5 or ( ZoneType >= 31 and ZoneType <= 33 ) )
 684     { zone.SetCylinder( coords[0], coords[1], coords[2], coords[3], coords[4], coords[5], coords[6], coords[7] ); }
 685     else if ( ZoneType == 7 or ( ZoneType >= 61 and ZoneType <= 63 ) )
 686     { zone.SetPipe( coords[0], coords[1], coords[2], coords[3], coords[4], coords[5], coords[6], coords[7], coords[8] ); }
 687     // Remarque : la taille de coords est suffisante pour les limites
 688     for ( int i = 0; i < 3; i++ ) {
 689       chunk = getNextChunk( stream, start, ok );
 690       if ( !ok ) return false;
 691       coords[i] = strtod( chunk.c_str(), 0 );
 692     }
 693     zone.SetLimit( coords[0], coords[1], coords[2]);
 694
 695     chunk = getNextChunk( stream, start, ok );
 696     if ( !ok ) return false;
 697     int size = atoi( chunk.c_str() );
 698     for ( int i = 0; i < size; i++ ) {
 699       chunk = getNextChunk( stream, start, ok );
 700       if ( !ok ) return false;
 701       zone.AddHypo( chunk.c_str() );
 702     }
 703     return true;
 704   }
 705
 706 //
 707 // =================================
 708 // 2.5. Restauration d'une frontiere
 709 // =================================
 710
 711   /*!
 712     \brief Restore boundary from the string
 713     \param boundary boundary being restored
 714     \param stream string representation of the boundary
 715     \return \c true if the boundary is correctly restored or \c false otherwise
 716   */
 717   bool Restore( HOMARD_Boundary& boundary, const std::string& stream )
 718   {
 719     std::string::size_type start = 0;
 720     std::string chunk;
 721     bool ok;
 722
 723     chunk = getNextChunk( stream, start, ok );
 724     if ( !ok ) return false;
 725     boundary.SetName( chunk.c_str() );
 726
 727     chunk = getNextChunk( stream, start, ok );
 728     if ( !ok ) return false;
 729     int BoundaryType = atoi( chunk.c_str() ) ;
 730     boundary.SetType( BoundaryType );
 731
 732     chunk = getNextChunk( stream, start, ok );
 733     if ( !ok ) return false;
 734     boundary.SetCaseCreation( chunk.c_str() );
 735
 736     // Si analytique, les coordonnees des frontieres : le nombre depend du type
 737     // Si discret, le maillage
 738     int lgcoords ;
 739     if ( BoundaryType == 1 ) { lgcoords = 7 ; }
 740     else if ( BoundaryType == 2 ) { lgcoords = 4 ; }
 741     else { lgcoords = 0 ; }
 742 //
 743     if ( lgcoords == 0 )
 744     {
 745       chunk = getNextChunk( stream, start, ok );
 746       if ( !ok ) return false;
 747       boundary.SetMeshName( chunk.c_str() );
 748
 749       chunk = getNextChunk( stream, start, ok );
 750       if ( !ok ) return false;
 751       boundary.SetMeshFile( chunk.c_str() );
 752     }
 753     else
 754     { std::vector<double> coords;
 755       coords.resize( lgcoords );
 756       for ( int i = 0; i < lgcoords; i++ ) {
 757         chunk = getNextChunk( stream, start, ok );
 758         if ( !ok ) return false;
 759         coords[i] = strtod( chunk.c_str(), 0 );
 760       }
 761       if ( BoundaryType == 1 )
 762       { boundary.SetCylinder(coords[0],coords[1],coords[2],coords[3],coords[4],coords[5],coords[6]); }
 763       else if ( BoundaryType == 2 )
 764       { boundary.SetSphere( coords[0], coords[1], coords[2], coords[3]); }
 765       else if ( BoundaryType == 3 )
 766       { boundary.SetConeA( coords[0], coords[1], coords[2], coords[3], coords[4], coords[5], coords[6]); }
 767       else if ( BoundaryType == 4 )
 768       { boundary.SetConeR( coords[0], coords[1], coords[2], coords[3], coords[4], coords[5], coords[6], coords[7]); }
 769       // Remarque : la taille de coords est suffisante pour les limites
 770       for ( int i = 0; i < 3; i++ ) {
 771         chunk = getNextChunk( stream, start, ok );
 772         if ( !ok ) return false;
 773         coords[i] = strtod( chunk.c_str(), 0 );
 774       }
 775       boundary.SetLimit( coords[0], coords[1], coords[2]);
 776     }
 777     // Les groupes
 778     chunk = getNextChunk( stream, start, ok );
 779     if ( !ok ) return false;
 780     int size = atoi( chunk.c_str() );
 781     for ( int i = 0; i < size; i++ ) {
 782       chunk = getNextChunk( stream, start, ok );
 783       if ( !ok ) return false;
 784       boundary.AddGroup( chunk.c_str() );
 785     }
 786
 787     return true;
 788   }
 789
 790 //
 791 // ==================================
 792 // 2.6. Restauration d'un schema YACS
 793 // ==================================
 794
 795   /*!
 796     \brief Restore a schema YACS from the string
 797     \param yacs yacs being restored
 798     \param stream string representation of the schema yacs
 799     \return \c true if yacs is correctly restored or \c false otherwise
 800   */
 801   bool Restore( HOMARD_YACS& yacs, const std::string& stream )
 802   {
 803     std::string::size_type start = 0;
 804     std::string chunk;
 805     bool ok;
 806
 807     chunk = getNextChunk( stream, start, ok );
 808     if ( !ok ) return false;
 809     yacs.SetName( chunk.c_str() );
 810
 811     chunk = getNextChunk( stream, start, ok );
 812     if ( !ok ) return false;
 813     int YACSType = atoi( chunk.c_str() ) ;
 814     yacs.SetType( YACSType );
 815
 816     return true;
 817   }
 818
 819 } // namespace HOMARD /end/