GeantLMOF.h

Go to the documentation of this file.

#ifndef GW_GEANTLMOF_H
#define GW_GEANTLMOF_H

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

#ifndef GW_GAMMATRACKER_H
#include <GammaTracker.h>
#endif

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

#define MAXCHARACTER 500

class TGeoVolume;

namespace Gw {

class GeantLMOF
{
        friend GeantLMOF &fastout(GeantLMOF &reader) ;
        friend GeantLMOF &checkout(GeantLMOF &reader) ;

private:
        bool fFastOut;

        GeantLMOF *fGamma;
        
protected:
        UInt_t OnlyType(const GeantLMOF &input, Int_t fTypemin = 1, Int_t fTypemax = 1);
                
public:
        enum Status { kEmpty, kGood, kEoE, kFail };

private:
        Double_t fRecoilBeta;
        Double_t fRecoilSigma;
        Double_t fRecoilDx;
        Double_t fRecoilDy;
        Double_t fRecoilDz;
        Double_t fRecoilAngle;
        Double_t fTime;

        UInt_t fNbEmitted;
        UInt_t fNbImpacts;

        std::vector<Int_t>    fType;
        std::vector<Int_t>    fNdet;
        std::vector<Int_t>    fEvNum;
        std::vector<Int_t>    fNInt;
        std::vector<Int_t>    fPrimary;
        std::vector<Double_t> fEnergy;
        std::vector<Double_t> fDx;
        std::vector<Double_t> fDy;
        std::vector<Double_t> fDz;
        std::vector<Double_t> fEdep;
        std::vector<Double_t> fPx;
        std::vector<Double_t> fPy;
        std::vector<Double_t> fPz;
        std::vector<Double_t> fNseg;

        Double_t fDistFactor;
        Double_t fEnerFactor;

private:
        std::ifstream 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

        Char_t buf[MAXCHARACTER];               // buffer to get data from files

private:
        void   ReadHeader();

public:
        GeantLMOF();
        ~GeantLMOF();
        

        static TGeoVolume *ImportAgataG4(const char *asolid = "asolid", const char *aclust = "aclust", const char *aeuler = "aeuler", const char *top = "World");
                
                                
        void SetRecoil(Float_t b=0.0, Float_t dx = 0.0, Float_t dy = 0.0, Float_t dz = 1.0, Float_t angle = 0.0) {fRecoilBeta=b; fRecoilDx=dx; fRecoilDy=dy; fRecoilDz=dz; fRecoilAngle=angle;}
        
        Double_t GetDistFactor() const { return fDistFactor; } 
        Double_t GetEnerFactor() const { return fEnerFactor; }

        Double_t GetfRecoilBeta() const { return fRecoilBeta; }
        void GetRecoil(Double_t &b, Double_t &dx, Double_t &dy, Double_t &dz) const { b = fRecoilBeta; dx = fRecoilDx; dy = fRecoilDy; dz = fRecoilDz;}

        UInt_t NbEmitted() const { return fNbEmitted; }
        UInt_t NbImpacts() const { return fNbImpacts; }
                
        const std::vector<Double_t> &GetEnergy() { return fEnergy;}
        const std::vector<Double_t> &GetDx() { return fDx;}
        const std::vector<Double_t> &GetDy() { return fDy;}
        const std::vector<Double_t> &GetDz() { return fDz;}     

        const std::vector<Double_t> &GetEdep() { return fEdep;}
        const std::vector<Double_t> &GetPx()   { return fPx;}
        const std::vector<Double_t> &GetPy()   { return fPy;}
        const std::vector<Double_t> &GetPz()   { return fPz;}           
        const std::vector<Double_t> &GetNseg() { return fNseg;} 

        const std::vector<Int_t> &GetType()  { return fType;}
        const std::vector<Int_t> &GetNdet()  { return fNdet;}
        const std::vector<Int_t> &GetEvNum() { return fEvNum;}
        const std::vector<Int_t> &GetNInt()  { return fNInt;}           
        const std::vector<Int_t> &GetPrimary()  { return fPrimary;}

        const std::vector<Double_t> &GetEventsRead() { return fEventsRead; }    
                                
        void operator>> (GammaTracker *) ;
        
        GeantLMOF &operator<< (GeantLMOF &(*pf)(GeantLMOF &)) { 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; }


        void   NextFile();


        Bool_t NextEvent(UInt_t mult = kMaxUInt);

        void ShowCurrentEvent();

        void ShowCurrentConditions();
};

GeantLMOF &fastout(GeantLMOF &reader)  { reader.fFastOut = true ; return reader;  }
GeantLMOF &checkout(GeantLMOF &reader) { reader.fFastOut = false ; return reader; }
                
}
#endif