BmnFHCalDigitizer.h

Go to the documentation of this file.

#ifndef BMNFHCALDIGITIZER_H
#define BMNFHCALDIGITIZER_H
 
#include "BmnFHCalDigit.h"
#include "BmnFHCalPoint.h"
#include "FairLogger.h"
#include "FairTask.h"
#include "TClonesArray.h"
 
#include <TRandom3.h>
#include <iostream>
#include <unordered_map>
#include <vector>
 
class BmnFHCalDigitizer : public FairTask
{
  public:
    struct SiPM
    {
        int Npixels;        // Total number of pixels in SiPM (for saturation)
        int pixPerMIP;      // MIP to N SiPM pixels with PDE taken into account
        double noiseMIP;    // MIP noise level
        double gevPerMIP;   // MIP to GeV conversion factor
 
        SiPM() = default;
 
        SiPM(int Npixels_, int pixPerMIP_, double noiseMIP_, double gevPerMIP_)
            : Npixels(Npixels_)
            , pixPerMIP(pixPerMIP_)
            , noiseMIP(noiseMIP_)
            , gevPerMIP(gevPerMIP_)
        {}
 
        ~SiPM() = default;
 
        ULong64_t ModelNpixels(double meanPixels) { return gRandom->Poisson(meanPixels); }
 
        ULong64_t ModelSaturation(ULong64_t firedPixels)
        {
            return static_cast<ULong64_t>(
                std::round(Npixels * (1.0 - std::exp(-static_cast<double>(firedPixels) / Npixels))));
        }
 
        double ModelNoise(double meanMIP) { return gRandom->Gaus(meanMIP, noiseMIP); }
 
        double ModelResponse(double pfELoss)
        {
            auto meanPixels = (pfELoss / gevPerMIP) * pixPerMIP;
            auto firedPixels = ModelNpixels(meanPixels);
            firedPixels = ModelSaturation(firedPixels);
            return gevPerMIP * ModelNoise(static_cast<double>(firedPixels) / pixPerMIP);
        }
    };
 
    // Constructor and Destructor
    BmnFHCalDigitizer(const int period);
    BmnFHCalDigitizer(const char* config = nullptr);
    virtual ~BmnFHCalDigitizer();
 
    // Overridden FairTask methods
    virtual InitStatus Init();
    virtual void Exec(Option_t* opt);
    virtual void Finish();
 
    // Setter methods
    InitStatus LoadConfig(const char* config);
    void SetScale(double scale) { fScale = scale; }
    void SetThreshold(double setValue) { fThreshold = setValue; }
    void SetTimeCut(double setValue) { fTimeCut = setValue; }
    void SetSiPM(int Npixels, int pixPerMIP, double noiseMIP, double gevPerMIP)
    {
        fSiPM.Npixels = Npixels;
        fSiPM.pixPerMIP = pixPerMIP;
        fSiPM.noiseMIP = noiseMIP;
        fSiPM.gevPerMIP = gevPerMIP;
    }
 
  private:
    double fScale;       // Scale factor
    double fThreshold;   // Noise threshold level
    double fTimeCut;     // Cut times above this
    SiPM fSiPM;          // SiPM properties and methods
 
    TClonesArray* fPointArray;   // Input array of BmnFHCalPoints
    TClonesArray* fDigiArray;    // Output array of BmnFHCalDigits
 
    std::unordered_map<uint32_t, std::vector<BmnFHCalPoint*>>
        fuoHitMap;   // Physical address (w/o scint) to point vector map
    void FillHitMap();
 
    float fworkTime;   // Accumulated work time for the digitizer
    ClassDef(BmnFHCalDigitizer, 3);
};
 
#endif   // BMNFHCALDIGITIZER_H