RpcDigitizationTool.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef RPC_DIGITIZATIONTOOL_H
#define RPC_DIGITIZATIONTOOL_H
 
#include "AthenaKernel/IAthRNGSvc.h"
#include "StoreGate/ReadCondHandleKey.h"
#include "MuonReadoutGeometry/MuonDetectorManager.h"
#include "HitManagement/TimedHitCollection.h"
#include "MuonCondData/RpcCondDbData.h"
#include "MuonSimEvent/RPCSimHit.h"
 
#include "MuonSimEvent/RPCSimHitCollection.h"
#include "PileUpTools/PileUpMergeSvc.h"
#include "PileUpTools/PileUpToolBase.h"
#include "xAODEventInfo/EventInfo.h"     // NEW EDM
 
 
#include "MuonDigitContainer/RpcDigitContainer.h"
#include "MuonSimData/MuonSimDataCollection.h"
 
class RpcHitIdHelper;
 
 
class RpcIdHelper;
 
namespace CLHEP {
    class HepRandomEngine;
}
 
class RpcDigitizationTool : public PileUpToolBase {
public:
    RpcDigitizationTool(const std::string& type, const std::string& name, const IInterface* pIID);
 
    virtual StatusCode initialize() override final;
 
    virtual StatusCode prepareEvent(const EventContext& ctx, const unsigned int /*nInputEvents*/) override final;
 
    virtual StatusCode processBunchXing(int bunchXing, SubEventIterator bSubEvents, SubEventIterator eSubEvents) override final;
 
    virtual StatusCode mergeEvent(const EventContext& ctx) override final;
 
    virtual StatusCode processAllSubEvents(const EventContext& ctx) override final;
 
private:
    StatusCode initializeRunDependentParameters();
 
    template <class CondType> StatusCode retrieveCondData(const EventContext& ctx,
                                                          const SG::ReadCondHandleKey<CondType>& key,
                                                          const CondType* & condPtr) const;
    using Collections_t = std::vector<std::unique_ptr<RpcDigitCollection> >;
    StatusCode getNextEvent(const EventContext& ctx);
    StatusCode doDigitization(const EventContext& ctx, Collections_t& collections, MuonSimDataCollection* sdoContainer);
    StatusCode fillTagInfo();
    long long int PackMCTruth(float proptime, float tof, float posx, float posz) const;
    static void UnPackMCTruth(double theWord, float& proptime, float& tof, float& posy, float& posz) ;
    std::array<int, 3> physicalClusterSize(const EventContext& ctx,
                                           const MuonGM::RpcReadoutElement* reEle,
                                           const Identifier& id, 
                                           const Amg::Vector3D& posAtCentre,
                                           CLHEP::HepRandomEngine* rndmEngine) const;
    std::array<int, 3> TurnOnStrips(const MuonGM::RpcReadoutElement* reEle,
                                    std::array<int, 3>&& pcs, 
                                    const Identifier& id) const;
    double PropagationTime(const MuonGM::RpcReadoutElement* reEle,
                           const Identifier& id, 
                           const Amg::Vector3D& globPos) const;
    Gaudi::Property<double> m_UncorrJitter{this, "UncorrJitter", 1.5, "jitter uncorrelated between eta and phi"};
    Gaudi::Property<double> m_CorrJitter{this, "CorrJitter", 0.0, "jitter correlated between eta and phi"};
 
    Gaudi::Property<double> m_UncorrJitter_BIS78{this, "UncorrJitter_BIS78", 0.3, "jitter uncorrelated between eta and phi BIS78"};
    Gaudi::Property<double> m_CorrJitter_BIS78{this, "CorrJitter_BIS78", 0.0, "jitter correlated between eta and phi BIS78"};
 
    
    Amg::Transform3D fromSimHitToLayer(const MuonGM::RpcReadoutElement* readOutEle,
                                       const Identifier& layerId) const;
 
 
    // pile-up
    bool outsideWindow(double time) const;
    Gaudi::Property<double> m_timeWindowLowerOffset{this, "WindowLowerOffset", -100., "digitization window lower limit"};
    Gaudi::Property<double> m_timeWindowUpperOffset{this, "WindowUpperOffset", +150., "digitization window lower limit"};
 
    std::pair<bool, bool> detectionEfficiency(const EventContext& ctx, 
                                              const Identifier& ideta, 
                                              const Identifier& idphi, 
                                              CLHEP::HepRandomEngine* rndmEngine, 
                                              const HepMcParticleLink& trkParticle) const;
 
    
    double FCPEfficiency(const HepMC::ConstGenParticlePtr& genParticle) const;
    int determineClusterSize(const EventContext& ctx, 
                             const Identifier& id, 
                             double xstripnorm, 
                             CLHEP::HepRandomEngine* rndmEngine) const;
 
    SG::ReadCondHandleKey<MuonGM::MuonDetectorManager> m_detMgrKey {this, "DetectorManagerKey",  "MuonDetectorManager", 
                                                            "Key of input MuonDetectorManager condition data"};
    const RpcIdHelper* m_idHelper{};
    const RpcHitIdHelper* m_muonHelper{};
    std::vector<std::unique_ptr<RPCSimHitCollection>> m_RPCHitCollList;
    std::unique_ptr<TimedHitCollection<RPCSimHit>> m_thpcRPC{};
    SG::ReadCondHandleKey<RpcCondDbData> m_readKey{this, "ReadKey", "RpcCondDbData", "Key of RpcCondDbData"};
    std::map<Identifier, std::vector<MuonSimData::Deposit>> m_sdo_tmp_map;
    Gaudi::Property<int> m_deadTime{this, "DeadTime", 100., "dead time"};
    Gaudi::Property<bool> m_patch_for_rpc_time{this, "PatchForRpcTime", false, ""};
    Gaudi::Property<double> m_rpc_time_shift{this, "PatchForRpcTimeShift", 12.5,
                                             "shift rpc digit time to match hardware time calibration: Zmumu muons are at the center of "
                                             "BC0, i.e. at 12.5ns+BC0shift w.r.t. RPC readout (BC0shift=2x3.125)"};
 
    Gaudi::Property<bool> m_validationSetup{this, "ValidationSetup", false, ""};
    Gaudi::Property<bool> m_includePileUpTruth{this, "IncludePileUpTruth", true, "pileup truth veto"};
 
    Gaudi::Property<bool> m_turnON_efficiency{this, "turnON_efficiency", true, ""};
    Gaudi::Property<bool> m_kill_deadstrips{this, "KillDeadStrips", false, ""};              // gabriele
    Gaudi::Property<bool> m_turnON_clustersize{this, "turnON_clustersize", true, ""};
    Gaudi::Property<int> m_FirstClusterSizeInTail{this, "FirstClusterSizeInTail", 3, ""};
 
    Gaudi::Property<std::vector<float>> m_PhiAndEtaEff_A{this, "PhiAndEtaEff_A", {}, ""};
    Gaudi::Property<std::vector<float>> m_OnlyPhiEff_A{this, "OnlyPhiEff_A", {}, ""};
    Gaudi::Property<std::vector<float>> m_OnlyEtaEff_A{this, "OnlyEtaEff_A", {}, ""};
    Gaudi::Property<std::vector<float>> m_PhiAndEtaEff_C{this, "PhiAndEtaEff_C", {}, ""};
    Gaudi::Property<std::vector<float>> m_OnlyPhiEff_C{this, "OnlyPhiEff_C", {}, ""};
    Gaudi::Property<std::vector<float>> m_OnlyEtaEff_C{this, "OnlyEtaEff_C", {}, ""};
 
    Gaudi::Property<float> m_PhiAndEtaEff_BIS78{this, "PhiAndEtaEff_BIS78", 0.93, ""};
    Gaudi::Property<float> m_OnlyEtaEff_BIS78{this, "OnlyEtaEff_BIS78", 0.96, ""};
    Gaudi::Property<float> m_OnlyPhiEff_BIS78{this, "OnlyPhiEff_BIS78", 0.96, ""};
 
    Gaudi::Property<std::vector<double>> m_FracClusterSize1_A{this, "FracClusterSize1_A", {}, ""};
    Gaudi::Property<std::vector<double>> m_FracClusterSize2_A{this, "FracClusterSize2_A", {}, ""};
    Gaudi::Property<std::vector<double>> m_FracClusterSizeTail_A{this, "FracClusterSizeTail_A", {}, ""};
    Gaudi::Property<std::vector<double>> m_MeanClusterSizeTail_A{this, "MeanClusterSizeTail_A", {}, ""};
 
    Gaudi::Property<std::vector<double>> m_FracClusterSize1_C{this, "FracClusterSize1_C", {}, ""};
    Gaudi::Property<std::vector<double>> m_FracClusterSize2_C{this, "FracClusterSize2_C", {}, ""};
    Gaudi::Property<std::vector<double>> m_FracClusterSizeTail_C{this, "FracClusterSizeTail_C", {}, ""};
    Gaudi::Property<std::vector<double>> m_MeanClusterSizeTail_C{this, "MeanClusterSizeTail_C", {}, ""};
 
    Gaudi::Property<float> m_FracClusterSize1_BIS78{this, "FracClusterSize1_BIS78", 0.60, ""};
    Gaudi::Property<float> m_FracClusterSize2_BIS78{this, "FracClusterSize2_BIS78", 0.35, ""};
    Gaudi::Property<float> m_FracClusterSizeTail_BIS78{this, "FracClusterSizeTail_BIA78", 0.05, ""};
    Gaudi::Property<float> m_MeanClusterSizeTail_BIS78{this, "MeanClusterSizeTail_BIA78", 3.5, ""};
 
 
 
    Gaudi::Property<bool> m_muonOnlySDOs{this, "MuonOnlySDOs", true, ""};
 
    static double timeOverThreshold(CLHEP::HepRandomEngine* rndmEngine) ;
    
protected:
    ServiceHandle<PileUpMergeSvc> m_mergeSvc{this, "PileUpMergeSvc", "PileUpMergeSvc", "Pile up service"};
    Gaudi::Property<bool> m_onlyUseContainerName{this, "OnlyUseContainerName", true,
                                                 "Don't use the ReadHandleKey directly. Just extract the container name from it."};
    SG::ReadHandleKey<RPCSimHitCollection> m_hitsContainerKey{this, "InputObjectName", "RPC_Hits", "name of the input object"};
    std::string m_inputHitCollectionName{""};
    SG::WriteHandleKey<RpcDigitContainer> m_outputDigitCollectionKey{
        this, "OutputObjectName", "RPC_DIGITS", "WriteHandleKey for Output RpcDigitContainer"};  // name of the output digits
    SG::WriteHandleKey<MuonSimDataCollection> m_outputSDO_CollectionKey{
        this, "OutputSDOName", "RPC_SDO", "WriteHandleKey for Output MuonSimDataCollection"};  // name of the output SDOs
 
    SG::WriteHandleKey<RPCSimHitCollection> m_simHitValidKey{this, "SimHitValidationKey", "InputRpcHits"};
    ServiceHandle<IAthRNGSvc> m_rndmSvc{this, "RndmSvc", "AthRNGSvc", ""};  // Random number service
 
    Gaudi::Property<std::string> m_RPC_TimeSchema{this, "RPC_TimeSchema", "RPC_TimeSchema", "Tag info name of Rpc Time Info"};
    Gaudi::Property<bool> m_sdoAreOnlyDigits{this, "RPCSDOareRPCDigits", true,
                                             "decide is SDO deposits are saved for all G4 hits or only for those accepted as digits"};
 
    Gaudi::Property<bool> m_Efficiency_fromCOOL{this, "Efficiency_fromCOOL", false, "Read efficiency from CoolDB"};
    Gaudi::Property<bool> m_EfficiencyPatchForBMShighEta{this, "EfficiencyPatchForBMShighEta", false,
                                                         "special patch to be true only when m_Efficiency_fromCOOL=true and "
                                                         "/RPC/DQMF/ELEMENT_STATUS tag is RPCDQMFElementStatus_2012_Jaunuary_26"};
    Gaudi::Property<bool> m_ClusterSize_fromCOOL{this, "ClusterSize_fromCOOL", false, "Read cluster size from CoolDB"};
    Gaudi::Property<bool> m_ClusterSize1_2uncorr{this, "ClusterSize1_2uncorr", false,
                                                 "Cluster size 1 and 2 not correlated to track position"};
    Gaudi::Property<bool> m_BOG_BOF_DoubletR2_OFF{this, "Force_BOG_BOF_DoubletR2_OFF", false, "Turn-off BOG and BOF with DoubletR=2"};
    Gaudi::Property<bool> m_ignoreRunDepConfig{this, "IgnoreRunDependentConfig", false,
                                               "true if we want to force the RUN1/RUN2 dependent options"};
    Gaudi::Property<bool> m_Efficiency_BIS78_fromCOOL{this, "Efficiency_BIS78_fromCOOL", false, " read BIS78 Efficiency from COOL DB"};
    Gaudi::Property<bool> m_ClusterSize_BIS78_fromCOOL{this, "ClusterSize_BIS78_fromCOOL", false, " read BIS78 Cluster Size from COOL DB"};
 
 
    Gaudi::Property<bool> m_RPCInfoFromDb{this, "RPCInfoFromDb", false, ""};
    Gaudi::Property<float> m_CutMaxClusterSize{this, "CutMaxClusterSize", 5.0, ""};
    Gaudi::Property<int> m_CutProjectedTracks{this, "CutProjectedTracks", 100, ""};
 
    int m_BOF_id{-1};
    int m_BOG_id{-1};
    int m_BOS_id{-1};
 
    int m_BIL_id{-1};
    int m_BIS_id{-1};
 
};
 
inline bool RpcDigitizationTool::outsideWindow(double time) const {
    return time < m_timeWindowLowerOffset || time > m_timeWindowUpperOffset;
}
#endif  // RpcDigitizationTool