StBTofSimMaker.h

/***************************************************************************
 *
 * $Id: StBTofSimMaker.h,v 1.10 2021/01/27 14:58:56 geurts Exp $
 *
 * Author:  Frank Geurts
 ***************************************************************************
 *
 * Description: StBTofSimMaker virtual base class for Barrel TOF Simulations
 *
 ***************************************************************************
 *
 * $Log: StBTofSimMaker.h,v $
 * Revision 1.10  2021/01/27 14:58:56  geurts
 * change path to StVpdSimConfig.h from StVpdSimMaker to StBTofUtil
 *
 * Revision 1.9  2018/03/28 02:01:50  jdb
 * update to StBTofSimMaker to use cell-by-cell time resolution for FastSim
 *
 * Revision 1.8  2017/10/20 17:50:33  smirnovd
 * Squashed commit of the following:
 *
 *     StBTof: Remove outdated ClassImp macro
 *
 *     Prefer explicit namespace for std:: names in header files
 *
 *     Removed unnecessary specification of default std::allocator
 *
 * Frank signed-off
 *
 * Revision 1.7  2017/03/02 18:25:46  jeromel
 * Updates to StBTofSimMaker after review
 *
 * Revision 1.6  2015/07/28 22:49:55  smirnovd
 *  Initialize static constants outside of class definition
 *
 *  C++ forbids initialization of non-integral static const members within the class
 *  definition. The syntax is allowed only for integral type variables.
 *
 * Revision 1.5  2014/08/06 11:42:54  jeromel
 * Suffix on literals need to be space (later gcc compiler makes it an error) - first wave of fixes
 *
 * Revision 1.4  2011/02/03 19:01:01  geurts
 * Introduce option to switch writing simulated hits to StEvent. Default behavior is OFF.
 *
 * Revision 1.3  2010/08/10 19:18:32  geurts
 * Look for geant data in bfc ("geant") or geant.root ("geantBranch"); Protect storing BTofMcHitCollection in case McEvent is NULL.  [Xin]
 *
 * Revision 1.2  2010/07/14 20:32:58  geurts
 * remove geometry initialization (not used)
 *
 * Revision 1.1  2009/12/09 21:56:41  dthein
 * First version of StBTofSimMaker
 *
 *
 **************************************************************************/
#ifndef STBTOFSIMMAKER_HH
#define STBTOFSIMMAKER_HH
#include "StMaker.h"

#include "St_DataSet.h"
class TH1F;
class TH2F;
class TNtuple;

class StEvent;
class StBTofCollection;
class StTofSimParam;
class StBTofDaqMap;
struct g2t_ctf_hit_st;
class StBTofHeader;

// g2t tables
#include "tables/St_g2t_ctf_hit_Table.h"
#include "tables/St_g2t_track_Table.h"
#include "tables/St_g2t_tpc_hit_Table.h"
#include "StBTofUtil/StVpdSimConfig.h"

#include "StMcEvent/StMcEvent.hh"
#include "StMcEvent/StMcBTofHitCollection.hh"
#include "StMcEvent/StMcBTofHit.hh"
#include "StThreeVectorF.hh"
#include <vector>



class StBTofSimResParams;
class StBTofSimMaker : public StMaker{
protected:


    StTofSimParam*      mSimDb;          
    StBTofSimResParams* mSimResDb;
    StBTofDaqMap*       mDaqMap;         
    StMcBTofHitCollection *mMcBTofHitCollection; 

    St_DataSet        *mGeantData;        
    StEvent           *mEvent;
    StMcEvent         *mMcEvent;
    StBTofCollection  *mBTofCollection = nullptr;
    StBTofHeader*     mBTofHeader;
    StVpdSimConfig*   mVpdSimConfig;

    //define some constants
    enum {
        mNTOF = 192,    
        mNTray = 120,   
        mNModule = 32,  
        mNCell = 6,     
        mAMP = 50000,
        mADCBINWIDTH = 25,
        mTDCBINWIDTH = 50
    };
    static const float mVHRBIN2PS;    
    static const float mHRBIN2PS;     
    static const float mBTofPadWidth; 
    static const bool kSimulation = kFALSE;
    static const bool kEmbedding = kTRUE;

    bool mVpdSim;         
    bool mIsEmbedding;     
    bool mUseVpdStart;  
    bool mCellXtalk;     
    bool mSlow;           
    bool mBookHisto;
    bool mWriteStEvent;  

    int     mTofHitFlag[mNTray][mNTOF];   

    struct TrackHit{
        int          tray;
        int          module;
        int          cell;
        int          trkId;
        double       dE;
        double       dQ;
        double       dQdt[600];  
        double       tof;
        double       s_track;
        double          t0;      
        StThreeVectorF position;
    };


    typedef std::vector<TrackHit> TrackVec;
    typedef std::vector<int> IntVec;


    string mHistoFile;  
    string mHistoFileName;

    TNtuple* ntuple;

    TH1F* mRawBetaHist; 
    TH1F* mBetaHist;    
    TH2F* mRawBetaVsMom;
    TH2F* mCalcBetaVsMom;
    TH2F* mBetaVsMom;       

    TH2F* Electron_BetaVsMom;
    TH2F* Muon_BetaVsMom;
    TH2F* Pion_BetaVsMom;
    TH2F* Kaon_BetaVsMom;
    TH2F* Proton_BetaVsMom;

    TH1F* mPathLHist;    
    TH1F* mRawTofHist;      
    TH1F* mTofHist;    
    TH1F* mRecMass;    

    TH1F* massHist;
    TH2F* m2VsP;        
    TH1F* mTofCalculated;
    TH2F* tof_RealVsCalc;

    TH1F* momBinRaw1;
    TH1F* momBinRaw2;
    TH1F* momBinRaw3;
    TH1F* momBinRaw4;
    TH1F* momBinRaw5;
    TH1F* momBinRaw6;
    TH1F* momBinRaw7;
    TH1F* momBinRaw8;

    TH1F* momBin1;
    TH1F* momBin2;
    TH1F* momBin3;
    TH1F* momBin4;
    TH1F* momBin5;
    TH1F* momBin6;
    TH1F* momBin7;
    TH1F* momBin8;

    TH2F* mCellGeant;    
    TH2F* mNCellGeant;   
    TH1F* mDeGeant;      
    TH1F* mTofGeant;     

    TH2F* mCellSeen;     
    TH2F* mNCellSeen;    
    TH1F* mDeSeen;       
    TH1F* mT0Seen;       
    TH1F* mTofSeen;      
    TH1F* mTofResSeen;   

    TH2F* mCellReco;     
    TH2F* mNCellReco;    
    TH1F* mTDCReco;      
    TH1F* mADCReco;      
    TH1F* mT0Reco;   
    TH1F* mTofResReco;   
    TH2F* mTACorr;       
    TH1F* mModHist;       

    TH1F* mdE;           
    TH1F* mdS;           
    TH1F* mT;            
    TH1F* mTime;         
    TH1F* mTime1;        
    TH1F* mPMlength;     
    TH1F* mAdc;          
    TH1F* mTdc;          

    TVolume *starHall;

    int CellResponse(g2t_ctf_hit_st* tof_hit,
            TrackVec& trackVec);   
    int CellTimePassTh(TrackVec& trackVec);        

    int FastCellResponse(g2t_ctf_hit_st* tof_hit, StBTofCollection* btofColl);

    IntVec    CalcCellId(int volume_id, float ylocal);
    int CellXtalk(int icell, float ylocal, float& wt, int& icellx);
    int      storeMcBTofHit(StMcBTofHit *mcCellHit);

    int        fillRaw(void);
    int        electronicNoise(void);
    float      slatResponseExp(float&);
    double GammaRandom();


    int        fillEvent();
    int        bookHistograms();
    int        ResetFlags();


public:
    StBTofSimMaker(const char *name="TofSim");


    virtual ~StBTofSimMaker();

    void           Reset();
    virtual int  Init();
    int          InitRun(int);
    int          FinishRun(int);
    virtual int  Make();
    virtual int  Finish();

    bool  getEmbeddingMode() { return mIsEmbedding; }
    StTofSimParam*    GetSimParam()       const { return mSimDb; }
    StBTofCollection*  GetBTofCollection()  const { return mBTofCollection; }
    StMcBTofHitCollection* GetMcBTofHitCollection() const { return mMcBTofHitCollection; }

    void    setEmbeddingMode(bool mode = kEmbedding) {
        mIsEmbedding = mode;
    }
    void   setCellXtalk(bool val) { mCellXtalk = val; }
    string   setHistFileName();
    void   setBookHist(bool val) { mBookHisto = val; }
    Int_t writeHistograms();
    void   writeStEvent(bool val = kTRUE) {mWriteStEvent = val;}

    virtual const char *GetCVS() const
    {static const char cvs[]="Tag $Name:  $ $Id: StBTofSimMaker.h,v 1.10 2021/01/27 14:58:56 geurts Exp $ built " __DATE__ " " __TIME__ ; return cvs;}

    ClassDef(StBTofSimMaker,2)
};
#endif