MM_StripsResponseSimulation.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef MM_DIGITIZATION_STRIPRESPONSESIMULATION_H
#define MM_DIGITIZATION_STRIPRESPONSESIMULATION_H
 
 
#include <TFile.h>
#include <TH1F.h>
#include <TH2F.h>
 
#include "AthenaBaseComps/AthMessaging.h"
#include "GaudiKernel/IToolSvc.h"
#include "GaudiKernel/Service.h"
#include "GaudiKernel/StatusCode.h"
#include "MM_Digitization/MM_DigitToolInput.h"
#include "MM_Digitization/MM_IonizationCluster.h"
#include "MM_Digitization/MM_StripToolOutput.h"
#include "NSWCalibTools/INSWCalibTool.h"
#include <sys/stat.h>
 
#include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <sstream>
#include <string>
#include <utility>
 
class MM_DigitToolInput;
class MM_StripToolOutput;
 
namespace CLHEP {
    class HepRandomEngine;
    class HepRandom;
    class RandGeneral;
}  // namespace CLHEP
 
class MM_StripsResponseSimulation : public AthMessaging {
public:
 
    struct ConfigModule: public NSWCalib::MicroMegaGas {
        ConfigModule() = default;
        float qThreshold{0.};
 
        float crossTalk1{0.};  // 0.10; //
        float crossTalk2{0.};  // 0.03;
 
        float driftGapWidth{0.};
 
        // Avalanche gain
        float avalancheGain{0.};
        int maxPrimaryIons{300};
      
        bool writeOutputFile{false};
        bool writeEventDisplays{false};
        
    };
    MM_StripsResponseSimulation(ConfigModule&& cfg);
 
    virtual ~MM_StripsResponseSimulation();
    MM_StripToolOutput GetResponseFrom(const MM_DigitToolInput& digiInput, double gainFraction, double stripPitch,
                                       CLHEP::HepRandomEngine* rndmEngine) const;   
  
   
    float getQThreshold() const { return m_cfg.qThreshold; };
    float getDriftGapWidth() const { return m_cfg.driftGapWidth; };
    double getDriftVelocity() const { return m_cfg.driftVelocity; };
    float getInteractionDensityMean() const { return m_cfg.interactionDensityMean; }
    float getInteractionDensitySigma() const { return m_cfg.interactionDensitySigma; }
    float getLongitudinalDiffusionSigma() const { return m_cfg.longitudinalDiffusionSigma; }
    float getTransversDiffusionSigma() const { return m_cfg.transverseDiffusionSigma; }
    
private:
    void initHistos();  
    void writeHistos(); 
    const ConfigModule m_cfg{};
 
    struct DataCache {
        std::vector<std::unique_ptr<MM_IonizationCluster>> IonizationClusters{};
        std::vector<int> finalNumberofStrip{};
        std::vector<std::vector<float>> finalqStrip{};
        std::vector<std::vector<float>> finaltStrip{};
        std::vector<float> tStripElectronicsAbThr{};
        std::vector<float> qStripElectronics{};
    };
 
    void whichStrips(DataCache& cache,
                     const MM_DigitToolInput& digiInput, 
                     double gainFraction,
                     double stripPitch, CLHEP::HepRandomEngine* rndmEngine) const;
 
  
    std::map<std::string, std::unique_ptr<TH1F>> m_mapOfHistograms{};
    std::map<std::string, std::unique_ptr<TH2F>> m_mapOf2DHistograms{};
 
    std::unique_ptr<CLHEP::RandGeneral> m_randNelectrons{};
 
    static constexpr unsigned int s_NelectronPropBins{300};
 
 
    std::unique_ptr<TFile> m_outputFile{nullptr};
 
protected:
    // seperate random number generation for performance monitoring
    float generateTransverseDiffusion(float posY, CLHEP::HepRandomEngine* rndmEngine) const;
    float getTransverseDiffusion(float posY, CLHEP::HepRandomEngine* rndmEngine) const;
    float getLongitudinalDiffusion(float posY, CLHEP::HepRandomEngine* rndmEngine) const;
    float getEffectiveCharge(CLHEP::HepRandomEngine* rndmEngine) const;
    float getPathLengthTraveled(CLHEP::HepRandomEngine* rndmEngine) const;
};
#endif