MuonDigitization/MDT_Digitization/src/MdtDigitizationTool.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
*/

#ifndef MUONDIGITIZATION_MDT_DIGITIZATIONTOOL_H
#define MUONDIGITIZATION_MDT_DIGITIZATIONTOOL_H
 
#include <sstream>
#include <string>
#include <vector>
 
#include "AthenaKernel/IAthRNGSvc.h"
#include "CLHEP/Geometry/Point3D.h"
#include "CLHEP/Random/RandGaussZiggurat.h"
#include "CLHEP/Random/RandomEngine.h"
#include "GaudiKernel/PhysicalConstants.h"
#include "GaudiKernel/ServiceHandle.h"
#include "GaudiKernel/ToolHandle.h"
#include "HitManagement/TimedHitCollection.h"
#include "Identifier/Identifier.h"
#include "MDT_Digitization/IMDT_DigitizationTool.h"
#include "MDT_Digitization/MDT_SortedHitVector.h"
#include "MDT_Response/MDT_Response.h"
#include "MuonCondData/MdtCondDbData.h"
#include "MuonIdHelpers/IMuonIdHelperSvc.h"
#include "MuonSimEvent/MDTSimHit.h"
#include "MdtCalibData/MdtCalibDataContainer.h"
#include "MuonSimEvent/MDTSimHitCollection.h"
#include "PileUpTools/PileUpMergeSvc.h"
#include "PileUpTools/PileUpToolBase.h"
#include "xAODEventInfo/EventInfo.h"     // NEW EDM
 
// Outputs
#include "MuonDigitContainer/MdtDigitContainer.h"
#include "MuonSimData/MuonSimData.h"
#include "MuonSimData/MuonSimDataCollection.h"
 
namespace MuonGM {
    class MuonDetectorManager;
    class MdtReadoutElement;
}  // namespace MuonGM
 
class MdtHitIdHelper;
// Digitization class for MDT hits
/*
  +DSL--------------------------------------------------------------------------
  The drift time can be modified according to the amount of wire sag,
  the track angle, the distance from the end of the tube, the tube length, the
  chamber phi angle. This drift time delta is turned on/off via  m_useWireSagRT
  It operates only on small wheel and big wheel end cap chambers (EIL/EIS; EML/EMS)
  The EOL/EOS chambers are presumably built with tubes bent to conform to the wire sag-
  so this code does not introduce wire-sag induced RT distortions for these chambers
 
  -DSL----------------------------------------------------------------------------
 
*/
class MuonSimDataCollection;
 
class MdtDigitizationTool : public PileUpToolBase {
public:
    MdtDigitizationTool(const std::string& type, const std::string& name, const IInterface* pIID);
    virtual ~MdtDigitizationTool() = default;

    virtual StatusCode initialize() override final;

    StatusCode prepareEvent(const EventContext& ctx, const unsigned int /*nInputEvents*/) override final;

    virtual StatusCode processBunchXing(int bunchXing, SubEventIterator bSubEvents, SubEventIterator eSubEvents) override final;
    StatusCode mergeEvent(const EventContext& ctx) override final;

    virtual StatusCode processAllSubEvents(const EventContext& ctx) override final;
 
    struct GeoCorOut {
        GeoCorOut(double sSag, double sTrack, Amg::Vector3D lp, double lSag) :
            sagSign(sSag), trackingSign(sTrack), localPosition(lp), localSag(lSag) {}
        double sagSign;               // sign indicating wether the particle passed above or below the wire
        double trackingSign;          // sign in tracking convention indicating whether the particle passed left ot right of the wire
        Amg::Vector3D localPosition;  // point of closest approach of the particle to the wire
        double localSag;
    };
 
private:
    using Collections_t = std::vector<std::unique_ptr<MdtDigitCollection> >;
    CLHEP::HepRandomEngine* getRandomEngine(const std::string& streamName, const EventContext& ctx) const;
    int digitizeTime(double time, bool isHPTDC, CLHEP::HepRandomEngine* rndmEngine) const;
    double minimumTof(Identifier DigitId, const MuonGM::MuonDetectorManager* detMgr) const;
 
    bool insideMatchingWindow(double time) const;
    bool insideMaskWindow(double time) const;
    bool checkMDTSimHit(const EventContext& ctx, const MDTSimHit& hit) const;
 
    bool handleMDTSimHit(const EventContext& ctx, const TimedHitPtr<MDTSimHit>& phit, CLHEP::HepRandomEngine* twinRndmEngine,
                         CLHEP::HepRandomEngine* toolRndmEngine);
    bool createDigits(const EventContext& ctx, Collections_t& collections, MuonSimDataCollection* sdoContainer, CLHEP::HepRandomEngine* rndmEngine);
 
    // calculate local hit position in local sagged wire frame, also returns whether the hit passed above or below the wire
    GeoCorOut correctGeometricalWireSag(const MDTSimHit& hit, const Identifier& id, const MuonGM::MdtReadoutElement* element) const;
 
    MDT_SortedHitVector m_hits;
 
    ServiceHandle<Muon::IMuonIdHelperSvc> m_idHelperSvc{this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"};
    const MdtHitIdHelper* m_muonHelper{};
 
    static MDTSimHit applyDeformations(const MDTSimHit&, const MuonGM::MdtReadoutElement*, const Identifier&) ;
 
    const MuonGM::MuonDetectorManager* m_MuonGeoMgr{};
 
    ToolHandle<IMDT_DigitizationTool> m_digiTool{this, "DigitizationTool", "MDT_Response_DigiTool",
                                                 "Tool which handle the digitization process"};
    std::vector<MDTSimHitCollection*> m_MDTHitCollList;
 
    // TDC ELECTRONICS
    Gaudi::Property<double> m_offsetTDC{this, "OffsetTDC", 800., "TDC offset used if no calibration data is found"};
    Gaudi::Property<double> m_signalSpeed{this, "SignalSpeed", 0.85*Gaudi::Units::c_light};
 
    Gaudi::Property<double> m_ns2TDCAMT{this, "ns2TDCAMT", 0.78125, "Conversion factor TDC/ns for AMT chips"};
    Gaudi::Property<double> m_ns2TDCHPTDC{this, "ns2TDCHPTDC", 0.1953125, "Conversion factor TDC/ns for HPTDC chips"};
    Gaudi::Property<double> m_resTDC{this, "ResolutionTDC", 0.5, "TDC resolution"};
    Gaudi::Property<double> m_t0ShiftTuning{this,"TunedT0Shift",-17.,"Fine tuned t0 shift value in ns"};
 
    // CONFIGURATION
    Gaudi::Property<bool> m_checkMDTSimHits{this, "CheckSimHits", true, "Control on the hit validity"};
    Gaudi::Property<bool> m_useTof{this, "UseTof", true, "Option for the tof calculation"};
    Gaudi::Property<bool> m_useAttenuation{this, "UseAttenuation", false, ""};
    Gaudi::Property<bool> m_useProp{this, "UseProp", true, ""};
 
    // TWIN TUBE
    Gaudi::Property<bool> m_useTwin{this, "UseTwin", false, ""};
    Gaudi::Property<bool> m_useAllBOLTwin{this, "UseAllBOLTwin", false, ""};
    Gaudi::Property<double> m_resTwin{this, "ResolutionTwinTube", 1.05, "Twin Tube resolution"};
 
    // TIMING SCHEME
    Gaudi::Property<bool> m_useTimeWindow{this, "UseTimeWindow", true, ""};
    Gaudi::Property<double> m_bunchCountOffset{this, "BunchCountOffset", -200., "Bunch crossing offset"};
    Gaudi::Property<double> m_matchingWindow{this, "MatchingWindow", 1000., "Matching window"};
    Gaudi::Property<double> m_maskWindow{this, "MaskWindow", 250., "Masked window"};
    Gaudi::Property<double> m_deadTime{this, "DeadTime", 700., "MDT drift tube dead time"};
    Gaudi::Property<bool> m_DiscardEarlyHits{this, "DiscardEarlyHits", true, ""};
 
    // COSMICS
    Gaudi::Property<bool> m_useOffSet1{this, "UseOffSet1", true, ""};
    Gaudi::Property<bool> m_useOffSet2{this, "UseOffSet2", true, ""};
 
 
    // B-lines
    Gaudi::Property<bool> m_useDeformations{this, "UseDeformations", false, ""};
 
    // MULTI-CHARGE PARTICLES DIGITIZATION
    Gaudi::Property<bool> m_DoQballCharge{this, "DoQballCharge", false, "dEdx for Qballs with account of electric charge"};
 
    // pile-up
    std::unique_ptr<TimedHitCollection<MDTSimHit>> m_thpcMDT{};  // the hits
 
    // pileup truth veto
    Gaudi::Property<bool> m_includePileUpTruth{this, "IncludePileUpTruth", true, "Include pile-up truth info"};

    // Access to the event methods:
    // Get next event and extract collection of hit collections:
    StatusCode getNextEvent(const EventContext& ctx);
    StatusCode doDigitization(const EventContext& ctx, Collections_t& collections, MuonSimDataCollection* sdoContainer);
    MdtDigitCollection* getDigitCollection(Identifier elementId, Collections_t& collections);
    void fillMaps(const MDTSimHit* mdtHit, const Identifier digitId, const double driftR);
 
protected:
    ServiceHandle<PileUpMergeSvc> m_mergeSvc{this, "PileUpMergeSvc", "PileUpMergeSvc", ""};  // Pile up service
    BooleanProperty m_onlyUseContainerName{this, "OnlyUseContainerName", true,
                                           "Don't use the ReadHandleKey directly. Just extract the container name from it."};
    SG::ReadHandleKey<MDTSimHitCollection> m_hitsContainerKey{this, "InputObjectName", "MDT_Hits", ""};  // name of the input objects
    std::string m_inputObjectName{""};
    SG::WriteHandleKey<MdtDigitContainer> m_outputObjectKey{this, "OutputObjectName", "MDT_DIGITS",
                                                            "WriteHandleKey for Output MdtDigitContainer"};
    SG::WriteHandleKey<MuonSimDataCollection> m_outputSDOKey{this, "OutputSDOName", "MDT_SDO",
                                                             "WriteHandleKey for Output MuonSimDataCollection"};
 
    ServiceHandle<IAthRNGSvc> m_rndmSvc{this, "RndmSvc", "AthRNGSvc", ""};  // Random number service
 
    SG::ReadCondHandleKey<MuonCalib::MdtCalibDataContainer> m_calibDbKey{this, "CalibDataKey", "MdtCalibConstants",
                                                                       "Conditions object containing the calibrations"};
 
    SG::ReadCondHandleKey<MdtCondDbData> m_readKey{this, "ReadKey", "MdtCondDbData", "Key of MdtCondDbData"};
};
 
#endif