BmnTofHitProducer.h

Go to the documentation of this file.

//--------------------------------------------------------------------------------------------------------------------------------------
#ifndef __BmnTofHitProducer_H
#define __BmnTofHitProducer_H 1
 
#include "BmnTof2Digit.h"
#include "BmnTof2Raw2DigitNew.h"
#include "BmnTofGeoUtils.h"
#include "BmnTofHitProducerIdeal.h"
#include "BmnTrigDigit.h"
 
#include <FairTask.h>
#include <TClonesArray.h>
#include <map>
#include <math.h>
 
#define TOF2_MAX_CHAMBERS 59
#define TOF2_MAX_STRIPS_IN_CHAMBER 32
 
#define STRIP_CORRECTIONS 1
#define LIST_CHAMBER_CORRECTIONS 0
#define LIST_STRIP_CORRECTIONS 0
// CVERS=0 -  use last calibration tables, 1 - use *;1 version
#define CVERS 1
 
class TRandom2;
class TEfficiency;
class TH1D;
class TH2D;
class BmnTofGeoUtils;
 
class BmnTofHitProducer : public BmnTofHitProducerIdeal
{
    Double_t fMCTime[TOF2_MAX_CHAMBERS];
    Double_t fMCTimeSigma[TOF2_MAX_CHAMBERS];
 
    Double_t tofcalc[TOF2_MAX_CHAMBERS] = {0.f};
    Double_t tofcals[TOF2_MAX_CHAMBERS][32] = {{0.f}};
 
    Double_t fTimeSigma;     // Uncertainties of time, gaus sigma [ns],  default: 100 ps
    Double_t fErrX, fErrY;   // Uncertainties of coordinates, gaus sigma [cm], dX= 10./sqrt(12.) mm, default: dY= 5 mm.
    TRandom2* pRandom;       //!
 
    Bool_t fDoINL;
    Bool_t fDoSlewing;
 
    // QA test histos
    TEfficiency *effTestEfficiencySingleHit, *effTestEfficiencyDoubleHit;   //!
    TH1D *htR, *h1TestDistance, *h1TestMass, *h1TestMassLong, *h1TestOccupancyTimeShift,
        *h1TestOccupancyPositionShift;   //!
    TH2D *h2TestNeighborPair, *h2TestXYSmeared, *h2TestXYSmeared2, *h2TestXYSmearedDouble, *h2TestXYSmearedDouble2,
        *h2TestEtaPhi, *h2TestStrips, *h2TestRZ, *h2TdetIdStripId;   //!
 
    Bool_t HitExist(Double_t val);
    Bool_t DoubleHitExist(Double_t val);
 
    BmnTofGeoUtils* pGeoUtils;   //!
 
    const char* fgeomFile;   //!
 
    const char* fMCTimeFile;   //!
 
    const char* fProtonTimeCorrectionFile;   //!
 
    const double fSignalVelosity;   // [ns/cm]
 
    // input- strip edge position & signal times; output- strip crosspoint; return false, if crosspoint outside strip
    Int_t MergeHitsOnStripNew(void);
    bool GetCrossPoint(const TVector3& p1, double time1, const TVector3& p2, double time2, TVector3& crossPoint);
    bool GetCrossPoint(const LStrip* pStrip, double dtime, TVector3& crossPoint);
    Double_t CalculateToF(BmnTof2Digit* d1, BmnTof2Digit* d2, BmnTrigDigit* t0);
    BmnTof2Raw2DigitNew* fTOF2;   //!
    Int_t fMainStripSelection;
    Int_t fSelectXYCalibration;
    Double_t fTimeMin;
    Double_t fTimeMax;
    Double_t fDiffTimeMaxSmall;
    Double_t fDiffTimeMaxBig;
 
  public:
    BmnTofHitProducer(const char* name = "TOF HitProducer",
                      const char* geomFile = "",
                      Bool_t useMCdata = true,
                      Int_t verbose = 1,
                      Bool_t DoTest = false);
    virtual ~BmnTofHitProducer();
 
    virtual InitStatus Init();
    virtual void Exec(Option_t* opt);
    virtual void Finish();
 
    virtual void OnlineWrite(const std::unique_ptr<TTree>& resultTree);
 
    void SetTimeResolution(Double_t sigma) { fTimeSigma = sigma; };
    void SetAlongStripResolution(Double_t Xerr) { fErrX = Xerr; };
    void SetSeed(UInt_t seed = 0);
 
    void SetDoINL(bool val) { fDoINL = val; }
    void SetDoSlewing(bool val) { fDoSlewing = val; }
    void SetMainStripSelection(Int_t s = 0) { fMainStripSelection = s; };
    void SetSelectXYCalibration(Int_t s = 0) { fSelectXYCalibration = s; };
    void SetTimeMin(Double_t mi = -2.) { fTimeMin = mi; };
    void SetTimeMax(Double_t ma = +15.) { fTimeMax = ma; };
    void SetDiffTimeMaxSmall(Double_t ds = 0.) { fDiffTimeMaxSmall = ds; };
    void SetDiffTimeMaxBig(Double_t db = 0.) { fDiffTimeMaxBig = db; };
 
    TString GetParameters()
    {
        char s[32];
        TString buf = "\n Run parameters: fTimeSigma=";
        sprintf(s, "%.5g", fTimeSigma);
        buf += (s);
        buf += " ns, fErrX=";
        sprintf(s, "%.4g", fErrX);
        buf += (s);
        buf += " cm, fErrY=";
        sprintf(s, "%.4g", fErrY);
        buf += (s);
        buf += " cm, fDoTest=";
        buf += fDoTest;
        buf += ", fDoMergeHits=";
        buf += fDoMergeHits;
        buf += ", fDoINL=";
        buf += fDoINL;
        buf += ", fDoSlewing=";
        buf += fDoSlewing;
        return buf;
    }
 
    int readMCTimeFile(const char*);
    void SetMCTimeFile(const char* file) { fMCTimeFile = file; }
    void SetProtonTimeCorrectionFile(const char* file) { fProtonTimeCorrectionFile = file; }
 
    ClassDef(BmnTofHitProducer, 2);
};
 
#endif