TgcDigitMaker.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef TGCDIGITMAKER_H
#define TGCDIGITMAKER_H
 
#include <string>
#include <vector>
 
#include "AthenaBaseComps/AthMessaging.h"
#include "GaudiKernel/StatusCode.h"
#include "GeoPrimitives/GeoPrimitives.h"
#include "Identifier/Identifier.h"
#include "MuonCondData/TgcDigitASDposData.h"
#include "MuonCondData/TgcDigitCrosstalkData.h"
#include "MuonCondData/TgcDigitTimeOffsetData.h"
 
namespace CLHEP {
class HepRandomEngine;
}
 
namespace MuonGM {
class MuonDetectorManager;
}
 
class TgcDigitCollection;
class TgcHitIdHelper;
class TgcIdHelper;
class TGCSimHit;
 
//--- class description
class TgcDigitMaker : public AthMessaging {
   public:
    TgcDigitMaker(const TgcHitIdHelper* hitIdHelper,
                  const MuonGM::MuonDetectorManager* mdManager,
                  const bool doFourBunch);
 
    virtual ~TgcDigitMaker() = default;

    StatusCode initialize();

    TgcDigitCollection* executeDigi(const TGCSimHit* hit,
                                    const double globalHitTime,
                                    const TgcDigitASDposData* ASDpos,
                                    const TgcDigitTimeOffsetData* TOffset,
                                    const TgcDigitCrosstalkData* Crosstalk,
                                    CLHEP::HepRandomEngine* rndmEngine);
 
    //====== for private
   private:
    enum NumberOfDimensions {
        N_STATIONNAME = 8,
        OFFSET_STATIONNAME = 41,
        N_STATIONETA = 11,
        OFFSET_STATIONETA = -5,
        N_STATIONPHI = 48,
        OFFSET_STATIONPHI = 1,
        N_GASGAP = 3,
        OFFSET_GASGAP = 1,
        N_ISSTRIP = 2,
        OFFSET_ISSTRIP = 0,
        N_ABSSTATIONETA = 5,
        OFFSET_ABSSTATIONETA = 1,
        N_STRIPCHANNEL = 32,
        OFFSET_STRIPCHANNEL = 1
    };
    enum TgcStation { kOUTER = 0, kINNER, N_STATION };
    enum TgcSensor { kWIRE = 0, kSTRIP, N_SENSOR };

    StatusCode readFileOfTimeJitter();
    float timeJitter(const Amg::Vector3D&,
                     CLHEP::HepRandomEngine* rndmEngine) const;

    bool efficiencyCheck(const TgcSensor sensor,
                         CLHEP::HepRandomEngine* rndmEngine) const;
    bool efficiencyCheck(const std::string& stationName, const int stationEta,
                         const int stationPhi, const int gasGap,
                         const TgcSensor sensor,
                         const double energyDeposit) const;
 
    uint16_t bcTagging(const double digittime, const double window,
                       const double offset) const;
    static void addDigit(const Identifier id, const uint16_t bctag,
                  TgcDigitCollection* digits) ;

    StatusCode readFileOfEnergyThreshold();
    StatusCode readFileOfDeadChamber();
    StatusCode readFileOfStripPosition();

    double getEnergyThreshold(const std::string& stationName, int stationEta,
                              int stationPhi, int gasGap,
                              const TgcSensor sensor) const;
    void randomCrossTalk(const TgcDigitCrosstalkData* crosstalk,
                         const Identifier elemId, const int gasGap,
                         const TgcSensor sensor, const int channel,
                         const float posInStrip, const float digitTime,
                         const float time_offset,
                         CLHEP::HepRandomEngine* rndmEngine,
                         TgcDigitCollection* digits) const;
    bool isDeadChamber(const std::string& stationName, int stationEta,
                       int stationPhi, int gasGap);
    static int getIStationName(const std::string& staionName) ;
    float getStripPosition(const std::string& stationName, int stationEta,
                           int channel) const;
    static double getSigPropTimeDelay(const float cableDistance) ;
    static float timeDiffByCableRadiusOfInner(const int iStationName,
                                       const int stationPhi,
                                       const int channel) ;
    float getDistanceToAsdFromSensor(const TgcDigitASDposData* readCdo,
                                     const int iStationName,
                                     const int stationEta, const int stationPhi,
                                     const TgcSensor sensor, const int channel,
                                     const float position) const;
    static float getTimeOffset(const TgcDigitTimeOffsetData* readCdo,
                        const uint16_t station_num, const int station_eta,
                        const TgcSensor sensor) ;
    static float getCrosstalkProbability(const TgcDigitCrosstalkData* readCdo,
                                  const uint16_t layer_id,
                                  const TgcSensor sensor,
                                  const unsigned int index_prob) ;

    unsigned int getRunPeriod() const;

    double m_energyThreshold[N_STATIONNAME][N_STATIONETA][N_STATIONPHI]
                            [N_GASGAP][N_ISSTRIP]{};

    bool m_isDeadChamber[N_STATIONNAME][N_STATIONETA][N_STATIONPHI][N_GASGAP]{};

    float m_StripPos[N_STATIONNAME][N_ABSSTATIONETA][N_STRIPCHANNEL]{};
 
    std::vector<std::vector<float> > m_vecAngle_Time;
 
    const TgcHitIdHelper* m_hitIdHelper{};
    const MuonGM::MuonDetectorManager*
    m_mdManager{};  // cannot use ReadCondHandleKey since no athena component
    const TgcIdHelper* m_idHelper{};
    float m_efficiency[N_SENSOR]{};

    double m_gateTimeWindow[N_STATION][N_SENSOR]{};
    double m_bunchCrossingTime;

    bool m_doFourBunchDigitization{false};
};
 
#endif