EvapLMOF.h

Go to the documentation of this file.

#ifndef GW_EVAPLMOF_H
#define GW_EVAPLMOF_H

#ifndef ROOT_Rtypes
#include "Rtypes.h"
#endif
#ifndef GWS_BUFFER_H
#include "Buffer.h"
#endif 

#include <iostream>
#include <fstream>
#include <string>
#include <sstream>
#include <vector>

class TLeaf;

namespace Gw {

class EvapLMOF
{
public:
        enum Status { kEmpty, kGood, kEoE, kFail };

        static Short_t VERBOSE;
        
public:
        static const Short_t MAXCASCADE   = 200; 
        static const Short_t MAXPARTICLES =  12; // because arrays start from 0 in C++ while 1 in fortran
        
private:
        // structure corresponding to the GLOB common
        struct GLOBAL {
                Int_t   AC;
                Int_t   ZC;
                Int_t   NCASC;
                Int_t   MDIR;
                Int_t   JCASC;
                Float_t ENER;
                Float_t SIGMA;
                Float_t VRC;
                Int_t   MAX_P;
        };
        // structure corresponding to the ID common
        struct ID {
                Short_t MG;
                Float_t EE;
                Float_t JE;
                Float_t L;
                Short_t Z;
                Short_t N;
                Short_t NUM;
                Float_t WT;
                
                Bool_t  FIS;
        };
        // structure corresponding to the DATA common
        struct DATA {
                Short_t MODE[MAXCASCADE];       
                Float_t EI[MAXCASCADE];
                Float_t EP[MAXCASCADE]; 
                Short_t JI[MAXCASCADE]; 
                Short_t LP[MAXCASCADE]; 
                Short_t MP[MAXCASCADE]; 
                Short_t MUL[MAXPARTICLES];      
                Float_t ES[MAXPARTICLES];
                Float_t DJ[MAXPARTICLES];
        };
        // structure corresponding to the KINMAT common (always filled unless idonly is set)    
        struct KINMAT {
                Float_t V0[3];
                Float_t VE[MAXCASCADE][3];
                Float_t THETA[MAXCASCADE];      
                Float_t PHI[MAXCASCADE];        
                Short_t ZB;
                Short_t AB;     
                Float_t ER;
                Float_t EEJ[MAXCASCADE];
                Float_t JF[MAXCASCADE]; 
        }; 
        
public:
        friend EvapLMOF &idonly(EvapLMOF &reader) ;
        friend EvapLMOF &full(EvapLMOF &reader) ;       

private:
        Gws::Buffer *fHeader;           // to identify the next record (Global or Id)   
        
        Gws::Buffer *fGlobalRecord;     // global record (one per run)
        Gws::Buffer *fIdRecord;         // id record (one per cascade)  
        Gws::Buffer *fDataRecord;       // full cascade
        
private:        
        struct GLOBAL   fGlobal;
        struct ID       fId;    
        struct DATA     fData;
        struct KINMAT   fKin;
        
private:                
        Bool_t fIdOnly; 

        TString fError;
        TString fWarning;
                
private:        
        void SetRecord(Gws::Memory::EEndian);
                
        Bool_t ReadGlobal();
        Bool_t ReadId();        
        Bool_t ReadData();      
        void   ReadHeader();
        
private:
        FILE *fInfile;                          // input stream

        Int_t fCurrent, fMaxFiles, fStatus;     // current file number, max file number and current status

        std::vector<Double_t>     fEventsRead;  // total number of events read for each files
        std::vector<std::string>  fFileName;    // name of each file

        std::string fPath;                      // path to reach input files

public:
        EvapLMOF();
        ~EvapLMOF();


        EvapLMOF &operator<< (EvapLMOF &(*pf)(EvapLMOF &)) { return (*pf)(*this); }


        void AddFile(const char *fname) { std::string s = fname; fFileName.push_back(s); Double_t zero = 0.0; fEventsRead.push_back(zero); fMaxFiles++; }
        
        void SetPath(const char *path ="./") { fPath = path; }
        
        const std::vector<Double_t> &GetEventsRead() { return fEventsRead; }    


        void   NextFile();


        Bool_t NextEvent(UInt_t next = 0);
        

        void Rewind();
        

        void Scan(UInt_t start = 0, UInt_t end = 10);
        
        const GLOBAL &GetGlobal() { return fGlobal;}
        const ID       &GetId() { return fId; } 
        const DATA   &GetData() { return fData; }
        const KINMAT  &GetKin() { return fKin; }
        

        TLeaf *GetLeaf(const char *leafname = "no");
                
        void ShowCurrentEvent(std::ostream &out = std::cout);
        

        void ShowCurrentConditions(std::ostream &out = std::cout);
        
        TString &GetError() { return fError; }  
        
        TString &GetWarning() { return fWarning; }
};
inline EvapLMOF &idonly(EvapLMOF &reader)  { reader.fIdOnly = true ; return reader;  }
inline EvapLMOF &full(EvapLMOF &reader)     { reader.fIdOnly = false ; return reader;  }
}
#endif