ASCConverter.cpp

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2004-2006 by Christian, Finck, Olivier Stezowski        * 
 *                             & Christophe Theisen                        *
 *   stezow(AT)ipnl.in2p3.fr, christophe.theisen(AT)cea.fr                 *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/

#ifndef GW_ASCCONVERTER_H
#include "ASCConverter.h"
#endif
 
#ifndef ROOT_TRegexp
#include <TRegexp.h>
#endif

#ifndef ROOT_TSystem
#include <TSystem.h>
#endif

#ifndef ROOT_TSystemDirectory
#include <TSystemDirectory.h>
#endif

#if ROOT_VERSION_CODE >= ROOT_VERSION(5,15,0)
#include "TList.h"
#endif

#ifndef ROOT_TObjArray
#include "TObjArray.h"
#endif

#ifndef ROOT_TObjString
#include "TObjString.h"
#endif

#include <iostream>
using namespace std;

namespace { ASCConverter gASCConverter; } // prototype ONLY use to create a new DB system

//_________________________________________________________________
ASCConverter::ASCConverter(const char *name) : HistoConverter(name)
{ 
  fType = "asc";
  // default file extension for ascii, could be change by setter 
  
  CheckDirectory(name);
  fStreamIN.clear(); fCycle = '_'; // because ; is not supported by all file systems 
  fLog.GetProcessName() = "ASCConverter";
} 

//_________________________________________________________________
ASCConverter::ASCConverter() : HistoConverter()
{ 
   fType = "asc";
   // default file extension for ascii, could be change by setter 
   fFileExt = ".asc";
   //default option
    fOptions = "h:0 c:1 s: p:1.0.1";
   // add this interface to the DB service 
   AddPrototype(GetType(),this);
} 

//_________________________________________________________________
ASCConverter::~ASCConverter()
{ 

} 

//_________________________________________________________________
HistoConverter *ASCConverter::NewDB(const char *name) const 
{ 
  return new ASCConverter(name);
}



//_________________________________________________________________
void ASCConverter::ls(Option_t *o) const
{
    HistoConverter::ls(o);
    TSystemDirectory dir; dir.SetDirectory(fName.Data()); 
    TList *list = dir.GetListOfFiles();
    TIter iter(list); 
    TObject *entry; 
    Int_t count = 0;
    
    while ( (entry = iter()) ) {
      TString tmp = entry->GetName();
      if ( tmp.EndsWith(fFileExt) ) { // this is a true ascii file
        cout << " [" << count++ <<  "] " << entry->GetName() ;
        if ( (count+1) % 5 == 0 ) cout << endl;
      else cout << "\t";                     
      }
    }
    cout << endl; 
    if ( list ) delete list;
}

//_________________________________________________________________
TH1 *ASCConverter::Get(int which)
{ 
   // list all the file to find the entry number correponding to which
    TSystemDirectory dir; dir.SetDirectory(fName.Data()); TList *list = dir.GetListOfFiles();
    TIter iter(list); TObject *entry; int count = 0; TString result = "_EMPTY_";

    while ( (entry = iter()) ) {
      TString tmp = entry->GetName();
      if ( tmp.EndsWith(fFileExt) ) {
        if ( which == count ) 
          result = entry->GetName(); 
        count++;
      }
    }
    if ( list ) delete list;
    
    if ( result != "_EMPTY_" ) return Get(result.Data()); // an entry has been found
    fLog.GetProcessMethod() = "Get(Int_t )";
    SetError(HistoConverter::kFail,
             Form("Cannot find entry # %d",which));
    return NULL;

} 

//_________________________________________________________________
TH1 *ASCConverter::Get(const char *name)
{ 
    TH1F *h = new TH1F();
    h->SetName(name);
    if ( !Read((*h)) ) {
     delete h;
      h = NULL; 
    }
    return h;
   
}

//_________________________________________________________________
bool ASCConverter::Read(TH1 &h)
{ 
   TString filename = fName.Data(); 
   if ( filename.IsNull() )  filename = "."; // for mine types
   
   if ( ! filename.EndsWith("/") ) filename+= "/";  // set file name as a full path name
     filename += h.GetName();


   if ( filename.EndsWith(fFileExt) == false ) filename += fFileExt; 
    
  ifstream in(filename, ios::in);
   
  if ( !in ) {
    fLog.GetProcessMethod() = "Read(TH1&  )";
    SetError(HistoConverter::kFail,
             Form("Cannot open file %s",filename.Data()));                
    return false;
   }
  
   // get format info 
   TArrayI params(6);
   if ( !DecodeFormat(params) ) {
    return false;
   }
    
  
  Int_t  nbLines   = params[0];
  Int_t  nbColumns = params[1];
  Char_t sep       = (char)params[2];
  Int_t  nbParams  = params[3];
  Int_t  posBin    = params[4];
  Int_t  posBinContent = params[5];  
   
  vector<Int_t> histo; histo.clear();
  vector<Int_t> bin;   bin.clear();

  
  Char_t line[255];
  //skip header 
  for (Int_t i = 0; i < nbLines; ++i)
    in.getline(line,255);
  
  // read data
  TString sCnt;
  TString sBin;
  Int_t idxBin;
  Int_t idxContent;
  
  while ( in.getline(line,255) ) {
    
    TString tmp(line);
    TObjArray* stringList = tmp.Tokenize(TString(sep));
    
 
    for (Int_t i = 0; i < nbColumns; ++i) {
      if (posBin != 0) {
        idxBin = (posBin-1) + nbParams*i;
        sBin   = ((TObjString*)stringList->At(idxBin))->GetString();
        bin.push_back(sBin.Atoi());
      }
      
      idxContent = (posBinContent-1) + nbParams*i;
      sCnt = ((TObjString*)stringList->At(idxContent))->GetString();
      histo.push_back(sCnt.Atoi());
    }
    delete stringList;
    
  }
  in.close();
  
  h.SetBins(histo.size(),0,histo.size()); 
  for (UInt_t i = 0; i < histo.size(); i++ ) 
    if (bin.size() != 0)
      h.SetBinContent(bin[i],histo[i]);
    else 
      h.SetBinContent(i+1,histo[i]);
  
  in.close(); 
  
  return true;
} 

//_________________________________________________________________
bool ASCConverter::Write(const TH1 & h)
{ 
        TString hname, filename;  // set file name as a full path name
        hname = h.GetName();
        filename = CheckFileVersion(hname);
                
        filename.Prepend(fName.Data());
        if ( gDebug > 0 ) {
          fLog.GetProcessMethod() = "Write(const TH1& )";
          SetError(HistoConverter::kFail, Form("file to store the spectrum %s", filename.Data()) );    
        }
        
        if (fVerboseLevel)
                fLog << info << "Writing spectrum " << filename << nline ;

        ofstream out(filename.Data(), ios::out);
        
        if (!out) {
          fLog.GetProcessMethod() = "Write(const TH1& )";
          SetError(HistoConverter::kFail,
                   Form("Cannot open %s in writing mode",filename.Data()));
          return false;
        }
  
  
    // get format info 
   TArrayI params(6);
   if ( !DecodeFormat(params) ) {
    return false;
   }
    
  
  Int_t  nbLines   = params[0];
  Int_t  nbColumns = params[1];
  Char_t sep       = (char)params[2];
  Int_t  nbParams  = params[3];
  Int_t  posBin    = params[4];
  Int_t  posBinContent = params[5];  
  Int_t idxBin = -1;
  Int_t idxContent = 0;
  Int_t bin = 1;

 //write dummy header 
  for (Int_t i = 0; i < nbLines; ++i)
    out << "Header generated by [ASCConverter::Write(TH1 &h)]" << endl;

  Int_t size = h.GetNbinsX()/nbColumns;

  for (Int_t j = 0; j < size; ++j) {
    
    for (Int_t i = 0; i < nbColumns; ++i) {
      if (posBin != 0 ) 
        idxBin = (posBin-1) + nbParams*i;
      idxContent = (posBinContent-1) + nbParams*i;
      if (i == idxBin) 
        out << h.GetBin(bin);
       else if (i == idxContent) {
        out << h.GetBinContent(bin++);
        }
      else
        out << "0"; 
      if (i < nbColumns-1)
        out << sep;
    }
    out << endl;    
  }
  return true;
} 

//_________________________________________________________________
bool ASCConverter::Read(TH2 &/*h*/)
{ 
  fLog.GetProcessMethod() = "Read(TH2& )";
  SetError(HistoConverter::kFail,"NO IMPLEMENTATION !!") ; 
  return false;
} 

//_________________________________________________________________
bool ASCConverter::Write(const TH2 &/*h*/)
{ 
  fLog.GetProcessMethod() = "Write(const TH2& )";
  SetError(HistoConverter::kFail,"NO IMPLEMENTATION !!");       
  return false;
} 

//_________________________________________________________________
bool ASCConverter::Read(THStack &/*hs*/)
{ 
  fLog.GetProcessMethod() = "Read(THStack& )";
  SetError(HistoConverter::kFail,"NO IMPLEMENTATION !!"); 
  return false;
} 

//_________________________________________________________________
bool ASCConverter::Write(const THStack &/*hs*/)
{ 
  fLog.GetProcessMethod() = "Write(const THStack& )";
  SetError(HistoConverter::kFail,"NO IMPLEMENTATION !!");       
  return false;
} 


//_________________________________________________________________
Bool_t ASCConverter::DecodeFormat(TArrayI& params)
{

   // decode options
   TString option = Normalize(fOptions.Data());
   TString type = "[";

   Int_t last = 0;
   Int_t idx = 0;
   Int_t nbLines = 0;
   Int_t nbColumns = 0;
   Int_t nbParams = 0;
   Int_t posBin = 0;
   Int_t posBinContent = 0;
   char sep = 0;

   //take always the last set option separated by [...]
   Int_t length = option.Length();
   while (last < length) {
    last = option.Index(type, idx);
    if (last == -1) break;
    idx = last + type.Length();
   }
   TString format(option(idx, length -idx));
   TString keys;
    TObjArray* stringList = format.Tokenize(TString(" "));
    if (stringList->GetEntries() > 4) {
      fLog.GetProcessMethod() = "DecodeFormat(TArrayI& )";
      SetError(HistoConverter::kFail,"Too many blanks in the format option !!");
      return false;
    }
    
    for (Int_t i = 0; i< stringList->GetEntries(); ++i) {
      keys = ((TObjString*)stringList->At(i))->GetString();
      const Char_t* k = keys.Data();
      switch(k[0])
      {
        case 'h' :
          sscanf(k, "h:%d", &nbLines);
          params[0] = nbLines;
          break;
        case 'c' :
          sscanf(k, "c:%d", &nbColumns);
          params[1] = nbColumns;
          break;      
        case 's' :
          sscanf(k, "s:%c", &sep);
          params[2] = (Int_t)sep;
          break;  
        case 'p' :
          sscanf(k, "p:%d.%d.%d", &nbParams, &posBin, &posBinContent);
          params[3] = nbParams; params[4] = posBin; params[5] = posBinContent;
          break;          
      }
    }

 return true;
 
}

//_____________________________________________________________________________
TString ASCConverter::Normalize(const char* line)
{
  
  TString rv(line);
  
  if ( rv.Length() <= 0 ) return TString();
  
  while ( rv[0] == ' ' )
  {
    rv.Remove(0,1);
  }
  while ( rv[rv.Length()-1] == ' ' )
  {
    rv.Remove(rv.Length()-1,1);
  }
  Ssiz_t i(0);
  bool kill = false;
  for ( i = 0; i < rv.Length(); ++i )
  {
    if ( rv[i] == ' ' )
    {
      if (kill)
            {
              rv.Remove(i,1);
              --i;
            }
      else
            {
              kill = true;
            }
    }
    else
    {
      kill = false;
    }
  }
  return rv;
}