GPSIConverter.cpp

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2004-2006 by 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_GPSICONVERTER_H
#include "GPSIConverter.h"
#endif

#ifndef ROOT_TRegexp
#include <TRegexp.h>
#endif

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

#include <iostream>
using namespace std;

namespace { GPSIConverter gGPSIConverter; } // prototype ONLY use to create a new DB system

//__________________________________________________________________
GPSIConverter::GPSIConverter(const char *name) : HistoConverter(name)
{ 
  // default  for gpsi  
  fType = "gpsi";

  CheckDirectory(name);
  fLog.GetProcessName() = "GPSIConverter";
}

//__________________________________________________________________
void GPSIConverter::CheckDirectory(const char *name)
{
   // Default for the header of the file
   fHeader.fNbSpectra = 0;
   fHeader.fFileSize  = 0;
   
   // defaults for the sp headers
   for (int i = 0; i < MAX_SP; i++) {
        fHeader.fWhere[i] = 0;
        
        fLabel[i].fNx = 0; 
        fLabel[i].fNy = 0;
        for (int j = 0; j < 12; j++) fLabel[i].fSpName[j] = 0;
   }
   
   // chech if the file extension, if not set to zombie !
   TString tmp = name;
   if ( tmp.EndsWith(fFileExt) == kFALSE ) {
        SetError(HistoConverter::kZombie,"extension must be .s for gpsi files !");
   }
   else {
        // check out if this file can be read by trying to open it in reading mode
        fStreamIN.open(name,ios::in);
        
        if ( fStreamIN.is_open() ) { // it already exist, load the header part and close it
                // check out that the file length is the same length 
                // that is written in the header part. The reading of the header 
                // part also determined if swapping is needed
                if ( ReadHeaders() == false ) {
                  fLog.GetProcessMethod() = "CheckDirectory(const char* )";
                        SetError(HistoConverter::kZombie,
                                  "Problems when reading the header part");     
                }
                fStreamIN.close(); 
        }
        else { // try to open an new file and init the header part.
                fLog.GetProcessMethod() = "CheckDirectory(const char* )";
                SetError(HistoConverter::kZombie,
                        "Currently, only possible to read existing gpsi files");
        }
   }  
} 

//__________________________________________________________________
GPSIConverter::GPSIConverter() : HistoConverter()
{ 
   // default for gpsi  
   fType = "gpsi";
   fFileExt = ".s";
   fOptions = "";

   // add this interface to the DB service 
   AddPrototype(GetType(),this);
} 

//__________________________________________________________________
GPSIConverter::~GPSIConverter()
{ 
        if ( fStreamIN.is_open() ) { fStreamIN.close(); }
} 



//__________________________________________________________________
HistoConverter *GPSIConverter::NewDB(const char *name) const 
{ 
  return new GPSIConverter(name);
}

//__________________________________________________________________
bool GPSIConverter::ReadHeaders()
{
        if ( fStreamIN.is_open() == false ) return false; // the file must be opened to read
        
        char tmp[512]; for (int i = 0; i < 512; i++) tmp[i] = 0;
        
        // determine the file size using seek 
        long real_size;
        fStreamIN.seekg(0,ios::end); real_size = fStreamIN.tellg();
        if ( real_size < 512*512 ) {
                //SetError(HistoConverter::kFail,
                //      Form("[GPSIConverter::ReadHeaders] file too small to be a gpsi file %d",real_size)) ;
          if ( gDebug > 0 ) {
                  fLog.GetProcessMethod() = "ReadHeaders()";
                  fLog << debug <<  "File too small to be a gpsi file"
                       << real_size
                       << nline;
          }
                return false;           
        }
        // read the number of expected spectra, the expected file size 
        // and compare it to what is obtained before
        // the coded value concerning the file size is in 512 units
        // so the read size is obtained with: 512*(filesize-1)
        short nbspectra1 = 0, nbspectra2 = 0; int filesize1 = 0, filesize2 = 0;
                
        fIsSwapping = false; 
        fStreamIN.seekg(0,ios::beg); 
        fStreamIN.read(tmp,2); nbspectra1 = Short(tmp);
        fStreamIN.read(tmp,2); filesize1  = Short(tmp); filesize1 = 512*(filesize1-1);  
        fIsSwapping = true; 
        fStreamIN.seekg(0,ios::beg); 
        fStreamIN.read(tmp,2); nbspectra2 = Short(tmp);
        fStreamIN.read(tmp,2); filesize2  = Short(tmp); filesize2 = 512*(filesize2-1);
        
        // check first if it is a good # of spectra 
        short which_swap = 0;
        if ( 0 < nbspectra1 && nbspectra1 < 254 ) which_swap = 1;
        if ( 0 < nbspectra2 && nbspectra2 < 254 ) which_swap = 2;
        
        if ( which_swap == 0 ) { // cannot be a gpsi file
                //SetError(HistoConverter::kFail,
                //        "[GPSIConverter::ReadHeaders] # of spectra not in the range [1,253]");
          if ( gDebug > 0 ) {
            fLog.GetProcessMethod() = "ReadHeaders()";
            fLog << error << "# of spectra not in the range [1,253]" << nline ; 
          }
                return false; 
        }
        
        // check if the file size coded inside is the likely one.
        // it doesn't check exactly because I have gpsi file that differ of 2 units 
        // from the real size ... maybe a PB with gpsi in Lyon. I've check that other
        // gpsi files work properly
        fIsSwapping = false;
        if ( real_size == 512*512 ) { // not enough spectra to check filesize   
          if ( which_swap == 2 ) fIsSwapping = true; 
        }
        else {
          if ( (real_size-5) < filesize1 && filesize1 < (real_size+5) ) which_swap += 10;
          if ( (real_size-5) < filesize2 && filesize2 < (real_size+5) ) which_swap += 20;
          
          if ( which_swap == 11 || which_swap == 22 ) {
                if ( which_swap == 22 ) fIsSwapping = true;
          }
          else {
                //SetError(HistoConverter::kFail,
                //         Form("[GPSIConverter::ReadHeaders] cannot determine endian type swap %d",which_swap));  
            if ( gDebug > 0 ) {
              fLog.GetProcessMethod() = "ReadHeaders()";
              fLog << error << "Cannot determine endian type swap " << which_swap << nline ;    
            }
          return false;           
          }
        } // else               
     
        // now re-start reading from the beginning
        fStreamIN.seekg(0,ios::beg); 
        fStreamIN.read(tmp,2); fHeader.fNbSpectra = Short(tmp);
                
        // read all sp headers
        for (int i = 0; i < fHeader.fNbSpectra; i++ ) {
        
                // determine where is the header for spectrum #i
                fStreamIN.seekg(2*i+4,ios::beg); fStreamIN.read(tmp,2); fHeader.fWhere[i] = Short(tmp); 

                // read the header for spectrum #i              
                fStreamIN.seekg((fHeader.fWhere[i]-1)*512,ios::beg);
                fStreamIN.read(tmp,512); 

                unsigned short test_label1 = UShort(tmp);
                unsigned short test_label2 = UShort(tmp+2);             
                if ( test_label1 != 0xFFFF || test_label2 != 0xFFFF ) {
                  //SetError(HistoConverter::kFail,
                  //         Form("[GPSIConverter::ReadHeaders] SP #%d has an incorrect header .. probably not a gpsi file",i));        
                  if ( gDebug > 0 ) {
                    fLog.GetProcessMethod() = "ReadHeaders()";
                    fLog << error << "SP #"
                             << i << " has an incorrect header .. probably not a gpsi file" << nline;     
                  }
                  return false;
                }               
                int len = Short(tmp+16) - 12;
                strncpy(fLabel[i].fSpName, (tmp + 31), len);
                fLabel[i].fNx = Short(tmp+70);
                fLabel[i].fNy = Short(tmp+66);  
        }       
        return true;
}

//__________________________________________________________________
void GPSIConverter::ls(Option_t *o) const 
{
        HistoConverter::ls(o);
        cout << fHeader.fNbSpectra << " spectra found in the file " << endl;
        for (int i = 0; i < fHeader.fNbSpectra; i++){
                cout << " [" << i <<  "] " << fLabel[i].fSpName;
                
                /*
                if ( fLabel[i].fNy == 1 )
                     cout << " - " << fLabel[i].fNx << " bins" ;
                else 
                     cout << " - " << fLabel[i].fNx << " bins_x " << fLabel[i].fNy << "bins_y"; */
                     
                if ( (i+1) % 5 == 0 ) cout << endl;
                else cout << "\t";
        }
        cout << endl;
}

//__________________________________________________________________
TH1 *GPSIConverter::Get(int which) 
{
        if ( which < 0 || which >= fHeader.fNbSpectra ) return NULL; 
        else return Get(fLabel[which].fSpName);
}  

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

//__________________________________________________________________
bool GPSIConverter::Read(TH1 &h)
{ 
        bool ok = false; TString hname = h.GetName();
        
        // look for a spectrum with a similar name in the list of labels
        int which = -1 ;
        for (int i = 0; i < fHeader.fNbSpectra; i++ ) {
                if (  hname.CompareTo(fLabel[i].fSpName) == 0 ) { 
                  h.SetBins(fLabel[i].fNx*fLabel[i].fNy,0,fLabel[i].fNx*fLabel[i].fNy); which = i; break;
                }
        }
        if ( which == -1 ) { 
          fLog.GetProcessMethod() = "Read(TH1&)";
                SetError(HistoConverter::kFail,
                         Form("SP %s not found",h.GetName())); 
                return false; 
        } // not in this file
        
        // now read the spectrum from the file
        fStreamIN.clear(); fStreamIN.open(fName.Data(),ios::in); 
        if ( fStreamIN.is_open() ) { 
                // move to the good postion and read 
                char *tmp = new char[4*fLabel[which].fNx*fLabel[which].fNy]; 
                if (tmp == NULL) return false;
                
                fStreamIN.seekg(fHeader.fWhere[which]*512,ios::beg);
                fStreamIN.read(tmp,4*fLabel[which].fNx*fLabel[which].fNy); 
                
                if ( fStreamIN.good() ) {
                        for ( int i = 0; i < fLabel[which].fNx*fLabel[which].fNy; i++ ) 
                                h.Fill(i,Float(tmp+4*i)) ;
                        ok = true;
                }
                fStreamIN.close(); delete [] tmp;
        }
        else { ok = false; }
        
        return ok;      
} 

//__________________________________________________________________
bool GPSIConverter::Write(const TH1 &/*h*/)
{ 
  fLog.GetProcessMethod() = "Write(const TH1&)";
  SetError(HistoConverter::kFail,
                 "CANNOT WRITE - gpsi is a deprecated DB system"); return false;
} 

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

//__________________________________________________________________
bool GPSIConverter::Write(const TH2 &/*h*/)
{ 
  fLog.GetProcessMethod() = "Write(const TH2&)";
  SetError(HistoConverter::kFail,
                 "CANNOT WRITE - gpsi is a deprecated DB system"); return false;
} 

//__________________________________________________________________
bool GPSIConverter::Read(THStack &hs)
{
    TString tmphs = hs.GetName();
    // pattern expression
    Bool_t wildcard = false;
    if ( tmphs.Contains("*") )
        wildcard = true;
        TRegexp all("*",kTRUE), pattern(hs.GetName(),wildcard);
    
        if ( pattern.Status() != TRegexp::kOK ) { 
                if ( gDebug > 0 ) cerr << "pattern * " << hs.GetName() << endl ;
                pattern = all; 
        }
        else { if ( gDebug > 0 ) cerr << "pattern " << hs.GetName() << endl ; }
                                
        TH1 *h; 
        for (int i = 0; i < fHeader.fNbSpectra; i++ ) {
        
                h = NULL; 
                
                if ( gDebug > 0 ) {
                 fLog.GetProcessMethod() = "Read(THStack&)";
                        fLog << debug << "Comparing " << fLabel[i].fSpName << " ..";
                }
                TString tmp;    
                tmp = fLabel[i].fSpName;
                if ( tmp.Contains(pattern) ) h = Get(fLabel[i].fSpName);
                
                // if a new spectrum, add it to the stack
                if ( h ) { hs.Add(h); if ( gDebug > 0 ) cerr << " IN STACK " << endl; }
                else { if ( gDebug > 0 ) cerr << " NOT IN STACK " << endl; }
        }
        return true;
} 

//__________________________________________________________________
bool GPSIConverter::Write(const THStack &/*hs*/)
{ 
  fLog.GetProcessMethod() = "Write(const TH1&)";
  SetError(HistoConverter::kFail,
                 "CANNOT WRITE - gpsi is a deprecated DB system"); return false;
}