BmnScWallDigitizer.h

Go to the documentation of this file.

/*
 * File:   BmnScWallDigitizer.h
 * Author: Sergey Morozov
 *
 * Created on 16.09.2021, 12:00
 */
 
#ifndef BMNSCWALLDIGITIZER_H
#define BMNSCWALLDIGITIZER_H
 
#include "BmnScWallDigit.h"
#include "BmnScWallGeoPar.h"
#include "BmnScWallPoint.h"
#include "FairLogger.h"
#include "TRandom3.h"
 
#include <FairTask.h>
#include <TClonesArray.h>
#include <fstream>
#include <iostream>
 
class BmnScWallDigitizer : 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
    BmnScWallDigitizer(const int period);
    BmnScWallDigitizer(const char* config = nullptr);
    virtual ~BmnScWallDigitizer();
 
    // 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 BmnScWallPoints
    TClonesArray* fDigiArray;    // Output array of BmnScWallDigits
 
    std::unordered_map<uint32_t, std::vector<BmnScWallPoint*>>
        fuoHitMap;   // Physical address (w/o scint) to point vector map
    void FillHitMap();
 
    float fworkTime;   // Accumulated work time for the digitizer
    ClassDef(BmnScWallDigitizer, 2);
};
 
#endif /* BMNSCWALLDIGITIZER_H */