#include <MM_DigitizationTool.h>

Inheritance diagram for MM_DigitizationTool:

Collaboration diagram for MM_DigitizationTool:

Public Member Functions
	MM_DigitizationTool (const std::string &type, const std::string &name, const IInterface *parent)

virtual StatusCode	initialize () override final
	Initialize. More...

StatusCode	prepareEvent (const EventContext &ctx, const unsigned int) override final
	When being run from PileUpToolsAlgs, this method is called at the start of the subevts loop. More...

StatusCode	processBunchXing (int bunchXing, SubEventIterator bSubEvents, SubEventIterator eSubEvents) override final
	When being run from PileUpToolsAlgs, this method is called for each active bunch-crossing to process current SubEvents bunchXing is in ns. More...

StatusCode	mergeEvent (const EventContext &ctx) override final
	When being run from PileUpToolsAlgs, this method is called at the end of the subevts loop. More...

virtual StatusCode	processAllSubEvents (const EventContext &ctx) override
	When being run from MM_Digitizer, this method is called during the event loop. More...

StatusCode	digitize (const EventContext &ctx)
	Just calls processAllSubEvents - leaving for back-compatibility (IMuonDigitizationTool) More...

Private Types
using	NoiseCalibConstants = NswCalibDbTimeChargeData::CalibConstants

Private Member Functions
CLHEP::HepRandomEngine *	getRandomEngine (const std::string &streamName, const EventContext &ctx) const

StatusCode	getNextEvent (const EventContext &ctx)
	Record MmDigitContainer and MuonSimDataCollection. More...

StatusCode	doDigitization (const EventContext &ctx)

bool	checkMMSimHit (const MMSimHit &) const

MM_ElectronicsToolInput	combinedStripResponseAllHits (const std::vector< MM_ElectronicsToolInput > &v_stripDigitOutput)

Private Attributes
ServiceHandle< IAthRNGSvc >	m_rndmSvc {this, "RndmSvc", "AthRNGSvc", "Random Number Service used in Muon digitization"}

Gaudi::Property< std::string >	m_rndmEngineName {this, "RndmEngine", "MuonDigitization", "Random engine name"}

ServiceHandle< Muon::IMuonIdHelperSvc >	m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}

ToolHandle< Muon::INSWCalibSmearingTool >	m_smearingTool {this, "SmearingTool", "Muon::NSWCalibSmearingTool/MMCalibSmearingTool"}

ToolHandle< Muon::INSWCalibTool >	m_calibrationTool {this, "CalibrationTool", "Muon::NSWCalibTool/NSWCalibTool"}

SG::ReadCondHandleKey< AtlasFieldCacheCondObj >	m_fieldCondObjInputKey {this, "AtlasFieldCacheCondObj", "fieldCondObj"}

SG::ReadCondHandleKey< NswCalibDbThresholdData >	m_condThrshldsKey

Gaudi::Property< bool >	m_onlyUseContainerName

SG::ReadHandleKey< MMSimHitCollection >	m_hitsContainerKey {this, "InputObjectName", "MM_Hits", "name of the input objects"}

std::string	m_inputObjectName {""}

Gaudi::Property< std::string >	m_vmmReadoutMode {this, "vmmReadoutMode", "peak", "For readout (DAQ) path. Can be peak or threshold"}

Gaudi::Property< std::string >	m_vmmARTMode {this, "vmmARTMode", "threshold", "For ART (trigger) path. Can be peak or threshold"}

Gaudi::Property< double >	m_energyThreshold {this, "EnergyThreshold", 50, "Minimal energy to produce a PRD"}

Gaudi::Property< double >	m_timeWindowLowerOffset

Gaudi::Property< double >	m_timeWindowUpperOffset

Gaudi::Property< double >	m_DiffMagSecondMuonHit {this, "DiffMagSecondMuonHit", 0.1}

Gaudi::Property< int >	m_maskMultiplet {this, "MaskMultiplet", 0, "0: all, 1: first, 2: second, 3: both"}

Gaudi::Property< bool >	m_writeOutputFile {this, "SaveInternalHistos", false}

Gaudi::Property< bool >	m_needsMcEventCollHelper {this, "UseMcEventCollectionHelper", false}

Gaudi::Property< bool >	m_checkMMSimHits {this, "CheckSimHits", true, "Control on the hit validity"}

Gaudi::Property< bool >	m_useTimeWindow {this, "UseTimeWindow", true}

Gaudi::Property< bool >	m_vmmNeighborLogic {this, "VMMNeighborLogic", false}

Gaudi::Property< bool >	m_doSmearing

Gaudi::Property< float >	m_qThreshold {this, "qThreshold", 0.001, "Charge Threshold"}

Gaudi::Property< float >	m_driftGapWidth {this, "DriftGapWidth", 5.04, "Drift Gap Width of 5.04 mm"}

Gaudi::Property< float >	m_crossTalk1 {this, "crossTalk1", 0.3, "Strip Cross Talk with Nearest Neighbor"}

Gaudi::Property< float >	m_crossTalk2 {this, "crossTalk2", 0.09, "Strip Cross Talk with 2nd Nearest Neighbor"}

Gaudi::Property< float >	m_avalancheGain {this, "AvalancheGain", 6.0e3, "avalanche Gain for rach gas mixture"}

Gaudi::Property< float >	m_electronicsThreshold

Gaudi::Property< float >	m_stripdeadtime {this, "StripDeadTime", 200, "dead-time for strip, default value 200 ns = 8 BCs"}

Gaudi::Property< float >	m_ARTdeadtime {this, "ARTDeadTime", 200, "dead-time for ART, default value 200 ns = 8 BCs"}

SG::WriteHandleKey< MmDigitContainer >	m_outputDigitCollectionKey

SG::WriteHandleKey< MuonSimDataCollection >	m_outputSDO_CollectionKey

ServiceHandle< PileUpMergeSvc >	m_mergeSvc {this, "MergeSvc", "PileUpMergeSvc", "Merge service used in digitization"}

Gaudi::Property< bool >	m_useCondThresholds

Gaudi::Property< bool >	m_useThresholdScaling

Gaudi::Property< float >	m_thresholdScaleFactor

Gaudi::Property< float >	m_vmmDeadtime

Gaudi::Property< float >	m_vmmUpperGrazeWindow

const MicromegasHitIdHelper *	m_muonHelper {nullptr}

SG::ReadCondHandleKey< MuonGM::MuonDetectorManager >	m_DetectorManagerKey

std::list< std::unique_ptr< MMSimHitCollection > >	m_MMHitCollList {}

std::unique_ptr< TimedHitCollection< MMSimHit > >	m_timedHitCollection_MM {}

std::unique_ptr< MM_StripsResponseSimulation >	m_StripsResponseSimulation {}

std::unique_ptr< MM_ElectronicsResponseSimulation >	m_ElectronicsResponseSimulation {}

std::map< int, NoiseCalibConstants >	m_noiseParams {}
	Define a map to cache the noise parameters individually Key: stationName * std::abs(stationEta) More...

structors and AlgTool implementation
virtual bool	toProcess (int bunchXing) const override
	the method this base class helps implementing More...

virtual StatusCode	processAllSubEvents (const EventContext &ctx)=0
	dummy implementation to allow compilation while all Digitization packages are migrated to use this new interface. More...

virtual bool	filterPassed () const override
	dummy implementation of passing filter More...

virtual void	resetFilter () override
	dummy implementation of filter reset More...

Gaudi::Property< int >	m_firstXing

Gaudi::Property< int >	m_lastXing

Gaudi::Property< int >	m_vetoPileUpTruthLinks

bool	m_filterPassed {true}

Detailed Description

@section MM_DigitizerDetails Class methods and properties

Authors: Nektarios Chr. Benekos necta.nosp@m.rios.nosp@m..bene.nosp@m.kos@.nosp@m.cern..nosp@m.ch Konstantinos Karakostas Konst.nosp@m.anti.nosp@m.nos.K.nosp@m.arak.nosp@m.ostas.nosp@m.@cer.nosp@m.n.ch //////////////////////////////////////////////////////////////////////////////

    In the initialize() method, the PileUpMerge and StoreGate services are initialized, and a pointer to an instance of the class
    MuonDetectorManager is retrieved from the detector store and used to obtain a MmIdHelper.
    The MMDigitContainer is initialized and the simulation identifier helper retrieved, together with the pointer to the digitization

tool. Random numbers are obtained in the code from a dedicated stream via AtRndmSvc, which is also initialized in the initialize() method. In the execute() method, the digits and the SDOs (Simulation Data Object, container for simulation data to be preserved after the digitization procedue, and persistified together with the RDOs) containers are created and recorded on StoreGate; the MMSimHit collection are merged using the TimedHitCollection sorted container (done in handleMicroMegasSimhit(TimedHitPtr<MMSimHit>& hit)) method); into a loop over the TimedHitCollection for the given DetectorElement, the handleMicroMegasSimhit() method converts the SimID into the Offline ID to be associated to the Digit and pass to the digitization tool the drift radius and the distance to the chamber RO side (for the propagation delay computation). The digitization tool returns a drift time, charge and strip position which are used together with the Offline ID, to create the digit object (in doDigitization() method). The finalize() method returns a SUCCESS StatusCode if the digitization procedure ends succesfully.

 In the initialize() method...
 In the execute() method...

Definition at line 76 of file MM_DigitizationTool.h.

Member Typedef Documentation

◆ NoiseCalibConstants

using MM_DigitizationTool::NoiseCalibConstants = NswCalibDbTimeChargeData::CalibConstants

private

Definition at line 198 of file MM_DigitizationTool.h.

Constructor & Destructor Documentation

◆ MM_DigitizationTool()

MM_DigitizationTool::MM_DigitizationTool	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	parent
	)

Definition at line 65 of file MM_DigitizationTool.cxx.

65 :

66 PileUpToolBase(type, name, parent) {}

Member Function Documentation

◆ checkMMSimHit()

bool MM_DigitizationTool::checkMMSimHit ( const MMSimHit & ) const

private

Definition at line 895 of file MM_DigitizationTool.cxx.

895 { return true; }

◆ combinedStripResponseAllHits()

MM_ElectronicsToolInput MM_DigitizationTool::combinedStripResponseAllHits ( const std::vector< MM_ElectronicsToolInput > & v_stripDigitOutput )

private

Definition at line 818 of file MM_DigitizationTool.cxx.

                                                                                                                                       {
     // set up pointer to conditions object
     const EventContext& ctx = Gaudi::Hive::currentContext();
     
     const NswCalibDbThresholdData* thresholdData {nullptr};
     if(m_useCondThresholds){
         SG::ReadCondHandle<NswCalibDbThresholdData> readThresholds{m_condThrshldsKey, ctx};
         if (!readThresholds.isValid()) { ATH_MSG_ERROR("Cannot find conditions data container for VMM thresholds!"); }
         thresholdData = readThresholds.cptr();
     }
  
     SG::ReadCondHandle<MuonGM::MuonDetectorManager> muonGeoMgrHandle{m_DetectorManagerKey, ctx};
     if (!muonGeoMgrHandle.isValid()) { ATH_MSG_FATAL("Failed to retrieve the detector manager from the conditiosn store"); }
     const MuonGM::MuonDetectorManager* muonGeoMgr = *muonGeoMgrHandle;
  
     std::vector<int> v_stripStripResponseAllHits;
     std::vector<std::vector<float>> v_timeStripResponseAllHits;
     std::vector<std::vector<float>> v_qStripResponseAllHits;
     std::vector<float> v_stripThresholdResponseAllHits;
  
     Identifier digitID = v_stripDigitOutput.at(0).digitID();
     float max_kineticEnergy = 0.0;
  
     // Loop over strip digit output elements
     for (auto& i_stripDigitOutput : v_stripDigitOutput) {
         //--- Just to get Digit id with the largest kinetic energy, but the Digit id is no longer meaningful
         if (i_stripDigitOutput.kineticEnergy() > max_kineticEnergy) {
             digitID = i_stripDigitOutput.digitID();
             max_kineticEnergy = i_stripDigitOutput.kineticEnergy();
         }
         //---
         for (size_t i = 0; i < i_stripDigitOutput.NumberOfStripsPos().size(); ++i) {
             int strip_id = i_stripDigitOutput.NumberOfStripsPos().at(i);
             bool found = false;
  
             for (size_t ii = 0; ii < v_stripStripResponseAllHits.size(); ++ii) {
                 if (v_stripStripResponseAllHits.at(ii) == strip_id) {
                     for (size_t iii = 0; iii < i_stripDigitOutput.chipTime().at(i).size(); ++iii) {
                         v_timeStripResponseAllHits.at(ii).push_back(i_stripDigitOutput.chipTime().at(i).at(iii));
                         v_qStripResponseAllHits.at(ii).push_back(i_stripDigitOutput.chipCharge().at(i).at(iii));
                     }
                     found = true;
                 }
             }
             if (!found) {  // strip id not in vector, add new entry
                 v_stripStripResponseAllHits.push_back(strip_id);
                 v_timeStripResponseAllHits.push_back(i_stripDigitOutput.chipTime().at(i));
                 v_qStripResponseAllHits.push_back(i_stripDigitOutput.chipCharge().at(i));
                 if (m_useCondThresholds) {
                     const Identifier id = m_idHelperSvc->mmIdHelper().channelID(digitID, m_idHelperSvc->mmIdHelper().multilayer(digitID),
                                                                                 m_idHelperSvc->mmIdHelper().gasGap(digitID), strip_id);
                     float threshold = 0;
                     if (!thresholdData->getThreshold(id, threshold))
                         ATH_MSG_ERROR("Cannot find retrieve VMM threshold from conditions data base!");
                     v_stripThresholdResponseAllHits.push_back(threshold);
                 } else if (m_useThresholdScaling) {
                     Identifier id = m_idHelperSvc->mmIdHelper().channelID(digitID, m_idHelperSvc->mmIdHelper().multilayer(digitID),
                                                                           m_idHelperSvc->mmIdHelper().gasGap(digitID), strip_id);
                     const MuonGM::MMReadoutElement* detectorReadoutElement = muonGeoMgr->getMMReadoutElement(id);
                     float stripLength = detectorReadoutElement->stripLength(id);
                     const int noise_id = m_idHelperSvc->stationName(digitID) * std::abs(m_idHelperSvc->stationEta(digitID));
                     const NoiseCalibConstants& noise = m_noiseParams.at(noise_id);
                     float threshold = (noise.slope * stripLength + noise.intercept) * m_thresholdScaleFactor;
                     v_stripThresholdResponseAllHits.push_back(threshold);
                 } else {
                     v_stripThresholdResponseAllHits.push_back(m_electronicsThreshold);
                 }
             }
         }
     }
  
     MM_ElectronicsToolInput stripDigitOutputAllHits(v_stripStripResponseAllHits, v_qStripResponseAllHits, v_timeStripResponseAllHits,
                                                     v_stripThresholdResponseAllHits, digitID, max_kineticEnergy);
  
     return stripDigitOutputAllHits;
 }

◆ digitize()

StatusCode MM_DigitizationTool::digitize ( const EventContext & ctx )

Just calls processAllSubEvents - leaving for back-compatibility (IMuonDigitizationTool)

Definition at line 396 of file MM_DigitizationTool.cxx.

396 { return this->processAllSubEvents(ctx); }

◆ doDigitization()

StatusCode MM_DigitizationTool::doDigitization ( const EventContext & ctx )

private

check if the hit has to be dropped, based on efficiency

move the initial track point to the readout plane

use the smearing tool to update time and charge

Definition at line 413 of file MM_DigitizationTool.cxx.

                                                                       {
     CLHEP::HepRandomEngine* rndmEngine = getRandomEngine(m_rndmEngineName, ctx);
  
     SG::ReadCondHandle<MuonGM::MuonDetectorManager> muonGeoMgrHandle{m_DetectorManagerKey, ctx};
     if (!muonGeoMgrHandle.isValid()) {
         ATH_MSG_FATAL("Failed to retrieve the detector manager from the conditiosn store");
         return StatusCode::FAILURE;
     }
     const MuonGM::MuonDetectorManager* muonGeoMgr = *muonGeoMgrHandle;
  
     // create and record the Digit container in StoreGate
     SG::WriteHandle<MmDigitContainer> digitContainer(m_outputDigitCollectionKey, ctx);
     ATH_CHECK(digitContainer.record(std::make_unique<MmDigitContainer>(m_idHelperSvc->mmIdHelper().detectorElement_hash_max())));
     ATH_MSG_DEBUG("MmDigitContainer recorded in StoreGate.");
  
     // Create and record the SDO container in StoreGate
     SG::WriteHandle<MuonSimDataCollection> sdoContainer(m_outputSDO_CollectionKey, ctx);
     ATH_CHECK(sdoContainer.record(std::make_unique<MuonSimDataCollection>()));
     ATH_MSG_DEBUG("MmSDOCollection recorded in StoreGate.");
  
  
     if (m_maskMultiplet == 3) { return StatusCode::SUCCESS; }
  
     // Perform null check on m_thpcCSC
     if (!m_timedHitCollection_MM) {
         ATH_MSG_ERROR("m_timedHitCollection_MM is null");
         return StatusCode::FAILURE;
     }
  
  
     // iterate over hits and fill id-keyed drift time map
     TimedHitCollection<MMSimHit>::const_iterator i, e;
  
     std::vector<std::unique_ptr<MmDigitCollection> > collections;
  
     // nextDetectorElement-->sets an iterator range with the hits of current detector element , returns a bool when done
     const MmIdHelper& idHelper{m_idHelperSvc->mmIdHelper()};
     while (m_timedHitCollection_MM->nextDetectorElement(i, e)) {
         Identifier layerID;
         std::vector<MM_ElectronicsToolInput> v_stripDigitOutput;  
  
         // Loop over the hits:
         while (i != e) {
             //
             // Hit Information And Preparation
             //           
             TimedHitPtr<MMSimHit> phit = *i++;
             const double eventTime = phit.eventTime();
             const MMSimHit& hit(*phit);
  
             const double hitKineticEnergy = hit.kineticEnergy();
             if (hitKineticEnergy <= 0) continue;
  
             const Amg::Vector3D& globalHitPosition = hit.globalPosition();
  
             const double globalHitTime = hit.globalTime();
             const double tofCorrection = globalHitPosition.mag() / CLHEP::c_light;
             const double bunchTime = globalHitTime - tofCorrection + eventTime;
  
             const int hitID = hit.MMId();
             // the G4 time or TOF from IP
             // double G4Time(hit.globalTime());
             // see what are the members of MMSimHit
  
             // convert sim id helper to offline id
             MM_SimIdToOfflineId simToOffline(&idHelper);
  
             // get the hit Identifier and info
             int simId = hit.MMId();
             layerID = simToOffline.convert(simId);
  
             if (m_doSmearing) {
                 bool acceptHit = true;
                 ATH_CHECK(m_smearingTool->isAccepted(layerID, acceptHit,rndmEngine));
                 if (!acceptHit) {
                     ATH_MSG_DEBUG("Dropping the hit - smearing tool");
                     continue;
                 }
             }
             const HepMcParticleLink particleLink = HepMcParticleLink::getRedirectedLink(phit->particleLink(), phit.eventId(), ctx); // This link should now correctly resolve to the TruthEvent McEventCollection in the main StoreGateSvc.
             // Read the information about the Micro Megas hit
             ATH_MSG_DEBUG("> hitID  " << hitID << " Hit bunch time  " << bunchTime << " tot " << globalHitTime << " tof/G4 time "
                                       << hit.globalTime() << " globalHitPosition " << globalHitPosition << "hit: r "
                                       << globalHitPosition.perp() << " z " << globalHitPosition.z() << " mclink " << particleLink
                                       << m_idHelperSvc->toStringGasGap(layerID));
  
             // For collection of inputs to throw back in SG
  
             // remove hits in masked multiplet
             if (m_maskMultiplet == idHelper.multilayer(layerID)) continue;
  
             //
             // Hit Information And Preparation
             //
  
             //
             // Sanity Checks
             //
             if (!m_idHelperSvc->isMM(layerID)) {
                 ATH_MSG_WARNING("layerID does not represent a valid MM layer: "<< m_idHelperSvc->toString(layerID));
                 continue;
             }
  
             // get readout element
             const MuonGM::MMReadoutElement* detectorReadoutElement = muonGeoMgr->getMMReadoutElement(layerID);
             if (!detectorReadoutElement) {
                 ATH_MSG_WARNING("Failed to retrieve detector element for: " << m_idHelperSvc->toString(layerID));
                 continue;
             }
             const std::array<int, 4>& readoutSide=detectorReadoutElement->getReadoutSide();
  
             //
             // Sanity Checks
             //
  
             const std::string stName = m_idHelperSvc->stationNameString(layerID);
  
         
             //
             // Angles, Geometry, and Coordinates. Oh my!
             //
  
             // Surface
             const Trk::PlaneSurface& surf = detectorReadoutElement->surface(layerID);
  
             // Calculate The Inclination Angle
             // Angle
             const Amg::Vector3D globalHitDirection = hit.globalDirection();
             Trk::LocalDirection localHitDirection;
             surf.globalToLocalDirection(globalHitDirection, localHitDirection);
  
             // This is not an incident angle yet. It's atan(z/x),
             // ... so it's the complement of the angle w.r.t. a vector normal to the detector surface
             float inAngleCompliment_XZ = localHitDirection.angleXZ() / CLHEP::degree;
             float inAngleCompliment_YZ = localHitDirection.angleYZ() / CLHEP::degree;
  
             // This is basically to handle the atan ambiguity
             if (inAngleCompliment_XZ < 0.0) inAngleCompliment_XZ += 180;
             if (inAngleCompliment_YZ < 0.0) inAngleCompliment_YZ += 180;
  
             // This gets the actual incidence angle from its complement.
             float inAngle_XZ = 90. - inAngleCompliment_XZ;
             float inAngle_YZ = 90. - inAngleCompliment_YZ;
  
             ATH_MSG_DEBUG("At eta: " << m_idHelperSvc->toString(layerID)
                                      << " Readout Side: " << (readoutSide).at(m_muonHelper->GetLayer(simId) - 1)
                                      << " Layer: " << m_muonHelper->GetLayer(simId) << "\n\t\t\t inAngle_XZ (degrees): " << inAngle_XZ
                                      << " inAngle_YZ (degrees): " << inAngle_YZ);
  
             // compute the hit position on the readout plane (same as in MuonFastDigitization)
             Amg::Vector3D stripLayerPosition = surf.transform().inverse() * globalHitPosition;
             Amg::Vector2D positionOnSurfaceUnprojected{stripLayerPosition.x(), stripLayerPosition.y()};
  
             Amg::Vector3D localDirection = surf.transform().inverse().linear() * globalHitDirection;
             Amg::Vector3D localDirectionTime{Amg::Vector3D::Zero()};
  
             // drift direction in backwards-chamber should be opposite to the incident direction.
             if ((readoutSide).at(idHelper.gasGap(layerID) - 1) == 1) {
                 localDirectionTime = localDirection;
                 inAngle_XZ = (-inAngle_XZ);
             } else
                 localDirectionTime = surf.transform().inverse().linear() * globalHitDirection;
  
             int gasGap = idHelper.gasGap(layerID);
             double shift = 0.5 * detectorReadoutElement->getDesign(layerID)->thickness;
             double scale = 0.0;
             if (gasGap == 1 || gasGap == 3) {
                 scale = -(stripLayerPosition.z() + shift) / localDirection.z();
             } else if (gasGap == 2 || gasGap == 4) {
                 scale = -(stripLayerPosition.z() - shift) / localDirection.z();
             }
  
             const Amg::Vector3D hitOnSurface = stripLayerPosition + scale * localDirection;
             Amg::Vector2D positionOnSurface{hitOnSurface.x(), hitOnSurface.y()};
  
             // Account For Time Offset
             double shiftTimeOffset = (globalHitTime - tofCorrection) * m_StripsResponseSimulation->getDriftVelocity();
             Amg::Vector3D hitAfterTimeShift(hitOnSurface.x(), hitOnSurface.y(), shiftTimeOffset);
             Amg::Vector3D hitAfterTimeShiftOnSurface = hitAfterTimeShift - (shiftTimeOffset / localDirectionTime.z()) * localDirectionTime;
  
             if (std::abs(hitAfterTimeShiftOnSurface.z()) > 0.1)
                 ATH_MSG_WARNING("Bad propagation to surface after time shift " << hitAfterTimeShiftOnSurface);
  
             //  moving the hit position to the center of the gap for the SDO position
             double scaleSDO = -stripLayerPosition.z() / localDirection.z();
             Amg::Vector3D hitAtCenterOfGasGap = stripLayerPosition + scaleSDO * localDirection;
             Amg::Vector3D hitAtCenterOfGasGapGlobal = surf.transform() * hitAtCenterOfGasGap;
             ATH_MSG_DEBUG("strip layer position z" << stripLayerPosition.z() << "hitAtCenterOfGasGap " 
                                                    << Amg::toString(hitAtCenterOfGasGap)<< " gas gap " << gasGap);
  
             // Don't consider electron hits below m_energyThreshold
             if (hit.kineticEnergy() < m_energyThreshold && std::abs(hit.particleEncoding()) == 11) {
                 continue;
             }
  
             // Perform Bound Check (making the call from the detector element to consider edge passivation)
             if (!detectorReadoutElement->insideActiveBounds(layerID, positionOnSurface)) {
                 ATH_MSG_DEBUG("m_exitcode = 1 : shiftTimeOffset = " << shiftTimeOffset << " "<<Amg::toString(hitOnSurface));
                 continue;
             }
  
             int stripNumber = detectorReadoutElement->stripNumber(positionOnSurface, layerID);
             Amg::Vector2D tmp(stripLayerPosition.x(), stripLayerPosition.y());
  
             if (stripNumber == -1) {
                 ATH_MSG_WARNING("!!! Failed to obtain strip number "
                                 << m_idHelperSvc->mmIdHelper().print_to_string(layerID) << "\n\t\t with pos " << positionOnSurface << " z "
                                 << stripLayerPosition.z() << " eKin: " << hit.kineticEnergy() << " eDep: " << hit.depositEnergy()
                                 << " unprojectedStrip: " << detectorReadoutElement->stripNumber(positionOnSurfaceUnprojected, layerID));
                 continue;
             }
  
             // Re-definition Of ID
             Identifier parentID = idHelper.parentID(layerID);
             Identifier digitID = idHelper.channelID(parentID, 
                                                     idHelper.multilayer(layerID),
                                                     idHelper.gasGap(layerID), stripNumber);
  
             // contain (name, eta, phi, multiPlet)
             const IdentifierHash moduleHash = m_idHelperSvc->moduleHash(layerID);
  
             ATH_MSG_DEBUG(" looking up collection using moduleHash "
                           << static_cast<int>(moduleHash) << " " << m_idHelperSvc->toString(layerID)
                           << " digitID: " << m_idHelperSvc->toString(digitID));
  
             const MuonGM::MuonChannelDesign* mmChannelDesign = detectorReadoutElement->getDesign(digitID);
             double distToChannel = mmChannelDesign->distanceToChannel(positionOnSurface, stripNumber);
  
             // check whether retrieved distance is greater than strip width
             // first retrieve the strip number from position by geometrical check
             int geoStripNumber = mmChannelDesign->channelNumber(positionOnSurface);
             if (geoStripNumber == -1) ATH_MSG_WARNING("Failed to retrieve strip number");
             // retrieve channel position of closest active strip
             Amg::Vector2D chPos{Amg::Vector2D::Zero()};
             if (!mmChannelDesign->center(geoStripNumber, chPos)) {
                 ATH_MSG_DEBUG("Failed to retrieve channel position for closest strip number "
                               << geoStripNumber
                               << ". Can happen if hit was found in non-active strip. Will not digitize it, since in data, "
                               << "we would probably not find a cluster formed well enough to survive reconstruction.");
                 continue;
             }
  
             MagField::AtlasFieldCache fieldCache;
             SG::ReadCondHandle<AtlasFieldCacheCondObj> readHandle{m_fieldCondObjInputKey, ctx};
             const AtlasFieldCacheCondObj* fieldCondObj{*readHandle};
             if (!fieldCondObj) {
                 ATH_MSG_ERROR("doDigitization: Failed to retrieve AtlasFieldCacheCondObj with key " << m_fieldCondObjInputKey.key());
                 return StatusCode::FAILURE;
             }
             fieldCondObj->getInitializedCache(fieldCache);
  
             // Obtain Magnetic Field At Detector Surface
             Amg::Vector3D hitOnSurfaceGlobal = surf.transform() * hitOnSurface;
             Amg::Vector3D magneticField{Amg::Vector3D::Zero()};
             fieldCache.getField(hitOnSurfaceGlobal.data(), magneticField.data());
  
             // B-field in local cordinate, X ~ #strip, increasing to outer R, Z ~ global Z but positive to IP
             Amg::Vector3D localMagneticField = surf.transform().linear().inverse() * magneticField;
             if ((readoutSide).at(m_muonHelper->GetLayer(simId) - 1) == -1)
                 localMagneticField[Amg::y] = -localMagneticField[Amg::y];
  
             //
             // Angles, Geometry, and Coordinates. Oh my!
             //
  
             //
             // Strip Response Simulation For This Hit
             //
             const MM_DigitToolInput stripDigitInput(
                 stripNumber, distToChannel, inAngle_XZ, inAngle_YZ, localMagneticField,
                 detectorReadoutElement->numberOfMissingBottomStrips(layerID) + 1,
                 detectorReadoutElement->numberOfStrips(layerID) - detectorReadoutElement->numberOfMissingTopStrips(layerID),
                 idHelper.gasGap(layerID), eventTime + globalHitTime);
  
             // fill the SDO collection in StoreGate
             // create here deposit for MuonSimData, link and tof
             //
             // Since we have output based on channel, instead of hit, the SDO and digit ID are No longer meaningless. 2016/06/27 T.Saito
             //
             // digitize input for strip response
  
             MuonSimData::Deposit deposit(particleLink, MuonMCData(hitOnSurface.x(), hitOnSurface.y()));
  
             // Record the SDO collection in StoreGate
             std::vector<MuonSimData::Deposit> deposits{deposit};
             MuonSimData simData(std::move(deposits), 0);
             simData.setPosition(hitAtCenterOfGasGapGlobal);
             simData.setTime(globalHitTime);
             sdoContainer->insert(std::make_pair(digitID, simData));
             ATH_MSG_DEBUG(" added MM SDO " << sdoContainer->size());
  
             float gainFraction = 1.0;
             if (m_doSmearing) {
                 // build identifier including the strip since layerId does not contain teh strip number
                 Identifier id = idHelper.channelID(layerID, 
                                                    idHelper.multilayer(layerID),
                                                    idHelper.gasGap(layerID), stripNumber);
                 ATH_CHECK(m_smearingTool->getGainFraction(id, gainFraction));
             }
             double stripPitch = detectorReadoutElement->getDesign(layerID)->channelWidth();
  
             MM_StripToolOutput tmpStripOutput = m_StripsResponseSimulation->GetResponseFrom(stripDigitInput, gainFraction, stripPitch, rndmEngine);
             MM_ElectronicsToolInput stripDigitOutput(tmpStripOutput.NumberOfStripsPos(), tmpStripOutput.chipCharge(),
                                                      tmpStripOutput.chipTime(), digitID, hit.kineticEnergy());
  
             v_stripDigitOutput.push_back(stripDigitOutput);
  
         }  // Hit Loop
  
         // Now at Detector Element Level (VMM)
  
         if (v_stripDigitOutput.empty()) {
             ATH_MSG_DEBUG("MM_DigitizationTool::doDigitization() -- there is no strip response on this VMM.");
             continue;
         }
  
         //
         // VMM Simulation
         //
  
         // Combine all strips (for this VMM) into a single VMM-level object
         //
         MM_ElectronicsToolInput stripDigitOutputAllHits = combinedStripResponseAllHits(v_stripDigitOutput);
         if (!m_idHelperSvc->isMM(stripDigitOutputAllHits.digitID())) {
             ATH_MSG_WARNING("Identifier from stripdigitOutputAllHits " 
                             << m_idHelperSvc->toString(stripDigitOutputAllHits.digitID())
                             << " is not a MM Identifier, skipping");
             continue;
         }
  
         // Create Electronics Output with peak finding setting
         //
         
         MM_DigitToolOutput electronicsOutputForReadout {m_vmmReadoutMode == "peak" 
                                                          ? m_ElectronicsResponseSimulation->getPeakResponseFrom(stripDigitOutputAllHits)
                                                          : m_ElectronicsResponseSimulation->getThresholdResponseFrom(stripDigitOutputAllHits)};
         if (!electronicsOutputForReadout.isValid()) {
             ATH_MSG_DEBUG("MM_DigitizationTool::doDigitization() -- "<<
                          " there is no electronics response (peak finding mode) even though there is a strip response.");
         }
        
         
         for (unsigned int firedCh = 0; firedCh < electronicsOutputForReadout.stripPos().size(); ++firedCh) {
             
             const int channel = electronicsOutputForReadout.stripPos()[firedCh];
             float time = electronicsOutputForReadout.stripTime()[firedCh];
             float charge = electronicsOutputForReadout.stripCharge()[firedCh];
             bool isValid{false};
             const Identifier digitID = idHelper.channelID(stripDigitOutputAllHits.digitID(),
                                                           idHelper.multilayer(stripDigitOutputAllHits.digitID()),
                                                           idHelper.gasGap(stripDigitOutputAllHits.digitID()),
                                                           channel, isValid);
             if (!isValid) {
                 ATH_MSG_DEBUG("Ghost strip fired... Ghost busters... ");
                 continue;
             }
             bool acceptStrip = true;
             if (m_doSmearing) {
                 ATH_CHECK(m_smearingTool->smearTimeAndCharge(digitID, time, charge, acceptStrip, rndmEngine));
  
             }
             if (!acceptStrip) {
                 ATH_MSG_DEBUG("Exaggeated with smearing "<<m_idHelperSvc->toString(digitID));
                 continue;
             }
             std::unique_ptr<MmDigit> newDigit = std::make_unique<MmDigit>(digitID, time, charge);
             
             const IdentifierHash moduleHash = m_idHelperSvc->moduleHash(digitID);
             if (moduleHash >= collections.size()) {
                 collections.resize(moduleHash+1);
             }
             MmDigitCollection* coll = collections[moduleHash].get();
             if (!coll) {
                 collections[moduleHash] = std::make_unique<MmDigitCollection>(m_idHelperSvc->chamberId(digitID), moduleHash);
                 coll = collections[moduleHash].get();
             }
             coll->push_back(std::move(newDigit));            
         }
         v_stripDigitOutput.clear();
     }
  
     for (size_t coll_hash = 0; coll_hash < collections.size(); ++coll_hash) {
       if (collections[coll_hash]) {
         ATH_CHECK( digitContainer->addCollection (collections[coll_hash].release(), coll_hash) );
       }
     }
  
     ATH_MSG_DEBUG("MM_Digitization Done!");
  
     m_timedHitCollection_MM.reset();
  
     return StatusCode::SUCCESS;
 }

◆ filterPassed()

virtual bool PileUpToolBase::filterPassed ( ) const

inlineoverridevirtualinherited

dummy implementation of passing filter

Definition at line 49 of file PileUpToolBase.h.

49 { return m_filterPassed; }

◆ getNextEvent()

StatusCode MM_DigitizationTool::getNextEvent ( const EventContext & ctx )

private

Record MmDigitContainer and MuonSimDataCollection.

Definition at line 326 of file MM_DigitizationTool.cxx.

                                                                     {
     // Get next event and extract collection of hit collections:
     // This is applicable to non-PileUp Event...
  
     ATH_MSG_DEBUG("MM_DigitizationTool::getNextEvent()");
  
     //  get the container(s)
     using TimedHitCollList = PileUpMergeSvc::TimedList<MMSimHitCollection>::type;
  
     // In case of single hits container just load the collection using read handles
     if (!m_onlyUseContainerName) {
         SG::ReadHandle<MMSimHitCollection> hitCollection(m_hitsContainerKey, ctx);
         if (!hitCollection.isValid()) {
             ATH_MSG_ERROR("Could not get MMSimHitCollection container " << hitCollection.name() << " from store " << hitCollection.store());
             return StatusCode::FAILURE;
         }
  
         // create a new hits collection
         m_timedHitCollection_MM = std::make_unique<TimedHitCollection<MMSimHit>>(1);
         m_timedHitCollection_MM->insert(0, hitCollection.cptr());
         ATH_MSG_DEBUG("MMSimHitCollection found with " << hitCollection->size() << " hits");
         return StatusCode::SUCCESS;
     }
  
     // this is a list<info<time_t, DataLink<MMSimHitCollection> > >
     TimedHitCollList hitCollList;
  
     ATH_CHECK(m_mergeSvc->retrieveSubEvtsData(m_inputObjectName, hitCollList));
     if (hitCollList.empty()) {
         ATH_MSG_ERROR("TimedHitCollList has size 0");
         return StatusCode::FAILURE;
     } else {
         ATH_MSG_DEBUG(hitCollList.size() << " MicroMegas SimHitCollections with key " << m_inputObjectName << " found");
     }
  
     // create a new hits collection - Define Hit Collection
     if (m_timedHitCollection_MM == nullptr) {
         m_timedHitCollection_MM = std::make_unique<TimedHitCollection<MMSimHit>>();
     } else {
         ATH_MSG_ERROR("m_timedHitCollection_MM is not null");
         return StatusCode::FAILURE;
     }
  
     // now merge all collections into one
     TimedHitCollList::iterator iColl(hitCollList.begin());
     TimedHitCollList::iterator endColl(hitCollList.end());
  
     // loop on the hit collections
     while (iColl != endColl) {
         const MMSimHitCollection* tmpColl(iColl->second);
         m_timedHitCollection_MM->insert(iColl->first, tmpColl);
         ATH_MSG_DEBUG("MMSimHitCollection found with " << tmpColl->size() << " hits");
         ++iColl;
     }
     return StatusCode::SUCCESS;
 }

◆ getRandomEngine()

CLHEP::HepRandomEngine * MM_DigitizationTool::getRandomEngine	(	const std::string &	streamName,
		const EventContext &	ctx
	)		const

private

Definition at line 897 of file MM_DigitizationTool.cxx.

                                                                                                                      {
     ATHRNG::RNGWrapper* rngWrapper = m_rndmSvc->getEngine(this, streamName);
     rngWrapper->setSeed(streamName, ctx);
     return rngWrapper->getEngine(ctx);
 }

◆ initialize()

StatusCode MM_DigitizationTool::initialize ( )

finaloverridevirtual

Initialize.

Small wedges first eta station

Small wedges second eta station

Large wedges first eta station

Reimplemented from PileUpToolBase.

Definition at line 71 of file MM_DigitizationTool.cxx.

                                            {
     ATH_MSG_DEBUG("MM_DigitizationTool:: in initialize()");
  
     ATH_CHECK(m_rndmSvc.retrieve());
  
     // Initialize transient detector store and MuonGeoModel OR MuonDetDescrManager
     ATH_CHECK(m_DetectorManagerKey.initialize());
     ATH_CHECK(m_idHelperSvc.retrieve());
  
     if (m_hitsContainerKey.key().empty()) {
         ATH_MSG_FATAL("Property InputObjectName not set !");
         return StatusCode::FAILURE;
     }
  
     if (m_onlyUseContainerName) m_inputObjectName = m_hitsContainerKey.key();
     ATH_MSG_DEBUG("Input objects in container: '" << m_inputObjectName << "'");
  
     // Pile-up merge service
     if (m_onlyUseContainerName) { ATH_CHECK(m_mergeSvc.retrieve()); }
  
     // Initialize ReadHandleKey
     ATH_CHECK(m_hitsContainerKey.initialize());
  
     // Initialize the output WriteHandleKeys
     ATH_CHECK(m_outputDigitCollectionKey.initialize());
     ATH_CHECK(m_outputSDO_CollectionKey.initialize());
     ATH_MSG_DEBUG("Output Digits: '" << m_outputDigitCollectionKey.key() << "'");
  
     ATH_CHECK(m_condThrshldsKey.initialize(m_useCondThresholds));
     ATH_CHECK(m_fieldCondObjInputKey.initialize());
     ATH_CHECK(m_calibrationTool.retrieve());
  
     // simulation identifier helper
     m_muonHelper = MicromegasHitIdHelper::GetHelper();
  
     // get gas properties from calibration tool
     const NSWCalib::MicroMegaGas prop = m_calibrationTool->mmGasProperties();
     const float peakTime = m_calibrationTool->mmPeakTime();
    
     MM_StripsResponseSimulation::ConfigModule strip_cfg{};
     strip_cfg.NSWCalib::MicroMegaGas::operator=(prop);
     strip_cfg.writeOutputFile = m_writeOutputFile;
     strip_cfg.qThreshold = m_qThreshold;
     strip_cfg.driftGapWidth = m_driftGapWidth;
     strip_cfg.crossTalk1 = m_crossTalk1;
     strip_cfg.crossTalk2 = m_crossTalk2;
     strip_cfg.avalancheGain = m_avalancheGain;
     m_StripsResponseSimulation = std::make_unique<MM_StripsResponseSimulation>(std::move(strip_cfg));
    
  
     m_timeWindowLowerOffset += peakTime;                     // account for peak time in time window
     m_timeWindowUpperOffset += peakTime;  // account for peak time in time window
  
     MM_ElectronicsResponseSimulation::ConfigModule elec_sim_cfg{};
     elec_sim_cfg.peakTime = peakTime;
     elec_sim_cfg.timeWindowLowerOffset = m_timeWindowLowerOffset;
     elec_sim_cfg.timeWindowUpperOffset = m_timeWindowUpperOffset;
     elec_sim_cfg.vmmDeadtime = m_vmmDeadtime;
     elec_sim_cfg.vmmUpperGrazeWindow = m_vmmUpperGrazeWindow;
     elec_sim_cfg.stripDeadTime = m_stripdeadtime;
     elec_sim_cfg.artDeadTime = m_ARTdeadtime;
     elec_sim_cfg.useNeighborLogic = m_vmmNeighborLogic;
     // ElectronicsResponseSimulation Creation
     m_ElectronicsResponseSimulation = std::make_unique<MM_ElectronicsResponseSimulation>(std::move(elec_sim_cfg));
     
     // Configuring various VMM modes of signal readout
     //
     std::string vmmReadoutMode = m_vmmReadoutMode;
     // convert vmmReadoutMode to lower case
     std::for_each(vmmReadoutMode.begin(), vmmReadoutMode.end(), [](char& c) { c = ::tolower(c); });
     if (vmmReadoutMode.find("peak") != std::string::npos)
         m_vmmReadoutMode = "peak";
     else if (vmmReadoutMode.find("threshold") != std::string::npos)
         m_vmmReadoutMode = "threshold";
     else {
         ATH_MSG_ERROR("MM_DigitizationTool can't interperet vmmReadoutMode option! (Should be 'peak' or 'threshold'.) Contains: "
                       << m_vmmReadoutMode);
         return StatusCode::FAILURE;
     }
     std::string vmmARTMode = m_vmmARTMode;
     // convert vmmARTMode to lower case
     std::for_each(vmmARTMode.begin(), vmmARTMode.end(), [](char& c) { c = ::tolower(c); });
     if (vmmARTMode.find("peak") != std::string::npos)
         m_vmmARTMode = "peak";
     else if (vmmARTMode.find("threshold") != std::string::npos)
         m_vmmARTMode = "threshold";
     else
         ATH_MSG_ERROR(
             "MM_DigitizationTool can't interperet vmmARTMode option! (Should be 'peak' or 'threshold'.) Contains: " << m_vmmARTMode);
  
     if (m_doSmearing) ATH_MSG_INFO("Running in smeared mode!");
  
     // get shortest and longest strip length for threshold scaling
     Identifier tmpId{0};  // temporary identifier to work with ReadoutElement
     const MuonGM::MuonDetectorManager* muonGeoMgr{nullptr};
     ATH_CHECK(detStore()->retrieve(muonGeoMgr));
     int stripNumberShortestStrip{-1}, stripNumberLongestStrip{-1};
     Identifier tmpIdShortestStrip{0},tmpIdLongestStrip{0};
     float shortestStripLength{FLT_MAX}, longestStripLength{0};   
  
     //============================
     //SMALL SECTORS - ETA 1 CHAMBERS
     // identifier for first gas gap in a small MM sector, layer is eta layer
     tmpId = m_idHelperSvc->mmIdHelper().channelID("MMS", 1, 1, 1, 1, 1);
     const MuonGM::MMReadoutElement* detectorReadoutElement = muonGeoMgr->getMMReadoutElement(tmpId);
     stripNumberShortestStrip = (detectorReadoutElement->getDesign(tmpId))->nMissedBottomEta + 1;
     tmpIdShortestStrip = m_idHelperSvc->mmIdHelper().channelID("MMS", 1, 1, 1, 1, stripNumberShortestStrip);  // identifier for the shortest strip
     shortestStripLength = detectorReadoutElement->stripLength(tmpIdShortestStrip);
  
     stripNumberLongestStrip = (detectorReadoutElement->getDesign(tmpId))->totalStrips - (detectorReadoutElement->getDesign(tmpId))->nMissedTopEta;
     tmpIdLongestStrip = m_idHelperSvc->mmIdHelper().channelID("MMS", 1, 1, 1, 1, stripNumberLongestStrip);  // identifier for the longest strip
     longestStripLength = detectorReadoutElement->stripLength(tmpIdLongestStrip);
  
     // now get the slope and intercept for the threshold scaling
     // function is m_noiseSlope * stripLength + m_noiseIntercept
     NoiseCalibConstants& noise_smallEta1 = m_noiseParams[m_idHelperSvc->stationName(tmpId)];
     noise_smallEta1.slope = (maxNoiseSmall_eta1 - minNoiseSmall_eta1) / (longestStripLength - shortestStripLength);
     noise_smallEta1.intercept =  minNoiseSmall_eta1 - noise_smallEta1.slope* shortestStripLength;    
     //============================
  
     //============================
     //SMALL SECTORS - ETA 2 CHAMBERS
     // identifier for first gas gap in a small MM sector, layer is eta layer
     tmpId = m_idHelperSvc->mmIdHelper().channelID("MMS", 2, 1, 1, 1, 1);
     detectorReadoutElement = muonGeoMgr->getMMReadoutElement(tmpId);
     stripNumberShortestStrip = (detectorReadoutElement->getDesign(tmpId))->nMissedBottomEta + 1;
     tmpIdShortestStrip = m_idHelperSvc->mmIdHelper().channelID("MMS", 2, 1, 1, 1, stripNumberShortestStrip);  // identifier for the shortest strip
     shortestStripLength = detectorReadoutElement->stripLength(tmpIdShortestStrip);
  
     stripNumberLongestStrip = (detectorReadoutElement->getDesign(tmpId))->totalStrips - (detectorReadoutElement->getDesign(tmpId))->nMissedTopEta;
     tmpIdLongestStrip = m_idHelperSvc->mmIdHelper().channelID("MMS", 2, 1, 1, 1, stripNumberLongestStrip);  // identifier for the longest strip
     longestStripLength = detectorReadoutElement->stripLength(tmpIdLongestStrip);
  
     // now get the slope and intercept for the threshold scaling
     // function is m_noiseSlope * stripLength + m_noiseIntercept
     NoiseCalibConstants& noise_smallEta2 = m_noiseParams[m_idHelperSvc->stationName(tmpId)*2];
     noise_smallEta2.slope = (maxNoiseSmall_eta2 - minNoiseSmall_eta2) / (longestStripLength - shortestStripLength);
     noise_smallEta2.intercept =  minNoiseSmall_eta2 - noise_smallEta2.slope * shortestStripLength;
     //============================
  
     //============================
     //LARGE SECTORS - ETA 1 CHAMBERS
     // identifier for first gas gap in a small MM sector, layer is eta layer
     tmpId = m_idHelperSvc->mmIdHelper().channelID("MML", 1, 1, 1, 1, 1);
     detectorReadoutElement = muonGeoMgr->getMMReadoutElement(tmpId);
     stripNumberShortestStrip = (detectorReadoutElement->getDesign(tmpId))->nMissedBottomEta + 1;
     tmpIdShortestStrip = m_idHelperSvc->mmIdHelper().channelID("MML", 1, 1, 1, 1, stripNumberShortestStrip);  // identifier for the shortest strip
     shortestStripLength = detectorReadoutElement->stripLength(tmpIdShortestStrip);
  
     stripNumberLongestStrip = (detectorReadoutElement->getDesign(tmpId))->totalStrips - (detectorReadoutElement->getDesign(tmpId))->nMissedTopEta;
     tmpIdLongestStrip = m_idHelperSvc->mmIdHelper().channelID("MML", 1, 1, 1, 1, stripNumberLongestStrip);  // identifier for the longest strip
     longestStripLength = detectorReadoutElement->stripLength(tmpIdLongestStrip);
  
     // now get the slope and intercept for the threshold scaling
     // function is m_noiseSlope * stripLength + m_noiseIntercept
     NoiseCalibConstants& noise_largeEta1 = m_noiseParams[m_idHelperSvc->stationName(tmpId)];
     noise_largeEta1.slope = (maxNoiseLarge_eta1 - minNoiseLarge_eta1) / (longestStripLength - shortestStripLength);
     noise_largeEta1.intercept =  minNoiseLarge_eta1 - noise_largeEta1.slope * shortestStripLength;    
     //============================
  
     //============================
     //LARGE SECTORS - ETA 2 CHAMBERS
     // identifier for first gas gap in a small MM sector, layer is eta layer
     tmpId = m_idHelperSvc->mmIdHelper().channelID("MML", 2, 1, 1, 1, 1);
     detectorReadoutElement = muonGeoMgr->getMMReadoutElement(tmpId);
     stripNumberShortestStrip = (detectorReadoutElement->getDesign(tmpId))->nMissedBottomEta + 1;
     tmpIdShortestStrip = m_idHelperSvc->mmIdHelper().channelID("MML", 2, 1, 1, 1, stripNumberShortestStrip);  // identifier for the shortest strip
     shortestStripLength = detectorReadoutElement->stripLength(tmpIdShortestStrip);
  
     stripNumberLongestStrip = (detectorReadoutElement->getDesign(tmpId))->totalStrips - (detectorReadoutElement->getDesign(tmpId))->nMissedTopEta;
     tmpIdLongestStrip = m_idHelperSvc->mmIdHelper().channelID("MML", 2, 1, 1, 1, stripNumberLongestStrip);  // identifier for the longest strip
     longestStripLength = detectorReadoutElement->stripLength(tmpIdLongestStrip);
  
     // now get the slope and intercept for the threshold scaling
     // function is m_noiseSlope * stripLength + m_noiseIntercept
     NoiseCalibConstants& noise_largeEta2 = m_noiseParams[m_idHelperSvc->stationName(tmpId)*2];
     noise_largeEta2.slope = (maxNoiseLarge_eta2 - minNoiseLarge_eta2) / (longestStripLength - shortestStripLength);
     noise_largeEta2.intercept =  minNoiseLarge_eta2 - noise_largeEta2.slope * shortestStripLength;    
     //============================
  
     ATH_MSG_DEBUG("Configuration  MM_DigitizationTool ");
     ATH_MSG_INFO("RndmSvc                " << m_rndmSvc);
     ATH_MSG_INFO("RndmEngine             " << m_rndmEngineName);
     ATH_MSG_DEBUG("InputObjectName        " << m_inputObjectName);
     ATH_MSG_DEBUG("OutputObjectName       " << m_outputDigitCollectionKey.key());
     ATH_MSG_DEBUG("OutputSDOName          " << m_outputSDO_CollectionKey.key());
     ATH_MSG_DEBUG("UseTimeWindow          " << m_useTimeWindow);
     ATH_MSG_DEBUG("CheckSimHits           " << m_checkMMSimHits);
     ATH_MSG_DEBUG("Threshold              " << m_qThreshold);
     ATH_MSG_DEBUG("TransverseDiffusSigma  " << m_StripsResponseSimulation->getTransversDiffusionSigma());
     ATH_MSG_DEBUG("LogitundinalDiffusSigma" << m_StripsResponseSimulation->getLongitudinalDiffusionSigma());
     ATH_MSG_DEBUG("Interaction density mean: " << m_StripsResponseSimulation->getInteractionDensityMean());
     ATH_MSG_DEBUG("Interaction density sigma: " << m_StripsResponseSimulation->getInteractionDensitySigma());
     ATH_MSG_DEBUG("DriftVelocity stripResponse: " << m_StripsResponseSimulation->getDriftVelocity());
     ATH_MSG_DEBUG("crossTalk1             " << m_crossTalk1);
     ATH_MSG_DEBUG("crossTalk2             " << m_crossTalk2);
     ATH_MSG_DEBUG("EnergyThreshold        " << m_energyThreshold);
  
     return StatusCode::SUCCESS;
 }

◆ mergeEvent()

StatusCode MM_DigitizationTool::mergeEvent ( const EventContext & ctx )

finaloverride

When being run from PileUpToolsAlgs, this method is called at the end of the subevts loop.

Not (necessarily) able to access SubEvents

Definition at line 383 of file MM_DigitizationTool.cxx.

                                                                   {
     ATH_MSG_VERBOSE("MM_DigitizationTool::in mergeEvent()");
  
     ATH_CHECK(doDigitization(ctx));
  
     // reset the pointer
     m_timedHitCollection_MM.reset();
  
     // clear cloned list
     m_MMHitCollList.clear();
     return StatusCode::SUCCESS;
 }

◆ prepareEvent()

StatusCode MM_DigitizationTool::prepareEvent	(	const EventContext &	ctx,
		const unsigned int	nInputEvents
	)

finaloverride

When being run from PileUpToolsAlgs, this method is called at the start of the subevts loop.

Not able to access SubEvents

Definition at line 279 of file MM_DigitizationTool.cxx.

                                                                                              {
     ATH_MSG_DEBUG("MM_DigitizationTool::prepareEvent() called for " << nInputEvents << " input events");
  
     m_MMHitCollList.clear();
  
     if (!m_timedHitCollection_MM) {
         m_timedHitCollection_MM = std::make_unique<TimedHitCollection<MMSimHit>>();
     } else {
         ATH_MSG_ERROR("m_timedHitCollection_MM is not null");
         return StatusCode::FAILURE;
     }
  
     return StatusCode::SUCCESS;
 }

◆ processAllSubEvents() [1/2]

StatusCode MM_DigitizationTool::processAllSubEvents ( const EventContext & ctx )

overridevirtual

When being run from MM_Digitizer, this method is called during the event loop.

alternative interface which uses the PileUpMergeSvc to obtain all the required SubEvents.

Reimplemented from PileUpToolBase.

Definition at line 398 of file MM_DigitizationTool.cxx.

                                                                            {
     ATH_MSG_DEBUG("MM_DigitizationTool::processAllSubEvents()");
  
     // merging of the hit collection in getNextEvent method
  
     if (!m_timedHitCollection_MM) ATH_CHECK(getNextEvent(ctx));
  
     ATH_CHECK(doDigitization(ctx));
  
     // reset the pointer
     m_timedHitCollection_MM.reset();
     return StatusCode::SUCCESS;
 }

◆ processAllSubEvents() [2/2]

virtual StatusCode IPileUpTool::processAllSubEvents

inherited

dummy implementation to allow compilation while all Digitization packages are migrated to use this new interface.

◆ processBunchXing()

StatusCode MM_DigitizationTool::processBunchXing	(	int	bunchXing,
		SubEventIterator	bSubEvents,
		SubEventIterator	eSubEvents
	)

finaloverridevirtual

When being run from PileUpToolsAlgs, this method is called for each active bunch-crossing to process current SubEvents bunchXing is in ns.

Reimplemented from PileUpToolBase.

Definition at line 294 of file MM_DigitizationTool.cxx.

                                                                                                                         {
     ATH_MSG_DEBUG("MM_DigitizationTool::in processBunchXing()" << bunchXing);
  
     typedef PileUpMergeSvc::TimedList<MMSimHitCollection>::type TimedHitCollList;
     TimedHitCollList hitCollList;
  
     if (!(m_mergeSvc->retrieveSubSetEvtData(m_inputObjectName, hitCollList, bunchXing, bSubEvents, eSubEvents).isSuccess()) &&
         hitCollList.empty()) {
         ATH_MSG_ERROR("Could not fill TimedHitCollList");
         return StatusCode::FAILURE;
     } else {
         ATH_MSG_VERBOSE(hitCollList.size() << " MMSimHitCollection with key " << m_inputObjectName << " found");
     }
  
     TimedHitCollList::iterator iColl(hitCollList.begin());
     TimedHitCollList::iterator endColl(hitCollList.end());
  
     // Iterating over the list of collections
     for (; iColl != endColl; ++iColl) {
         auto hitCollPtr = std::make_unique<MMSimHitCollection>(*iColl->second);
         PileUpTimeEventIndex timeIndex(iColl->first);
  
         ATH_MSG_DEBUG("MMSimHitCollection found with " << hitCollPtr->size() << " hits");
         ATH_MSG_VERBOSE("time index info. time: " << timeIndex.time() << " index: " << timeIndex.index() << " type: " << timeIndex.type());
  
         m_timedHitCollection_MM->insert(timeIndex, hitCollPtr.get());
         m_MMHitCollList.push_back(std::move(hitCollPtr));
     }
     return StatusCode::SUCCESS;
 }

◆ resetFilter()

virtual void PileUpToolBase::resetFilter ( )

inlineoverridevirtualinherited

dummy implementation of filter reset

Reimplemented in MergeTruthJetsTool.

Definition at line 51 of file PileUpToolBase.h.

51 { m_filterPassed=true; }

◆ toProcess()

virtual bool PileUpToolBase::toProcess ( int bunchXing ) const

inlineoverridevirtualinherited

the method this base class helps implementing

Reimplemented in MergeHijingParsTool, and MergeTrackRecordCollTool.

Definition at line 32 of file PileUpToolBase.h.

                                                        {
     //closed interval [m_firstXing,m_lastXing]
     return !((m_firstXing > bunchXing) || (bunchXing > m_lastXing));
   }

Member Data Documentation

◆ m_ARTdeadtime

Gaudi::Property<float> MM_DigitizationTool::m_ARTdeadtime {this, "ARTDeadTime", 200, "dead-time for ART, default value 200 ns = 8 BCs"}

private

Definition at line 166 of file MM_DigitizationTool.h.

◆ m_avalancheGain

Gaudi::Property<float> MM_DigitizationTool::m_avalancheGain {this, "AvalancheGain", 6.0e3, "avalanche Gain for rach gas mixture"}

private

Definition at line 160 of file MM_DigitizationTool.h.

◆ m_calibrationTool

ToolHandle<Muon::INSWCalibTool> MM_DigitizationTool::m_calibrationTool {this, "CalibrationTool", "Muon::NSWCalibTool/NSWCalibTool"}

private

Definition at line 118 of file MM_DigitizationTool.h.

◆ m_checkMMSimHits

Gaudi::Property<bool> MM_DigitizationTool::m_checkMMSimHits {this, "CheckSimHits", true, "Control on the hit validity"}

private

Definition at line 144 of file MM_DigitizationTool.h.

◆ m_condThrshldsKey

SG::ReadCondHandleKey<NswCalibDbThresholdData> MM_DigitizationTool::m_condThrshldsKey

private

Initial value:

{
        this, "CondThrshldsKey", "NswCalibDbThresholdData",
        "Key of NswCalibDbThresholdData object containing calibration data (VMM thresholds)"}

Definition at line 121 of file MM_DigitizationTool.h.

◆ m_crossTalk1

Gaudi::Property<float> MM_DigitizationTool::m_crossTalk1 {this, "crossTalk1", 0.3, "Strip Cross Talk with Nearest Neighbor"}

private

Definition at line 157 of file MM_DigitizationTool.h.

◆ m_crossTalk2

Gaudi::Property<float> MM_DigitizationTool::m_crossTalk2 {this, "crossTalk2", 0.09, "Strip Cross Talk with 2nd Nearest Neighbor"}

private

Definition at line 158 of file MM_DigitizationTool.h.

◆ m_DetectorManagerKey

SG::ReadCondHandleKey<MuonGM::MuonDetectorManager> MM_DigitizationTool::m_DetectorManagerKey

private

Initial value:

{this, "DetectorManagerKey", "MuonDetectorManager",

"Key of input MuonDetectorManager condition data"}

Definition at line 190 of file MM_DigitizationTool.h.

◆ m_DiffMagSecondMuonHit

Gaudi::Property<double> MM_DigitizationTool::m_DiffMagSecondMuonHit {this, "DiffMagSecondMuonHit", 0.1}

private

Definition at line 138 of file MM_DigitizationTool.h.

◆ m_doSmearing

Gaudi::Property<bool> MM_DigitizationTool::m_doSmearing

private

Initial value:

{this, "doSmearing", true,

"set the usage or not of the smearing tool for realistic detector performance"}

Definition at line 147 of file MM_DigitizationTool.h.

◆ m_driftGapWidth

Gaudi::Property<float> MM_DigitizationTool::m_driftGapWidth {this, "DriftGapWidth", 5.04, "Drift Gap Width of 5.04 mm"}

private

Definition at line 156 of file MM_DigitizationTool.h.

◆ m_ElectronicsResponseSimulation

std::unique_ptr<MM_ElectronicsResponseSimulation> MM_DigitizationTool::m_ElectronicsResponseSimulation {}

private

Definition at line 196 of file MM_DigitizationTool.h.

◆ m_electronicsThreshold

Gaudi::Property<float> MM_DigitizationTool::m_electronicsThreshold

private

Initial value:

{this, "electronicsThreshold", 15000,

"threshold Voltage for histoBNL, 2*(Intrinsic noise ~3k e)"}

Definition at line 163 of file MM_DigitizationTool.h.

◆ m_energyThreshold

Gaudi::Property<double> MM_DigitizationTool::m_energyThreshold {this, "EnergyThreshold", 50, "Minimal energy to produce a PRD"}

private

Definition at line 133 of file MM_DigitizationTool.h.

◆ m_fieldCondObjInputKey

SG::ReadCondHandleKey<AtlasFieldCacheCondObj> MM_DigitizationTool::m_fieldCondObjInputKey {this, "AtlasFieldCacheCondObj", "fieldCondObj"}

private

Definition at line 120 of file MM_DigitizationTool.h.

◆ m_filterPassed

bool PileUpToolBase::m_filterPassed {true}

protectedinherited

Definition at line 60 of file PileUpToolBase.h.

◆ m_firstXing

Gaudi::Property<int> PileUpToolBase::m_firstXing

protectedinherited

Initial value:

{this, "FirstXing", -999,

"First bunch-crossing in which det is live"}

Definition at line 54 of file PileUpToolBase.h.

◆ m_hitsContainerKey

SG::ReadHandleKey<MMSimHitCollection> MM_DigitizationTool::m_hitsContainerKey {this, "InputObjectName", "MM_Hits", "name of the input objects"}

private

Definition at line 127 of file MM_DigitizationTool.h.

◆ m_idHelperSvc

ServiceHandle<Muon::IMuonIdHelperSvc> MM_DigitizationTool::m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}

private

Definition at line 116 of file MM_DigitizationTool.h.

◆ m_inputObjectName

std::string MM_DigitizationTool::m_inputObjectName {""}

private

Definition at line 128 of file MM_DigitizationTool.h.

◆ m_lastXing

Gaudi::Property<int> PileUpToolBase::m_lastXing

protectedinherited

Initial value:

{this, "LastXing", 999,

"Last bunch-crossing in which det is live"}

Definition at line 56 of file PileUpToolBase.h.

◆ m_maskMultiplet

Gaudi::Property<int> MM_DigitizationTool::m_maskMultiplet {this, "MaskMultiplet", 0, "0: all, 1: first, 2: second, 3: both"}

private

Definition at line 140 of file MM_DigitizationTool.h.

◆ m_mergeSvc

ServiceHandle<PileUpMergeSvc> MM_DigitizationTool::m_mergeSvc {this, "MergeSvc", "PileUpMergeSvc", "Merge service used in digitization"}

private

Definition at line 173 of file MM_DigitizationTool.h.

◆ m_MMHitCollList

std::list<std::unique_ptr<MMSimHitCollection> > MM_DigitizationTool::m_MMHitCollList {}

private

Definition at line 193 of file MM_DigitizationTool.h.

◆ m_muonHelper

const MicromegasHitIdHelper* MM_DigitizationTool::m_muonHelper {nullptr}

private

Definition at line 189 of file MM_DigitizationTool.h.

◆ m_needsMcEventCollHelper

Gaudi::Property<bool> MM_DigitizationTool::m_needsMcEventCollHelper {this, "UseMcEventCollectionHelper", false}

private

Definition at line 143 of file MM_DigitizationTool.h.

◆ m_noiseParams

std::map<int, NoiseCalibConstants> MM_DigitizationTool::m_noiseParams {}

private

Define a map to cache the noise parameters individually Key: stationName * std::abs(stationEta)

Definition at line 201 of file MM_DigitizationTool.h.

◆ m_onlyUseContainerName

Gaudi::Property<bool> MM_DigitizationTool::m_onlyUseContainerName

private

Initial value:

{this, "OnlyUseContainerName", true,

"Don't use the ReadHandleKey directly. Just extract the container name from it."}

Definition at line 125 of file MM_DigitizationTool.h.

◆ m_outputDigitCollectionKey

SG::WriteHandleKey<MmDigitContainer> MM_DigitizationTool::m_outputDigitCollectionKey

private

Initial value:

{

this, "OutputObjectName", "MM_DIGITS", "WriteHandleKey for Output MmigitContainer"}

Definition at line 168 of file MM_DigitizationTool.h.

◆ m_outputSDO_CollectionKey

SG::WriteHandleKey<MuonSimDataCollection> MM_DigitizationTool::m_outputSDO_CollectionKey

private

Initial value:

{

this, "OutputSDOName", "MM_SDO", "WriteHandleKey for Output MuonSimDataCollection"}

Definition at line 170 of file MM_DigitizationTool.h.

◆ m_qThreshold

Gaudi::Property<float> MM_DigitizationTool::m_qThreshold {this, "qThreshold", 0.001, "Charge Threshold"}

private

Definition at line 155 of file MM_DigitizationTool.h.

◆ m_rndmEngineName

Gaudi::Property<std::string> MM_DigitizationTool::m_rndmEngineName {this, "RndmEngine", "MuonDigitization", "Random engine name"}

private

Definition at line 114 of file MM_DigitizationTool.h.

◆ m_rndmSvc

ServiceHandle<IAthRNGSvc> MM_DigitizationTool::m_rndmSvc {this, "RndmSvc", "AthRNGSvc", "Random Number Service used in Muon digitization"}

private

Definition at line 113 of file MM_DigitizationTool.h.

◆ m_smearingTool

ToolHandle<Muon::INSWCalibSmearingTool> MM_DigitizationTool::m_smearingTool {this, "SmearingTool", "Muon::NSWCalibSmearingTool/MMCalibSmearingTool"}

private

Definition at line 117 of file MM_DigitizationTool.h.

◆ m_stripdeadtime

Gaudi::Property<float> MM_DigitizationTool::m_stripdeadtime {this, "StripDeadTime", 200, "dead-time for strip, default value 200 ns = 8 BCs"}

private

Definition at line 165 of file MM_DigitizationTool.h.

◆ m_StripsResponseSimulation

std::unique_ptr<MM_StripsResponseSimulation> MM_DigitizationTool::m_StripsResponseSimulation {}

private

Definition at line 195 of file MM_DigitizationTool.h.

◆ m_thresholdScaleFactor

Gaudi::Property<float> MM_DigitizationTool::m_thresholdScaleFactor

private

Initial value:

{this, "thresholdScaleFactor", 7.0,

"Use x times the strip length dependent noise as MM threshold"}

Definition at line 179 of file MM_DigitizationTool.h.

◆ m_timedHitCollection_MM

std::unique_ptr<TimedHitCollection<MMSimHit> > MM_DigitizationTool::m_timedHitCollection_MM {}

private

Definition at line 194 of file MM_DigitizationTool.h.

◆ m_timeWindowLowerOffset

Gaudi::Property<double> MM_DigitizationTool::m_timeWindowLowerOffset

private

Initial value:

{this, "WindowLowerOffset", -12.5,

"lower boundary of the time window in which digits are accepted"}

Definition at line 134 of file MM_DigitizationTool.h.

◆ m_timeWindowUpperOffset

Gaudi::Property<double> MM_DigitizationTool::m_timeWindowUpperOffset

private

Initial value:

{this, "WindowUpperOffset", 187.5,

"upper boundary of the time window in which digits are accepted"}

Definition at line 136 of file MM_DigitizationTool.h.

◆ m_useCondThresholds

Gaudi::Property<bool> MM_DigitizationTool::m_useCondThresholds

private

Initial value:

{this, "useCondThresholds", false,

"Use conditions data to get thresholds, overrules useThresholdScaling"}

Definition at line 175 of file MM_DigitizationTool.h.

◆ m_useThresholdScaling

Gaudi::Property<bool> MM_DigitizationTool::m_useThresholdScaling

private

Initial value:

{this, "useThresholdScaling", true,

"Use a strip length dependent threshold in MM digitiation"}

Definition at line 177 of file MM_DigitizationTool.h.

◆ m_useTimeWindow

Gaudi::Property<bool> MM_DigitizationTool::m_useTimeWindow {this, "UseTimeWindow", true}

private

Definition at line 145 of file MM_DigitizationTool.h.

◆ m_vetoPileUpTruthLinks

Gaudi::Property<int> PileUpToolBase::m_vetoPileUpTruthLinks

protectedinherited

Initial value:

{this, "VetoPileUpTruthLinks", true,

"Ignore links to suppressed pile-up truth"}

Definition at line 58 of file PileUpToolBase.h.

◆ m_vmmARTMode

Gaudi::Property<std::string> MM_DigitizationTool::m_vmmARTMode {this, "vmmARTMode", "threshold", "For ART (trigger) path. Can be peak or threshold"}

private

Definition at line 131 of file MM_DigitizationTool.h.

◆ m_vmmDeadtime

Gaudi::Property<float> MM_DigitizationTool::m_vmmDeadtime

private

Initial value:

{

this, "vmmDeadtime", 200, "Specifies how much before the lower time limit the VMM simulation should start evaluating the signal"}

Definition at line 181 of file MM_DigitizationTool.h.

◆ m_vmmNeighborLogic

Gaudi::Property<bool> MM_DigitizationTool::m_vmmNeighborLogic {this, "VMMNeighborLogic", false}

private

Definition at line 146 of file MM_DigitizationTool.h.

◆ m_vmmReadoutMode

Gaudi::Property<std::string> MM_DigitizationTool::m_vmmReadoutMode {this, "vmmReadoutMode", "peak", "For readout (DAQ) path. Can be peak or threshold"}

private

Definition at line 130 of file MM_DigitizationTool.h.

◆ m_vmmUpperGrazeWindow

Gaudi::Property<float> MM_DigitizationTool::m_vmmUpperGrazeWindow

private

Initial value:

{

this, "vmmUpperGrazeWindow", 150, "Specifies how much above the upper time window boundary the VMM sim evaluates the signal."}

Definition at line 185 of file MM_DigitizationTool.h.

◆ m_writeOutputFile

Gaudi::Property<bool> MM_DigitizationTool::m_writeOutputFile {this, "SaveInternalHistos", false}

private

Definition at line 142 of file MM_DigitizationTool.h.

The documentation for this class was generated from the following files:

Public Member Functions

Private Types

Private Member Functions

Private Attributes

structors and AlgTool implementation

Detailed Description

Member Typedef Documentation

◆ NoiseCalibConstants

Constructor & Destructor Documentation

◆ MM_DigitizationTool()

Member Function Documentation

◆ checkMMSimHit()

◆ combinedStripResponseAllHits()

◆ digitize()

◆ doDigitization()

◆ filterPassed()

◆ getNextEvent()

◆ getRandomEngine()

◆ initialize()

◆ mergeEvent()

◆ prepareEvent()

◆ processAllSubEvents() [1/2]

◆ processAllSubEvents() [2/2]

◆ processBunchXing()

◆ resetFilter()

◆ toProcess()

Member Data Documentation

◆ m_ARTdeadtime

◆ m_avalancheGain

◆ m_calibrationTool

◆ m_checkMMSimHits

◆ m_condThrshldsKey

◆ m_crossTalk1

◆ m_crossTalk2

◆ m_DetectorManagerKey

◆ m_DiffMagSecondMuonHit

◆ m_doSmearing

◆ m_driftGapWidth

◆ m_ElectronicsResponseSimulation

◆ m_electronicsThreshold

◆ m_energyThreshold

◆ m_fieldCondObjInputKey

◆ m_filterPassed

◆ m_firstXing

◆ m_hitsContainerKey

◆ m_idHelperSvc

◆ m_inputObjectName

◆ m_lastXing

◆ m_maskMultiplet

◆ m_mergeSvc

◆ m_MMHitCollList

◆ m_muonHelper

◆ m_needsMcEventCollHelper

◆ m_noiseParams

◆ m_onlyUseContainerName

◆ m_outputDigitCollectionKey

◆ m_outputSDO_CollectionKey

◆ m_qThreshold

◆ m_rndmEngineName

◆ m_rndmSvc

◆ m_smearingTool

◆ m_stripdeadtime

◆ m_StripsResponseSimulation

◆ m_thresholdScaleFactor

◆ m_timedHitCollection_MM

◆ m_timeWindowLowerOffset

◆ m_timeWindowUpperOffset

◆ m_useCondThresholds

◆ m_useThresholdScaling

◆ m_useTimeWindow

◆ m_vetoPileUpTruthLinks

◆ m_vmmARTMode

◆ m_vmmDeadtime

◆ m_vmmNeighborLogic

◆ m_vmmReadoutMode

◆ m_vmmUpperGrazeWindow

◆ m_writeOutputFile