BmnNdetDigitizer.h

Go to the documentation of this file.

// -------------------------------------------------------------------------
// -----                 BmnNdetDigitizer header file                    -----
// -----                 Created 14/08/06  by S.Spataro                   -----
// -----                 Modified by M.Golubeva July 2022                -----
// -------------------------------------------------------------------------
 
#ifndef BMNNDETDIGITIZER_H
#define BMNNDETDIGITIZER_H 1
 
#include "BmnNdetDigit.h"
#include "BmnNdetPoint.h"
#include "FairLogger.h"
#include "FairTask.h"
#include "TClonesArray.h"
 
#include <TRandom3.h>
#include <iostream>
#include <unordered_map>
#include <vector>
 
class BmnNdetDigitizer : 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
    BmnNdetDigitizer(const int period);
    BmnNdetDigitizer(const char* config = nullptr);
    virtual ~BmnNdetDigitizer();
 
    // 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 BmnNdetPoints
    TClonesArray* fDigiArray;    // Output array of BmnNdetDigits
 
    std::unordered_map<uint32_t, std::vector<BmnNdetPoint*>> fuoHitMap;   // Address to hit vector of different tracks
    void FillHitMap();
 
    float fworkTime;   // Accumulated work time for the digitizer
    ClassDef(BmnNdetDigitizer, 5);
};
 
#endif   // BMNNDETDIGITIZER_H