src/MEDLoader/SauvReader.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 // File      : SauvReader.cxx
  20 // Created   : Tue Aug 16 13:57:42 2011
  21 // Author    : Edward AGAPOV (eap)
  22 //
  23
  24 #include "SauvReader.hxx"
  25
  26 #include "SauvMedConvertor.hxx"
  27 #include "MEDCouplingAutoRefCountObjectPtr.hxx"
  28 #include "NormalizedUnstructuredMesh.hxx"
  29 #include "MEDCouplingRefCountObject.hxx"
  30
  31 #include <cstring>
  32 #include <sstream>
  33 #include <iostream>
  34
  35 using namespace ParaMEDMEM;
  36 using namespace SauvUtilities;
  37 using namespace std;
  38
  39 #define GIBI_EQUAL(var_str, stat_str) (strncmp (var_str, stat_str, strlen(stat_str)) == 0)
  40
  41 //================================================================================
  42 /*!
  43  * \brief Creates a reader of a given sauve file
  44  */
  45 //================================================================================
  46
  47 SauvReader* SauvReader::New(const char *fileName) throw(INTERP_KERNEL::Exception)
  48 {
  49   if ( !fileName || strlen(fileName) < 1 ) THROW_IK_EXCEPTION("Invalid file name");
  50
  51   ParaMEDMEM::MEDCouplingAutoRefCountObjectPtr< SauvUtilities::FileReader> parser;
  52
  53   // try to open as XRD
  54   parser = new XDRReader( fileName );
  55   if ( parser->open() )
  56     {
  57       SauvReader* reader = new SauvReader;
  58       reader->_fileReader = parser.retn();
  59       return reader;
  60     }
  61
  62   // try to open as ASCII
  63   parser = new ASCIIReader( fileName );
  64   if ( parser->open() )
  65     {
  66       SauvReader* reader = new SauvReader;
  67       reader->_fileReader = parser.retn();
  68       return reader;
  69     }
  70
  71   THROW_IK_EXCEPTION("Unable to open file |"<< fileName << "|");
  72 }
  73 //================================================================================
  74 /*!
  75  * \brief Destructor
  76  */
  77 //================================================================================
  78
  79 SauvReader::~SauvReader()
  80 {
  81   _fileReader->decrRef();
  82 }
  83
  84 //================================================================================
  85 /*!
  86  * \brief Return current line of ASCII file to report an error
  87  */
  88 //================================================================================
  89
  90 std::string SauvReader::lineNb() const
  91 {
  92   if ( isASCII() )
  93     return string(" (line #") + SauvUtilities::toString
  94       ( static_cast<SauvUtilities::ASCIIReader*>( _fileReader )->lineNb() ) + ")";
  95
  96   return "";
  97 }
  98
  99 //================================================================================
 100 /*!
 101  * \brief Reads contents of the sauve file and convert it to MEDFileData
 102  */
 103 //================================================================================
 104
 105 ParaMEDMEM::MEDFileData * SauvReader::loadInMEDFileDS() throw(INTERP_KERNEL::Exception)
 106 {
 107   SauvUtilities::IntermediateMED iMed; // intermadiate DS
 108   _iMed = &iMed;
 109
 110   char* line; // a current line
 111   const char* enregistrement_type=" ENREGISTREMENT DE TYPE";
 112
 113   while ( getNextLine(line, /*raiseOEF=*/false)) // external loop looking for "ENREGISTREMENT DE TYPE"
 114     {
 115       if ( isASCII() && !GIBI_EQUAL( line, enregistrement_type ))
 116         continue; // "ENREGISTREMENT DE TYPE" not found -> read the next line
 117
 118       // read the number of a record
 119       int recordNumber;
 120       if ( isASCII() )
 121         recordNumber = atoi( line + strlen(enregistrement_type) + 1 );
 122       else
 123         recordNumber = getInt();
 124
 125       // read the record
 126       if ( recordNumber == 2 )
 127         readRecord2();
 128       else if (recordNumber == 4 )
 129         readRecord4();
 130       else if (recordNumber == 7 )
 131         readRecord7();
 132       else if (recordNumber == 5 )
 133         break; // stop reading
 134       else
 135         if ( !isASCII() )
 136           THROW_IK_EXCEPTION("XDR : ENREGISTREMENT DE TYPE " << recordNumber << " not implemented!!!");
 137     }
 138
 139   ParaMEDMEM::MEDFileData* medFileData = iMed.convertInMEDFileDS();
 140
 141   return medFileData;
 142 }
 143
 144 //================================================================================
 145 /*!
 146  * \brief Reads "ENREGISTREMENT DE TYPE 4"
 147  */
 148 //================================================================================
 149
 150 void SauvReader::readRecord4()
 151 {
 152   if ( !isASCII() )
 153     {
 154       getInt(); // skip NIVEAU
 155       getInt(); // skip ERREUR
 156       _iMed->_spaceDim = getInt();
 157       getFloat(); // skip DENSITE
 158     }
 159   else
 160     {
 161       char* line;
 162       getNextLine(line);
 163       const char* s = " NIVEAU  15 NIVEAU ERREUR   0 DIMENSION";
 164       _iMed->_spaceDim = atoi( line + strlen( s ) + 1 );
 165       if ( !GIBI_EQUAL( line, " NIVEAU" ))
 166         THROW_IK_EXCEPTION( "Could not read space dimension" << lineNb() );
 167       }
 168   if ( _iMed->_spaceDim < 1 )
 169     THROW_IK_EXCEPTION( "Invalid space dimension:" << _iMed->_spaceDim );
 170 }
 171
 172 //================================================================================
 173 /*!
 174  * \brief Reads "ENREGISTREMENT DE TYPE 7"
 175  */
 176 //================================================================================
 177
 178 void SauvReader::readRecord7()
 179 {
 180   if ( !isASCII() )
 181     {
 182       getInt(); // skip NOMBRE INFO CASTEM2000
 183       getInt(); // skip IFOUR
 184       getInt(); // skip NIFOUR
 185       getInt(); // skip IFOMOD
 186       getInt(); // skip IECHO
 187       getInt(); // skip IIMPI
 188       getInt(); // skip IOSPI
 189       getInt(); // skip ISOTYP
 190       getInt(); // skip NSDPGE
 191     }
 192   else
 193     {
 194       // skip 3 lines:
 195       // NOMBRE INFO CASTEM2000   8
 196       // IFOUR   2 NIFOUR   0 IFOMOD   2 IECHO   1 IIMPI   0 IOSPI   0 ISOTYP   1
 197       // NSDPGE     0
 198       char* line;
 199       getNextLine(line);
 200       getNextLine(line);
 201       getNextLine(line);
 202     }
 203 }
 204
 205 //================================================================================
 206 /*!
 207  * \brief Reads the pile number, nb of objects and nb named of objects
 208  */
 209 //================================================================================
 210
 211 int SauvReader::readPileNumber(int& nbNamedObjects, int& nbObjects)
 212 {
 213   // FORMAT(' PILE NUMERO',I4,'NBRE ObjectS NOMMES',I8,'NBRE ObjectS',I8)
 214   int pileNumber;
 215   if ( !isASCII() )
 216     {
 217       initIntReading(3);
 218       pileNumber     = getInt(); next();
 219       nbNamedObjects = getInt(); next();
 220       nbObjects      = getInt(); next();
 221     }
 222   else
 223     {
 224       char* line;
 225       getNextLine(line);
 226       const char *s1 = " PILE NUMERO", *s2 = "NBRE ObjectS NOMMES", *s3 = "NBRE ObjectS";
 227       if ( ! GIBI_EQUAL( line, s1 ) )
 228         THROW_IK_EXCEPTION("Could not read the pile number " << lineNb() );
 229       line           = line + strlen(s1);
 230       pileNumber     = atoi( line );
 231       line           = line + 4 + strlen(s2);
 232       nbNamedObjects = atoi( line );
 233       line           = line + 8 + strlen(s3);
 234       nbObjects      = atoi( line );
 235     }
 236   if ( nbNamedObjects<0 )
 237     THROW_IK_EXCEPTION("Invalid nb of named objects: " << nbNamedObjects  << lineNb() );
 238   if ( nbObjects<0)
 239     THROW_IK_EXCEPTION("Invalid nb of objects: " << nbObjects  << lineNb() );
 240   // It appears to be a valid case
 241   // if ( nbObjects<nbNamedObjects)
 242   //   THROW_IK_EXCEPTION("In PILE " << pileNumber <<
 243   //                      " nb of objects is less than nb of named objects"  << lineNb() );
 244   return pileNumber;
 245 }
 246
 247 //================================================================================
 248 /*!
 249  * \brief Reads "ENREGISTREMENT DE TYPE 2"
 250  */
 251 //================================================================================
 252
 253 void SauvReader::readRecord2()
 254 {
 255   if ( _iMed->_spaceDim == 0 )
 256     THROW_IK_EXCEPTION("Missing ENREGISTREMENT DE TYPE   4");
 257
 258   // read a pile number
 259   int pileNumber, nbNamedObjects, nbObjects;
 260   pileNumber = readPileNumber(nbNamedObjects, nbObjects);
 261
 262   if ( !_encounteredPiles.insert( pileNumber ).second && // piles may repeat
 263        isASCII())
 264     return;
 265
 266   // read object names and their indices
 267   vector<string> objectNames(nbNamedObjects);
 268   for ( initNameReading( nbNamedObjects ); more(); next() )
 269     objectNames[ index() ] = getName();
 270
 271   vector<int> nameIndices(nbNamedObjects);
 272   for ( initIntReading( nbNamedObjects ); more(); next() )
 273     nameIndices[ index() ] = getInt();
 274
 275   switch ( pileNumber )
 276     {
 277     case PILE_SOUS_MAILLAGE:
 278       read_PILE_SOUS_MAILLAGE(nbObjects, objectNames, nameIndices);
 279       break;
 280     case PILE_NODES_FIELD:
 281       read_PILE_NODES_FIELD(nbObjects, objectNames, nameIndices);
 282       break;
 283     case PILE_TABLES:
 284       read_PILE_TABLES(nbObjects, objectNames, nameIndices);
 285       break;
 286     case PILE_LREEL:
 287       read_PILE_LREEL(nbObjects, objectNames, nameIndices);
 288       break;
 289     case PILE_LOGIQUES:
 290       read_PILE_LOGIQUES(nbObjects, objectNames, nameIndices);
 291       break;
 292     case PILE_FLOATS:
 293       read_PILE_FLOATS(nbObjects, objectNames, nameIndices);
 294       break;
 295     case PILE_INTEGERS:
 296       read_PILE_INTEGERS(nbObjects, objectNames, nameIndices);
 297       break;
 298     case PILE_STRINGS:
 299       read_PILE_STRINGS(nbObjects, objectNames, nameIndices);
 300       break;
 301     case PILE_LMOTS:
 302       read_PILE_LMOTS(nbObjects, objectNames, nameIndices);
 303       break;
 304     case PILE_NOEUDS:
 305       read_PILE_NOEUDS(nbObjects, objectNames, nameIndices);
 306       break;
 307     case PILE_COORDONNEES:
 308       read_PILE_COORDONNEES(nbObjects, objectNames, nameIndices);
 309       break;
 310     case PILE_MODL:
 311       read_PILE_MODL(nbObjects, objectNames, nameIndices);
 312       break;
 313     case PILE_FIELD:
 314       read_PILE_FIELD(nbObjects, objectNames, nameIndices);
 315       break;
 316     default:
 317       if ( !isASCII() )
 318         THROW_IK_EXCEPTION("XDR : reading PILE " << pileNumber << " not implemented !!!");
 319     }
 320 }
 321
 322 //================================================================================
 323 /*!
 324  * \brief Reads "PILE NUMERO   1": gibi sub-meshes that are converted into med groups
 325  */
 326 //================================================================================
 327
 328 void SauvReader::read_PILE_SOUS_MAILLAGE(const int                 nbObjects,
 329                                          std::vector<std::string>& objectNames,
 330                                          std::vector<int>&         nameIndices)
 331 {
 332   _iMed->_groups.reserve(nbObjects*2); // fields may add some groups
 333
 334   char* line;
 335   map<int,int> strangeGroupType;
 336   int i;
 337
 338   for (int object=0; object!=nbObjects; ++object) // loop on sub-groups
 339     {
 340       initIntReading( 5 );
 341       int castemCellType = getIntNext();
 342       int nbSubGroups    = getIntNext();
 343       int nbReferences   = getIntNext();
 344       int nbNodesPerElem = getIntNext();
 345       int nbElements     = getIntNext();
 346
 347       _iMed->_groups.push_back(Group());
 348       SauvUtilities::Group & group = _iMed->_groups.back();
 349
 350       // Issue 0021311. Allocate places for names of referring groups
 351       // that will be possibly filled after reading long names from
 352       // PILE_TABLES and PILE_STRINGS
 353       group._refNames.resize( nbReferences );
 354
 355       // castemCellType=0 corresponds to a sub-mesh composed of other sub-meshes
 356       if (castemCellType==0 && nbSubGroups>0)
 357         {
 358           group._groups.resize( nbSubGroups );
 359           for ( initIntReading( nbSubGroups ); more(); next() )
 360             group._groups[ index() ] = & _iMed->_groups[ getInt() - 1 ];
 361           //std::sort( group._groups.begin(), group._groups.end() ); // for _groups comparison in getFieldSupport()
 362         }
 363       // skip references
 364       if ( isASCII() )
 365         for ( i = 0; i < nbReferences; i += 10 ) // FORMAT(10I8)
 366           getNextLine(line);
 367       else
 368         for (initIntReading(nbReferences); more(); next());
 369
 370       // skip colors
 371       if ( isASCII() )
 372         for ( i = 0; i < nbElements; i += 10 )
 373           getNextLine(line);
 374       else
 375         for (initIntReading(nbElements); more(); next());
 376
 377       // not a composit group
 378       if (castemCellType>0 && nbSubGroups==0)
 379         {
 380           group._cellType = SauvUtilities::gibi2medGeom(castemCellType);
 381
 382           initIntReading( nbElements * nbNodesPerElem );
 383           if ( group._cellType == INTERP_KERNEL::NORM_ERROR ) // look for group end
 384             {
 385               for ( ; more();  next());
 386               strangeGroupType.insert( make_pair( object, castemCellType ));
 387             }
 388           else
 389             {
 390               // if ( group._cellType == MED_POINT1 ) group._cellType = NORM_ERROR; // issue 21199
 391
 392               // read connectivity of elements of a group
 393               SauvUtilities::Cell ma( nbNodesPerElem );
 394               SauvUtilities::Node* pNode;
 395               group._cells.resize( nbElements );
 396               for ( i = 0; i < nbElements; ++i )
 397                 {
 398                   ma.init();
 399                   for ( int n = 0; n < nbNodesPerElem; ++n )
 400                     {
 401                       int nodeID = getIntNext();
 402                       pNode = _iMed->getNode( nodeID );
 403                       ma._nodes[n] = pNode;
 404                       _iMed->_nbNodes += ( !pNode->isUsed() );
 405                       pNode->_number = nodeID;
 406                     }
 407                   ma._number = _iMed->getNbCellsOfType( group._cellType ) + 1;
 408                   group._cells[i] = _iMed->insert( group._cellType, ma );
 409                 }
 410             }
 411         }
 412     } // loop on groups
 413
 414   // set group names
 415   for (i=0; i!=(int)objectNames.size(); ++i)
 416     {
 417       int grpID = nameIndices[i];
 418       SauvUtilities::Group & grp = _iMed->_groups[ grpID-1 ];
 419       if ( !grp._name.empty() ) // a group has several names
 420         { // create a group with subgroup grp and named grp.name
 421           _iMed->_groups.push_back(Group());
 422           _iMed->_groups.back()._groups.push_back( &_iMed->_groups[ grpID-1 ]);
 423           _iMed->_groups.back()._name = grp._name;
 424         }
 425       grp._name=objectNames[i];
 426 #ifdef _DEBUG
 427       map<int,int>::iterator it = strangeGroupType.find( grpID - 1 );
 428       if ( it != strangeGroupType.end() )
 429         cout << "Skip " << grp._name << " of not supported CASTEM type: " << it->second << endl;
 430 #endif
 431     }
 432 } // read_PILE_SOUS_MAILLAGE()
 433
 434 //================================================================================
 435 /*!
 436  * \brief Skip "PILE NUMERO  18" of XDR file
 437  */
 438 //================================================================================
 439
 440 void SauvReader::read_PILE_LREEL (const int nbObjects, std::vector<std::string>&, std::vector<int>&)
 441 {
 442   if ( isXRD() )
 443     {
 444       for (int object=0; object!=nbObjects; ++object) // pour chaque Group
 445         {
 446           initIntReading(1);
 447           int nb_vals = getIntNext();
 448           initDoubleReading(nb_vals);
 449           for(int i=0; i<nb_vals; i++) next();
 450         }
 451     }
 452 }
 453
 454 //================================================================================
 455 /*!
 456  * \brief Skip "PILE NUMERO  24" of XDR file
 457  */
 458 //================================================================================
 459
 460 void SauvReader::read_PILE_LOGIQUES (const int, std::vector<std::string>&, std::vector<int>&)
 461 {
 462   if ( isXRD() )
 463     {
 464       initIntReading(1);
 465       int nb_vals = getIntNext();
 466       initIntReading(nb_vals);
 467       for(int i=0; i<nb_vals; i++) next();
 468     }
 469 }
 470
 471 //================================================================================
 472 /*!
 473  * \brief Skip "PILE NUMERO  25" of XDR file
 474  */
 475 //================================================================================
 476
 477 void SauvReader::read_PILE_FLOATS (const int, std::vector<std::string>&, std::vector<int>&)
 478 {
 479   if ( isXRD() )
 480     {
 481       initIntReading(1);
 482       int nb_vals = getIntNext();
 483       initDoubleReading(nb_vals);
 484       for(int i=0; i<nb_vals; i++) next();
 485     }
 486 }
 487
 488 //================================================================================
 489 /*!
 490  * \brief Skip "PILE NUMERO  26" of XDR file
 491  */
 492 //================================================================================
 493
 494 void SauvReader::read_PILE_INTEGERS (const int, std::vector<std::string>&, std::vector<int>&)
 495 {
 496   if ( isXRD() )
 497     {
 498       initIntReading(1);
 499       int nb_vals = getIntNext();
 500       initIntReading(nb_vals);
 501       for(int i=0; i<nb_vals; i++) next();
 502     }
 503 }
 504
 505 //================================================================================
 506 /*!
 507  * \brief Skip "PILE NUMERO  29" of XDR file
 508  */
 509 //================================================================================
 510
 511 void SauvReader::read_PILE_LMOTS (const int nbObjects, std::vector<std::string>&, std::vector<int>&)
 512 {
 513   if ( isXRD() )
 514     {
 515       for (int object=0; object!=nbObjects; ++object) // pour chaque Group
 516         {
 517           initIntReading(2);
 518           int len = getIntNext();
 519           int nb_vals = getIntNext();
 520           int nb_char = len*nb_vals;
 521           int nb_char_tmp = 0;
 522           int fixed_length = 71;
 523           while (nb_char_tmp < nb_char)
 524             {
 525               int remain_len = nb_char - nb_char_tmp;
 526               int width;
 527               if ( remain_len > fixed_length )
 528                 {
 529                   width = fixed_length;
 530                 }
 531               else
 532                 {
 533                   width = remain_len;
 534                 }
 535               initNameReading(1, width);
 536               next();
 537               nb_char_tmp += width;
 538             }
 539         }
 540     }
 541 }
 542
 543 //================================================================================
 544 /*!
 545  * \brief Skip "PILE NUMERO  38" of XDR file
 546  */
 547 //================================================================================
 548
 549 void SauvReader::read_PILE_MODL (const int nbObjects, std::vector<std::string>&, std::vector<int>&)
 550 {
 551   if ( isXRD() )
 552     {
 553       for (int object=0; object!=nbObjects; ++object) // pour chaque Group
 554         {
 555           // see wrmodl.eso
 556           initIntReading(10);
 557           int n1  = getIntNext();
 558           int nm2 = getIntNext();
 559           int nm3 = getIntNext();
 560           int nm4 = getIntNext();
 561           int nm5 = getIntNext();
 562           int n45 = getIntNext();
 563           /*int nm6 =*/ getIntNext();
 564           /*int nm7 =*/ getIntNext();
 565           next();
 566           next();
 567           int nm1 = n1 * n45;
 568           int nm9 = n1 * 16;
 569           for (initIntReading(nm1); more(); next());
 570           for (initIntReading(nm9); more(); next());
 571           for (initNameReading(nm5, 8); more(); next());
 572           for (initNameReading(nm2, 8); more(); next());
 573           for (initNameReading(nm3, 8); more(); next());
 574           for (initIntReading(nm4); more(); next());
 575         }
 576     }
 577 } // Fin case pile 38
 578
 579 //================================================================================
 580 /*!
 581  * \brief Read "PILE NUMERO  32": links to node coordinates
 582  */
 583 //================================================================================
 584
 585 void SauvReader::read_PILE_NOEUDS (const int nbObjects, std::vector<std::string>&, std::vector<int>&)
 586 {
 587   initIntReading(1);
 588   int nb_indices = getIntNext();
 589
 590   if (nb_indices != nbObjects)
 591     THROW_IK_EXCEPTION("Error of reading PILE NUMERO  " << PILE_NOEUDS << lineNb() );
 592
 593   for ( initIntReading( nbObjects ); more(); next() )
 594     {
 595       int coordID = getInt();
 596       _iMed->getNode( index()+1 )->_coordID = coordID;
 597     }
 598 }
 599
 600 //================================================================================
 601 /*!
 602  * \brief Read "PILE NUMERO  33": node coordinates
 603  */
 604 //================================================================================
 605
 606 void SauvReader::read_PILE_COORDONNEES (const int nbObjects, std::vector<std::string>&, std::vector<int>&)
 607 {
 608   initIntReading(1);
 609   int nbReals = getIntNext();
 610
 611   if ( nbReals < (int)(_iMed->_nbNodes*(_iMed->_spaceDim+1)) )
 612     THROW_IK_EXCEPTION("Error of reading PILE NUMERO  " << PILE_COORDONNEES << lineNb() );
 613
 614   // there are coordinates + density for each node
 615   _iMed->_coords.resize( nbReals - nbReals/(_iMed->_spaceDim+1));
 616   double* coordPtr = &_iMed->_coords[0];
 617
 618   initDoubleReading( nbReals );
 619   while ( more() )
 620     {
 621       for (unsigned j = 0; j < _iMed->_spaceDim; ++j, next())
 622         *coordPtr++ = getDouble();
 623       // skip density
 624       getDouble();
 625       next();
 626     }
 627 }
 628
 629 //================================================================================
 630 /*!
 631  * \brief Finds or create a Group equal to a given field support
 632  */
 633 //================================================================================
 634
 635 SauvUtilities::Group* SauvReader::getFieldSupport(const vector<SauvUtilities::Group*>& supports)
 636 {
 637   SauvUtilities::Group* group = NULL;
 638   set<SauvUtilities::Group*> sup_set( supports.begin(), supports.end() );
 639   if (sup_set.size() == 1 ) // one or equal supports
 640     {
 641       group = supports[0];
 642     }
 643   else
 644     {
 645       // try to find an existing composite group with the same sub-groups
 646       for ( size_t i = 0; i < _iMed->_groups.size() && !group; ++i )
 647         {
 648           Group & grp = _iMed->_groups[i];
 649           if (sup_set.size() == grp._groups.size())
 650             {
 651               bool sameOrder = true;
 652               for ( size_t j = 0; j < supports.size() && sameOrder; ++j )
 653                 sameOrder = ( supports[j] == grp._groups[ j % grp._groups.size() ]);
 654               if ( sameOrder )
 655                 group = & _iMed->_groups[i];
 656             }
 657         }
 658       if ( !group ) // no such a group, add a new one
 659         {
 660           vector<SauvUtilities::Group*> newGroups( supports.begin(),
 661                                                    supports.begin() + sup_set.size() );
 662           // check if supports includes newGroups in the same order
 663           bool sameOrder = true;
 664           for ( size_t j = newGroups.size(); j < supports.size() && sameOrder; ++j )
 665             sameOrder = ( supports[j] == newGroups[ j % newGroups.size() ]);
 666           if ( sameOrder )
 667             {
 668               _iMed->_groups.push_back( SauvUtilities::Group() );
 669               group = & _iMed->_groups.back();
 670               group->_groups.swap( newGroups );
 671             }
 672         }
 673     }
 674   if ( group )
 675     group->_isProfile = true;
 676   return group;
 677 }
 678
 679 //================================================================================
 680 /*!
 681  * \brief set field names
 682  */
 683 //================================================================================
 684
 685 void SauvReader::setFieldNames(const vector<SauvUtilities::DoubleField* >& fields,
 686                                const vector<string>&                       objets_nommes,
 687                                const vector<int>&                          indices_objets_nommes)
 688 {
 689   unsigned i;
 690   for ( i = 0; i < indices_objets_nommes.size(); ++i )
 691     {
 692       int fieldIndex = indices_objets_nommes[ i ];
 693       if ( fields[ fieldIndex - 1 ] )
 694         fields[ fieldIndex - 1 ]->_name = objets_nommes[ i ];
 695     }
 696 }
 697
 698 //================================================================================
 699 /*!
 700  * \brief Read "PILE NUMERO   2": NODE FIELDS
 701  */
 702 //================================================================================
 703
 704 void SauvReader::read_PILE_NODES_FIELD (const int                 nbObjects,
 705                                         std::vector<std::string>& objectNames,
 706                                         std::vector<int>&         nameIndices)
 707 {
 708   _iMed->_nodeFields.resize( nbObjects, (SauvUtilities::DoubleField*) 0 );
 709   for (int object=0; object!=nbObjects; ++object) // loop on fields
 710     {
 711       // EXAMPLE ( with no values )
 712
 713       // (1)       4       7       2       1
 714       // (2)     -88       0       3     -89       0       1     -90       0       2     -91
 715       // (2)       0       1
 716       // (3) FX   FY   FZ   FZ   FX   FY   FLX
 717       // (4)       0       0       0       0       0       0       0
 718       // (5)           cree  par  muc pri
 719       // (6)
 720       // (7)       2
 721
 722       // (1): nb subcomponents, nb components(total), IFOUR, nb attributes
 723       int nb_sub, total_nb_comp, nb_attr;
 724       int i_sub, i_comp;
 725       initIntReading( 4 );
 726       nb_sub        = getIntNext();
 727       total_nb_comp = getIntNext();
 728       next(); // ignore IFOUR
 729       nb_attr       = getIntNext();
 730       if ( nb_sub < 0 || total_nb_comp < 0 || nb_attr < 0 )
 731         THROW_IK_EXCEPTION("Error of field reading " << lineNb());
 732
 733       // (2) loop on subcomponents of a field, for each read
 734       // (a) support, (b) number of values and (c) number of components
 735       vector<Group*> supports( nb_sub );
 736       vector<int> nb_values  ( nb_sub );
 737       vector<int> nb_comps   ( nb_sub );
 738       int total_nb_values = 0;
 739       initIntReading( nb_sub * 3 );
 740       for ( i_sub = 0; i_sub < nb_sub; ++i_sub )
 741         {
 742           int supId = -getIntNext(); // (a) reference to support
 743           if ( supId < 1 || supId > (int)_iMed->_groups.size() )
 744             THROW_IK_EXCEPTION("Wrong mesh reference: "<< supId << lineNb() );
 745           supports[ i_sub ] = &_iMed->_groups[ supId-1 ]; // (a) reference to support
 746
 747           nb_values[ i_sub ] = getIntNext();    // (b) nb points
 748           total_nb_values += nb_values[ i_sub ];
 749           if ( nb_values[ i_sub ] < 0 )
 750             THROW_IK_EXCEPTION(" Wrong nb of points: " << nb_values[ i_sub ]  << lineNb() );
 751           nb_comps[ i_sub ] = getInt(); next();     // (c) nb of components in i_sub
 752         }
 753
 754       // create a field if there are values
 755       SauvUtilities::DoubleField* fdouble = 0;
 756       if ( total_nb_values > 0 )
 757         fdouble = new DoubleField( nb_sub, total_nb_comp );
 758       _iMed->_nodeFields[ object ] = fdouble;
 759
 760       // (3) component names
 761       initNameReading( total_nb_comp, 4 );
 762       for ( i_sub = 0; i_sub < nb_sub; ++i_sub )
 763         {
 764           // store support id and nb components of a sub
 765           if ( fdouble )
 766             fdouble->_sub[ i_sub ].setData( nb_comps[ i_sub ], supports[ i_sub ] );
 767           for ( i_comp = 0; i_comp < nb_comps[ i_sub ]; ++i_comp, next() )
 768             {
 769               // store component name
 770               string compName = getName();
 771               if ( fdouble )
 772                 fdouble->_sub[ i_sub ].compName( i_comp ) = compName;
 773             }
 774         }
 775       // (4) nb harmonics ( ignored )
 776       for ( initIntReading( total_nb_comp ); more(); next() );
 777       // (5) TYPE ( ignored )
 778       for (initNameReading(1, /*length=*/71); more(); next());
 779       // (6) TITRE ( ignored )
 780       for (initNameReading(1, /*length=*/71); more(); next());
 781       // (7) attributes ( ignored )
 782       for ( initIntReading( nb_attr ); more(); next() );
 783
 784       for ( i_sub = 0; i_sub < nb_sub; ++i_sub )
 785         {
 786           // loop on components: read values
 787           initDoubleReading( nb_values[ i_sub ] * nb_comps[ i_sub ] );
 788           for ( i_comp = 0; i_comp < nb_comps[ i_sub ]; ++i_comp )
 789             {
 790               if ( fdouble )
 791                 {
 792                   vector<double>& vals = fdouble->addComponent( nb_values[ i_sub ] );
 793                   for ( int i = 0; more() && i < nb_values[ i_sub ]; next(), ++i )
 794                     vals[ i ] = getDouble();
 795                 }
 796               else
 797                 {
 798                   for ( int i = 0; i < nb_values[ i_sub ]; next(), ++i );
 799                 }
 800             }
 801         } // loop on subcomponents of a field
 802
 803       // set a supporting group including all subs supports but only
 804       // if all subs have the same components
 805       if ( fdouble && fdouble->hasSameComponentsBySupport() )
 806         fdouble->_group = getFieldSupport( supports );
 807       else
 808         for ( i_sub = 0; i_sub < nb_sub; ++i_sub )
 809           fdouble->_sub[ i_sub ]._support->_isProfile = true;
 810
 811     } // end loop on field objects
 812
 813   // set field names
 814   setFieldNames( _iMed->_nodeFields, objectNames, nameIndices );
 815
 816 }  // read_PILE_NODES_FIELD()
 817
 818 //================================================================================
 819 /*!
 820  * \brief Read "PILE NUMERO  39": FIELDS
 821  */
 822 //================================================================================
 823
 824 void SauvReader::read_PILE_FIELD (const int                 nbObjects,
 825                                   std::vector<std::string>& objectNames,
 826                                   std::vector<int>&         nameIndices)
 827 {
 828   // REAL EXAMPLE
 829
 830   // (1)        1       2       6      16
 831   // (2)                                                         CARACTERISTIQUES
 832   // (3)      -15  317773       4       0       0       0      -2       0       3
 833   // (4)             317581
 834   // (5)  0
 835   // (6)   317767  317761  317755  317815
 836   // (7)  YOUN     NU       H        SIGY
 837   // (8)  REAL*8            REAL*8            REAL*8            REAL*8
 838   // (9)        1       1       0       0
 839   // (10)  2.00000000000000E+05
 840   // (11)       1       1       0       0
 841   // (12)  3.30000000000000E-01
 842   // (13)       1       1       0       0
 843   // (14)  1.00000000000000E+04
 844   // (15)       6     706       0       0
 845   // (16)  1.00000000000000E+02  1.00000000000000E+02  1.00000000000000E+02
 846   // (17)  1.00000000000000E+02  1.00000000000000E+02  1.00000000000000E+02
 847   // (18)  ...
 848
 849   _iMed->_cellFields.resize( nbObjects, (SauvUtilities::DoubleField*) 0 );
 850   for (int object=0; object!=nbObjects; ++object) // pour chaque field
 851     {
 852       initIntReading( 4 );
 853       int i_sub, nb_sub = getIntNext(); // (1) <nb_sub> 2 6 <title length>
 854       next(); // skip "2"
 855       next(); // skip "6"
 856       int title_length = getIntNext(); // <title length>
 857       if ( nb_sub < 1 )
 858         THROW_IK_EXCEPTION("Error of field reading: wrong nb of subcomponents " << nb_sub << lineNb() );
 859
 860       string description;
 861       if ( title_length )
 862         {
 863           if ( isXRD() )
 864             {
 865               initNameReading(1, title_length);
 866               description = getName();
 867               next();
 868             }
 869           else
 870             {
 871               char* line;
 872               getNextLine( line ); // (2) title
 873               const int len = 72; // line length
 874               description = string(line + len - title_length, title_length); // title is right justified
 875             }
 876         }
 877       // look for a line starting with '-' : <reference to support>
 878       if ( isXRD() )
 879         {
 880           initIntReading( nb_sub * 9 );
 881         }
 882       else
 883         {
 884           do {
 885             initIntReading( nb_sub * 9 );
 886           } while ( getInt() >= 0 );
 887         }
 888       int total_nb_comp = 0;
 889       vector<Group*> supports( nb_sub );
 890       vector<int>     nb_comp( nb_sub );
 891       for ( i_sub = 0; i_sub < nb_sub; ++i_sub )
 892         {                                    // (3)
 893           int supportId     = -getIntNext(); // <reference to support>
 894           next();                            // ignore <address>
 895           nb_comp [ i_sub ] =  getIntNext(); // <nb of components in the sub>
 896           for ( int i = 0; i < 6; ++i ) next();  // ignore 6 ints, in example "0 0 0 -2 0 3"
 897
 898           if ( supportId < 1 || supportId > (int)_iMed->_groups.size() )
 899             THROW_IK_EXCEPTION("Error of field reading: wrong mesh reference "<< supportId << lineNb() );
 900           if ( nb_comp[ i_sub ] < 0 )
 901             THROW_IK_EXCEPTION("Error of field reading: wrong nb of components " <<nb_comp[ i_sub ] << lineNb() );
 902
 903           supports[ i_sub ] = &_iMed->_groups[ supportId-1 ];
 904           total_nb_comp += nb_comp[ i_sub ];
 905         }
 906       // (4) dummy strings
 907       for ( initNameReading( nb_sub, 17 ); more(); next() );
 908       // (5) dummy strings
 909       for ( initNameReading( nb_sub ); more(); next() );
 910
 911       // loop on subcomponents of a field, each of which refers to
 912       // a certain support and has its own number of components;
 913       // read component values
 914       SauvUtilities::DoubleField* fdouble = 0;
 915       for ( i_sub = 0; i_sub < nb_sub; ++ i_sub )
 916         {
 917           vector<string> comp_names( nb_comp[ i_sub ]), comp_type( nb_comp[ i_sub ]);
 918           // (6) nb_comp addresses of MELVAL structure
 919           for ( initIntReading( nb_comp[ i_sub ] ); more(); next() );
 920           // (7) component names
 921           for ( initNameReading( nb_comp[ i_sub ] ); more(); next() )
 922             comp_names[ index() ] = getName();
 923           // (8) component type
 924           for ( initNameReading( nb_comp[ i_sub ], 17 ); more(); next() ) // 17 is name width
 925             {
 926               comp_type[ index() ] = getName();
 927               // component types must be the same
 928               if ( index() > 0 && comp_type[ index() ] != comp_type[ index() - 1] )
 929                 THROW_IK_EXCEPTION( "Error of field reading: diff component types <"
 930                                     << comp_type[ index() ] << "> != <" << comp_type[ index() - 1 ]
 931                                     << ">" << lineNb() );
 932             }
 933           // now type is known, create a field, one for all subs
 934           bool isReal = (nb_comp[i_sub] > 0) ? (comp_type[0] == "REAL*8") : true;
 935           if ( !fdouble && total_nb_comp )
 936             {
 937               if ( !isReal )
 938                 cout << "Warning: read NOT REAL field, type <" << comp_type[0] << ">" << lineNb() << endl;
 939               _iMed->_cellFields[ object ] = fdouble = new SauvUtilities::DoubleField( nb_sub, total_nb_comp );
 940               fdouble->_description = description;
 941             }
 942           // store support id and nb components of a sub
 943           if ( fdouble )
 944             fdouble->_sub[ i_sub ].setData( nb_comp[ i_sub ], supports[ i_sub ]);
 945           // loop on components: read values
 946           for ( int i_comp = 0; i_comp < nb_comp[ i_sub ]; ++i_comp )
 947             {
 948               // (9) nb of values
 949               initIntReading( 4 );
 950               int nb_val_by_elem = getIntNext();
 951               int nb_values      = getIntNext();
 952               next();
 953               next();
 954               fdouble->_sub[ i_sub ]._nb_gauss[ i_comp ] = nb_val_by_elem;
 955
 956               // (10) values
 957               nb_values *= nb_val_by_elem;
 958               if ( fdouble )
 959                 {
 960                   vector<double> & vals = fdouble->addComponent( nb_values );
 961                   for ( isReal ? initDoubleReading( nb_values ) : initIntReading( nb_values ); more(); next())
 962                     vals[ index() ] = getDouble();
 963                   // store component name
 964                   fdouble->_sub[ i_sub ].compName( i_comp ) = comp_names[ i_comp ];
 965                 }
 966               else
 967                 {
 968                   for ( isReal ? initDoubleReading( nb_values ) : initIntReading( nb_values ); more(); next() ) ;
 969                 }
 970             }
 971         } // loop on subcomponents of a field
 972
 973       // set id of a group including all sub supports but only
 974       // if all subs have the same nb of components
 975       if ( fdouble && fdouble->hasSameComponentsBySupport() )
 976         fdouble->_group = getFieldSupport( supports );
 977       else
 978         for ( i_sub = 0; i_sub < nb_sub; ++i_sub )
 979           fdouble->_sub[ i_sub ]._support->_isProfile = true;
 980
 981     } // end loop on field objects
 982
 983   // set field names
 984   setFieldNames( _iMed->_cellFields, objectNames, nameIndices );
 985
 986 } // read_PILE_FIELD()
 987
 988 //================================================================================
 989 /*!
 990  * \brief Read "PILE NUMERO  10": TABLES
 991  */
 992 //================================================================================
 993
 994 void SauvReader::read_PILE_TABLES (const int                 nbObjects,
 995                                    std::vector<std::string>& objectNames,
 996                                    std::vector<int>&         nameIndices)
 997 {
 998   // IMP 0020434: mapping GIBI names to MED names
 999
1000   string table_med_mail = "MED_MAIL";
1001   string table_med_cham = "MED_CHAM";
1002   string table_med_comp = "MED_COMP";
1003   int table_med_mail_id = -1;
1004   int table_med_cham_id = -1;
1005   int table_med_comp_id = -1;
1006   for (size_t iname = 0; iname < objectNames.size(); iname++)
1007     if      (objectNames[iname] == table_med_mail) table_med_mail_id = nameIndices[iname];
1008     else if (objectNames[iname] == table_med_cham) table_med_cham_id = nameIndices[iname];
1009     else if (objectNames[iname] == table_med_comp) table_med_comp_id = nameIndices[iname];
1010
1011   if ( isASCII() )
1012     if (table_med_mail_id < 0 && table_med_cham_id < 0 && table_med_comp_id < 0)
1013       return;
1014
1015   for (int itable = 1; itable <= nbObjects; itable++)
1016     {
1017       // read tables "MED_MAIL", "MED_CHAM" and "MED_COMP", that keeps correspondence
1018       // between GIBI names (8 symbols if any) and MED names (possibly longer)
1019       initIntReading(1);
1020       int nb_table_vals = getIntNext();
1021       if (nb_table_vals < 0)
1022         THROW_IK_EXCEPTION("Error of reading PILE NUMERO  10" << lineNb() );
1023
1024       int name_i_med_pile;
1025       initIntReading(nb_table_vals);
1026       for (int i = 0; i < nb_table_vals/4; i++)
1027         {
1028           if (itable == table_med_mail_id ||
1029               itable == table_med_cham_id ||
1030               itable == table_med_comp_id)
1031             {
1032               nameGIBItoMED name_i;
1033               name_i_med_pile  = getIntNext();
1034               name_i.med_id    = getIntNext();
1035               name_i.gibi_pile = getIntNext();
1036               name_i.gibi_id   = getIntNext();
1037
1038               if (name_i_med_pile != PILE_STRINGS)
1039                 {
1040                   // error: med(long) names are always kept in PILE_STRINGS
1041                 }
1042               if (itable == table_med_mail_id)
1043                 {
1044                   if (name_i.gibi_pile != PILE_SOUS_MAILLAGE) {
1045                     // error: must be PILE_SOUS_MAILLAGE
1046                   }
1047                   _iMed->_listGIBItoMED_mail.push_back(name_i);
1048                 }
1049               else if (itable == table_med_cham_id)
1050                 {
1051                   if (name_i.gibi_pile != PILE_FIELD &&
1052                       name_i.gibi_pile != PILE_NODES_FIELD)
1053                     {
1054                       // error: must be PILE_FIELD or PILE_NODES_FIELD
1055                     }
1056                   _iMed->_listGIBItoMED_cham.push_back(name_i);
1057                 }
1058               else if (itable == table_med_comp_id)
1059                 {
1060                   if (name_i.gibi_pile != PILE_STRINGS)
1061                     {
1062                       // error: gibi(short) names of components are kept in PILE_STRINGS
1063                     }
1064                   _iMed->_listGIBItoMED_comp.push_back(name_i);
1065                 }
1066             }
1067           else
1068             {
1069               // pass table
1070               for ( int ii = 0; ii < 4; ++ii ) next();
1071             }
1072         }
1073     } // for (int itable = 0; itable < nbObjects; itable++)
1074 }
1075
1076 //================================================================================
1077 /*!
1078  * \brief Read "PILE NUMERO  27"
1079  */
1080 //================================================================================
1081
1082 void SauvReader::read_PILE_STRINGS (const int                 nbObjects,
1083                                     std::vector<std::string>& objectNames,
1084                                     std::vector<int>&         nameIndices)
1085 {
1086   // IMP 0020434: mapping GIBI names to MED names
1087   initIntReading(2);
1088   int stringLen    = getIntNext();
1089   int nbSubStrings = getIntNext();
1090   if (nbSubStrings != nbObjects)
1091     THROW_IK_EXCEPTION("Error of reading PILE NUMERO  27" << lineNb() );
1092
1093   string aWholeString;
1094   if ( isXRD() )
1095     {
1096       const int fixedLength = 71;
1097       while ((int)aWholeString.length() < stringLen)
1098         {
1099           int remainLen = stringLen - aWholeString.length();
1100           int len;
1101           if ( remainLen > fixedLength )
1102             {
1103               len = fixedLength;
1104             }
1105           else
1106             {
1107               len = remainLen;
1108             }
1109           initNameReading(1, len);
1110           aWholeString += getName();
1111           next();
1112         }
1113     }
1114   else
1115     {
1116       char* line;
1117       const int fixedLength = 71;
1118       while ((int)aWholeString.length() < stringLen)
1119         {
1120           getNextLine( line );
1121           int remainLen = stringLen - aWholeString.length();
1122           if ( remainLen > fixedLength )
1123             {
1124               aWholeString += line + 1;
1125             }
1126           else
1127             {
1128               aWholeString += line + ( 72 - remainLen );
1129             }
1130         }
1131     }
1132   int prevOffset = 0;
1133   int currOffset = 0;
1134   initIntReading(nbSubStrings);
1135   for (int istr = 1; istr <= nbSubStrings; istr++, next())
1136     {
1137       currOffset = getInt();
1138       // fill mapStrings
1139       _iMed->_mapStrings[istr] = aWholeString.substr(prevOffset, currOffset - prevOffset);
1140       prevOffset = currOffset;
1141     }
1142 }