 |
ATLAS Offline Software
|
#include <sTgcDigitizationTool.h>
|
CLHEP::HepRandomEngine * | getRandomEngine (const std::string &streamName, const EventContext &ctx) const |
|
template<class CondType > |
StatusCode | retrieveCondData (const EventContext &ctx, SG::ReadCondHandleKey< CondType > &key, const CondType *&condPtr) const |
|
StatusCode | getNextEvent (const EventContext &ctx) |
| Get next event and extract collection of hit collections. More...
|
|
StatusCode | doDigitization (const EventContext &ctx) |
| Core part of digitization use by mergeEvent (IPileUpTool) and digitize (IMuonDigitizationTool) More...
|
|
double | getChannelThreshold (const EventContext &ctx, const Identifier &channelID, const NswCalibDbThresholdData &thresholdData) const |
|
StatusCode | processDigitsWithVMM (const EventContext &ctx, const DigiConditions &digiCond, sTgcSimDigitCont &unmergedContainer, const double vmmDeadTime, const bool isNeighbourOn, sTgcDigtCont &outDigitContainer, MuonSimDataCollection &outSdoContainer) const |
|
sTgcSimDigitVec | processDigitsWithVMM (const EventContext &ctx, const DigiConditions &digiCond, const double vmmDeadTime, sTgcSimDigitVec &unmergedDigits, const bool isNeighborOn) const |
|
|
ServiceHandle< PileUpMergeSvc > | m_mergeSvc {this, "PileUpMergeSvc", "PileUpMergeSvc", "Merge service used in digitization"} |
|
ServiceHandle< IAthRNGSvc > | m_rndmSvc {this, "RndmSvc", "AthRNGSvc", "Random Number Service used in Muon digitization"} |
|
ServiceHandle< Muon::IMuonIdHelperSvc > | m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"} |
|
SG::ReadCondHandleKey< MuonGM::MuonDetectorManager > | m_detMgrKey |
|
SG::ReadCondHandleKey< Muon::DigitEffiData > | m_effiKey |
|
std::unique_ptr< sTgcDigitMaker > | m_digitizer {} |
|
std::unique_ptr< TimedHitCollection< sTGCSimHit > > | m_thpcsTGC {} |
|
std::vector< std::unique_ptr< sTGCSimHitCollection > > | m_STGCHitCollList {} |
|
ToolHandle< Muon::INSWCalibSmearingTool > | m_smearingTool {this,"SmearingTool","Muon::NSWCalibSmearingTool/STgcCalibSmearingTool"} |
|
ToolHandle< Muon::INSWCalibTool > | m_calibTool {this,"CalibrationTool","Muon::NSWCalibTool/NSWCalibTool"} |
|
SG::WriteHandleKey< sTgcDigitContainer > | m_outputDigitCollectionKey {this,"OutputObjectName","sTGC_DIGITS","WriteHandleKey for Output sTgcDigitContainer"} |
|
SG::WriteHandleKey< MuonSimDataCollection > | m_outputSDO_CollectionKey {this,"OutputSDOName","sTGC_SDO","WriteHandleKey for Output MuonSimDataCollection"} |
|
Gaudi::Property< bool > | m_doSmearing {this,"doSmearing",false} |
|
Gaudi::Property< bool > | m_doToFCorrection {this,"doToFCorrection",false} |
|
Gaudi::Property< bool > | m_doEfficiencyCorrection {this,"doEfficiencyCorrection",false} |
|
Gaudi::Property< double > | m_runVoltage {this,"operatingHVinkV",2.8} |
|
Gaudi::Property< std::string > | m_rndmEngineName {this,"RndmEngine","MuonDigitization","Random engine name"} |
|
Gaudi::Property< bool > | m_onlyUseContainerName {this, "OnlyUseContainerName", true, "Don't use the ReadHandleKey directly. Just extract the container name from it."} |
|
SG::ReadHandleKey< sTGCSimHitCollection > | m_hitsContainerKey {this, "InputObjectName", "sTGC_Hits", "name of the input object"} |
|
std::string | m_inputObjectName {""} |
|
Gaudi::Property< bool > | m_useCondThresholds {this, "useCondThresholds", false, "Use conditions data to get VMM charge threshold values"} |
|
SG::ReadCondHandleKey< NswCalibDbThresholdData > | m_condThrshldsKey {this, "CondThrshldsKey", "NswCalibDbThresholdData", "Key of NswCalibDbThresholdData object containing calibration data (VMM thresholds)"} |
|
Gaudi::Property< int > | m_doChannelTypes {this,"doChannelTypes",3} |
|
Gaudi::Property< bool > | m_doPadSharing {this,"padChargeSharing", false} |
|
Gaudi::Property< double > | m_deadtimeStrip {this,"deadtimeStrip", 250} |
|
Gaudi::Property< double > | m_deadtimePad {this,"deadtimePad" , 250} |
|
Gaudi::Property< double > | m_deadtimeWire {this,"deadtimeWire" , 250} |
|
Gaudi::Property< bool > | m_doNeighborOn {this,"neighborOn", true} |
|
Gaudi::Property< double > | m_energyDepositThreshold {this,"energyDepositThreshold",300.0*CLHEP::eV,"Minimum energy deposit for hit to be digitized"} |
|
Gaudi::Property< double > | m_limitElectronKineticEnergy {this,"limitElectronKineticEnergy",5.0*CLHEP::MeV,"Minimum kinetic energy for electron hit to be digitized"} |
|
Gaudi::Property< double > | m_chargeThreshold {this,"chargeThreshold", 0.030, "vmm charge threshold in pC, need to set useCondThresholds to false if one wants to use this threshold value otherwise the one from the conditions database is used"} |
|
Gaudi::Property< bool > | m_applyAsBuiltBLines {this, "applyAsBuiltBLines",false, "correct the hit position by the as built and B-lines parameters"} |
|
const double | m_timeJitterElectronicsStrip {2.f} |
|
const double | m_timeJitterElectronicsPad {2.f} |
|
const double | m_hitTimeMergeThreshold {30.f} |
|
◆ DigiConditions
◆ sTgcDigitVec
◆ sTgcDigtCont
◆ sTgcSimDigitCont
◆ sTgcSimDigitVec
◆ sTgcDigitizationTool()
sTgcDigitizationTool::sTgcDigitizationTool |
( |
const std::string & |
type, |
|
|
const std::string & |
name, |
|
|
const IInterface * |
parent |
|
) |
| |
◆ bcTagging()
uint16_t sTgcDigitizationTool::bcTagging |
( |
const double |
digittime | ) |
|
|
staticprivate |
◆ digitize()
StatusCode sTgcDigitizationTool::digitize |
( |
const EventContext & |
ctx | ) |
|
◆ doDigitization()
StatusCode sTgcDigitizationTool::doDigitization |
( |
const EventContext & |
ctx | ) |
|
|
private |
Core part of digitization use by mergeEvent (IPileUpTool) and digitize (IMuonDigitizationTool)
apply the smearing tool to decide if the hit has to be digitized or not based on layer efficiency
Resize the container accordingly
Definition at line 267 of file MuonDigitization/sTGC_Digitization/src/sTgcDigitizationTool.cxx.
281 ATH_CHECK(digitContainer.record(std::make_unique<sTgcDigitContainer>(idHelper.module_hash_max())));
282 ATH_MSG_DEBUG (
"sTgcDigitContainer recorded in StoreGate." );
286 ATH_CHECK(sdoContainer.record(std::make_unique<MuonSimDataCollection>()));
293 sTgcSimDigitCont unmergedPadDigits{}, unmergedStripDigits{}, unmergedWireDigits{};
296 ATH_MSG_DEBUG(
"create Digit container of size " << idHelper.module_hash_max());
298 double earliestEventTime = 9999;
305 ATH_MSG_VERBOSE(
"Looping over hit " << nhits+1 <<
" on this Detector Element." );
312 if(eventTime < earliestEventTime) earliestEventTime = eventTime;
324 if (hit_kineticEnergy > 0.) {
327 ATH_MSG_DEBUG(
"Skip electron hit with kinetic energy " << hit_kineticEnergy
337 ATH_MSG_VERBOSE(
"Skip hit with a direction perpendicular to the beam line, ie z-component is less than 0.00001 mm.");
343 ATH_MSG_DEBUG(
"Updated hit global time to include off set of " << eventTime <<
" ns from OOT bunch.");
349 const int idHit = hit.
sTGCId();
351 Identifier layid = simToOffline.convert(idHit);
357 bool acceptHit =
true;
381 int surfHash_wire = detEL->
surfaceHash(idHelper.gasGap(layid),
382 sTgcIdHelper::sTgcChannelTypes::Wire);
394 const double scale = Amg::intersect<3>(LPOS, LOCDIRE, Amg::Vector3D::UnitZ(), 0.).value_or(0);
404 ATH_MSG_DEBUG(
"sTgcDigitizationTool::doDigitization hits mapped");
417 double globalHitTime = temp_hit.globalTime() + eventTime;
419 double bunchTime = globalHitTime - tof;
423 if (digiHits.empty()) {
427 for( std::unique_ptr<sTgcDigit>&
digit : digiHits) {
437 double newTime =
digit->time();
438 int newChannelType = idHelper.channelType(newDigitId);
442 if(newChannelType== sTgcIdHelper::sTgcChannelTypes::Strip)
443 newTime += timeJitterElectronicsStrip;
445 newTime += timeJitterElectronicsPad;
449 newTime += bunchTime;
451 newTime += globalHitTime;
453 double newCharge =
digit->charge();
455 bool isDead{
false},
isPileup{eventId != 0};
456 ATH_MSG_VERBOSE(
"Hit is from the main signal subevent if eventId is zero, eventId = " << eventId <<
" newTime: " << newTime);
462 <<
" BC tag = " << newDigit.bcTag()
463 <<
" digitTime = " << newDigit.time()
464 <<
" charge = " << newDigit.charge()) ;
469 std::vector<MuonSimData::Deposit> deposits;
470 deposits.push_back(std::move(deposit));
475 simData.setPosition(glob_hitOnSurf_wire);
476 simData.setTime(globalHitTime);
477 const unsigned int modHash =
static_cast<unsigned>(
m_idHelperSvc->detElementHash(newDigitId));
478 sTgcSimDigitCont& contToPush = newChannelType == sTgcIdHelper::sTgcChannelTypes::Pad ? unmergedPadDigits :
479 newChannelType == sTgcIdHelper::sTgcChannelTypes::Strip ? unmergedStripDigits : unmergedWireDigits;
481 if (contToPush.size() <= modHash) contToPush.resize(modHash + 1);
482 contToPush[modHash].emplace_back(std::move(
simData), std::move(newDigit));
513 false, outputDigits, *sdoContainer));
518 false, outputDigits, *sdoContainer));
523 if (digits.empty())
continue;
525 const IdentifierHash modHash =
m_idHelperSvc->moduleHash(elemID);
526 std::unique_ptr<sTgcDigitCollection> collection = std::make_unique<sTgcDigitCollection>(elemID, modHash);
527 collection->
insert(collection->
end(), std::make_move_iterator(digits.begin()),
528 std::make_move_iterator(digits.end()));
529 ATH_CHECK(digitContainer->addCollection(collection.release(), modHash));
531 return StatusCode::SUCCESS;
◆ filterPassed()
virtual bool PileUpToolBase::filterPassed |
( |
| ) |
const |
|
inlineoverridevirtualinherited |
◆ getChannelThreshold()
◆ getNextEvent()
StatusCode sTgcDigitizationTool::getNextEvent |
( |
const EventContext & |
ctx | ) |
|
|
private |
Get next event and extract collection of hit collections.
Definition at line 163 of file MuonDigitization/sTGC_Digitization/src/sTgcDigitizationTool.cxx.
173 if (!hitCollection.isValid()) {
174 ATH_MSG_ERROR(
"Could not get sTGCSimHitCollection container " << hitCollection.name() <<
" from store " << hitCollection.store());
175 return StatusCode::FAILURE;
179 m_thpcsTGC = std::make_unique<TimedHitCollection<sTGCSimHit>>(1);
181 ATH_MSG_DEBUG(
"sTGCSimHitCollection found with " << hitCollection->size() <<
" hits");
182 return StatusCode::SUCCESS;
186 TimedHitCollList hitCollList;
190 return StatusCode::FAILURE;
192 if (hitCollList.empty()) {
194 return StatusCode::FAILURE;
202 m_thpcsTGC = std::make_unique<TimedHitCollection<sTGCSimHit>>();
205 return StatusCode::FAILURE;
211 while (iColl != endColl) {
213 m_thpcsTGC->insert(iColl->first, p_collection);
214 ATH_MSG_DEBUG (
"sTGC SimHitCollection found with " << p_collection->size() <<
" hits" );
218 return StatusCode::SUCCESS;
◆ getRandomEngine()
CLHEP::HepRandomEngine * sTgcDigitizationTool::getRandomEngine |
( |
const std::string & |
streamName, |
|
|
const EventContext & |
ctx |
|
) |
| const |
|
private |
◆ initialize()
StatusCode sTgcDigitizationTool::initialize |
( |
| ) |
|
|
virtual |
◆ mergeEvent()
StatusCode sTgcDigitizationTool::mergeEvent |
( |
const EventContext & |
ctx | ) |
|
◆ prepareEvent()
StatusCode sTgcDigitizationTool::prepareEvent |
( |
const EventContext & |
ctx, |
|
|
const unsigned int |
nInputEvents |
|
) |
| |
◆ processAllSubEvents() [1/2]
StatusCode sTgcDigitizationTool::processAllSubEvents |
( |
const EventContext & |
ctx | ) |
|
|
virtual |
◆ 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()
Reimplemented from PileUpToolBase.
Definition at line 123 of file MuonDigitization/sTGC_Digitization/src/sTgcDigitizationTool.cxx.
126 ATH_MSG_DEBUG (
"sTgcDigitizationTool::in processBunchXing()" );
128 m_thpcsTGC = std::make_unique<TimedHitCollection<sTGCSimHit>>();
131 TimedHitCollList hitCollList;
134 bSubEvents, eSubEvents).isSuccess()) &&
135 hitCollList.empty()) {
137 return StatusCode::FAILURE;
139 ATH_MSG_VERBOSE(hitCollList.size() <<
" sTGCSimHitCollection with key " <<
147 for( ; iColl != endColl; ++iColl){
149 auto hitCollPtr = std::make_unique<sTGCSimHitCollection>(*iColl->second);
152 ATH_MSG_DEBUG(
"sTGCSimHitCollection found with " << hitCollPtr->size() <<
" hits");
154 <<
" index: " << timeIndex.index()
155 <<
" type: " << timeIndex.type());
157 m_thpcsTGC->insert(timeIndex, hitCollPtr.get());
160 return StatusCode::SUCCESS;
◆ processDigitsWithVMM() [1/2]
Sort the unmerged digit vector per layer Id -> by channel -> time from early to late arrival
Catch the cases where the channel is 1 or maxChannel
merge digits in time. Do weighed average to find time of digits originally below threshold. Follows what we expect from real VMM.
We reached another digit. No need to merge
Definition at line 630 of file MuonDigitization/sTGC_Digitization/src/sTgcDigitizationTool.cxx.
640 [&idHelper](
const sTgcSimDigitData&
a,
const sTgcSimDigitData&
b) {
641 const int layA = idHelper.gasGap(a.identify());
642 const int layB = idHelper.gasGap(b.identify());
643 if (layA != layB) return layA < layB;
644 const int chA = idHelper.channel(a.identify());
645 const int chB = idHelper.channel(b.identify());
646 if (chA != chB) return chA < chB;
647 return a.time() < b.time();
651 premerged.reserve(unmergedDigits.size());
652 savedDigits.reserve(premerged.capacity());
655 auto passNeigbourLogic = [&](
const sTgcSimDigitData& candidate) {
656 if (!isNeighborOn || savedDigits.empty())
return false;
657 if (savedDigits.back().identify() == candidate.identify() &&
658 std::abs(savedDigits.back().time() - candidate.time()) < vmmDeadTime) {
662 const Identifier digitId = candidate.identify();
663 const int channel = idHelper.channel(digitId);
664 const int maxChannel = detMgr->getsTgcReadoutElement(digitId)->numberOfStrips(digitId);
667 if (neighbour ==
channel)
continue;
668 const Identifier neighbourId = idHelper.channelID(digitId,
669 idHelper.multilayer(digitId),
670 idHelper.gasGap(digitId),
671 idHelper.channelType(digitId), neighbour);
674 if (std::find_if(savedDigits.begin(), savedDigits.end(), [&](
const sTgcSimDigitData&
known){
675 return known.identify() == neighbourId &&
676 known.getDigit().charge() > threshold &&
677 std::abs(known.time() - candidate.time()) < m_hitTimeMergeThreshold;
678 }) != savedDigits.end())
return true;
692 sTgcDigit& digit1{(*merge_me).getDigit()};
693 double totalCharge = digit1.
charge();
694 double weightedTime = digit1.time();
697 for ( ; merge_with!= unmergedDigits.end(); ++merge_with) {
699 if ((*merge_with).identify() != (*merge_me).identify()) {
702 const sTgcDigit& mergeDigit{(*merge_with).getDigit()};
708 weightedTime = (weightedTime * totalCharge + mergeDigit.time() * mergeDigit.charge())
709 / (totalCharge + mergeDigit.charge());
711 totalCharge += mergeDigit.
charge();
713 digit1.set_charge(totalCharge);
714 digit1.set_time(weightedTime);
715 sTgcSimDigitData& mergedHit{*merge_me};
716 if (!savedDigits.empty() &&
717 savedDigits.back().identify() == digit1.identify() &&
718 std::abs(savedDigits.back().time() - digit1.time()) <= vmmDeadTime)
continue;
719 if (digit1.charge() >
threshold || passNeigbourLogic(mergedHit)){
720 savedDigits.emplace_back(std::move(mergedHit));
721 }
else if (isNeighborOn) {
722 premerged.emplace_back(std::move(mergedHit));
725 std::copy_if(std::make_move_iterator(premerged.begin()),
726 std::make_move_iterator(premerged.end()),
727 std::back_inserter(savedDigits), passNeigbourLogic);
◆ processDigitsWithVMM() [2/2]
Start the merging by looping over the digit container and grouping the hits from the same layer together.
Merge all digits
Update the container iterator to go to the next layer
Assign enough space in the container vector
Push back the SDO
apply the smearing before adding the digit
Select strips with charge > 0.001 pC to avoid having zero ADC count when converting charge [pC] to PDO [ADC count]
Definition at line 573 of file MuonDigitization/sTGC_Digitization/src/sTgcDigitizationTool.cxx.
585 if (digitsInCham.empty())
continue;
588 digitsInCham, isNeighbourOn);
590 if (mergedDigits.empty())
continue;
592 const IdentifierHash
hash =
m_idHelperSvc->moduleHash(mergedDigits.front().identify());
593 const unsigned int hashIdx =
static_cast<unsigned>(
hash);
595 if (
hash >= outDigitContainer.size()) {
596 outDigitContainer.resize(
hash + 1);
598 for (sTgcSimDigitData& merged : mergedDigits) {
600 outSdoContainer.insert(std::make_pair(merged.identify(), std::move(merged.getSimData())));
602 bool acceptDigit{
true};
603 float chargeAfterSmearing = merged.getDigit().charge();
606 digiCond.rndmEngine));
613 if (idHelper.channelType(merged.identify()) == sTgcIdHelper::sTgcChannelTypes::Strip &&
614 chargeAfterSmearing < 0.001) {
617 std::unique_ptr<sTgcDigit> finalDigit = std::make_unique<sTgcDigit>(std::move(merged.getDigit()));
622 " BC tag = " << finalDigit->
bcTag()<<
623 " digitTime = " << finalDigit->
time() <<
624 " charge = " << finalDigit->
charge());
625 outDigitContainer[hashIdx].push_back(std::move(finalDigit));
628 return StatusCode::SUCCESS;
◆ resetFilter()
virtual void PileUpToolBase::resetFilter |
( |
| ) |
|
|
inlineoverridevirtualinherited |
◆ retrieveCondData()
template<class CondType >
◆ toProcess()
virtual bool PileUpToolBase::toProcess |
( |
int |
bunchXing | ) |
const |
|
inlineoverridevirtualinherited |
◆ m_applyAsBuiltBLines
Gaudi::Property<bool> sTgcDigitizationTool::m_applyAsBuiltBLines {this, "applyAsBuiltBLines",false, "correct the hit position by the as built and B-lines parameters"} |
|
private |
◆ m_calibTool
◆ m_chargeThreshold
Gaudi::Property<double> sTgcDigitizationTool::m_chargeThreshold {this,"chargeThreshold", 0.030, "vmm charge threshold in pC, need to set useCondThresholds to false if one wants to use this threshold value otherwise the one from the conditions database is used"} |
|
private |
◆ m_condThrshldsKey
◆ m_deadtimePad
Gaudi::Property<double> sTgcDigitizationTool::m_deadtimePad {this,"deadtimePad" , 250} |
|
private |
◆ m_deadtimeStrip
Gaudi::Property<double> sTgcDigitizationTool::m_deadtimeStrip {this,"deadtimeStrip", 250} |
|
private |
◆ m_deadtimeWire
Gaudi::Property<double> sTgcDigitizationTool::m_deadtimeWire {this,"deadtimeWire" , 250} |
|
private |
◆ m_detMgrKey
◆ m_digitizer
◆ m_doChannelTypes
Gaudi::Property<int> sTgcDigitizationTool::m_doChannelTypes {this,"doChannelTypes",3} |
|
private |
◆ m_doEfficiencyCorrection
Gaudi::Property<bool> sTgcDigitizationTool::m_doEfficiencyCorrection {this,"doEfficiencyCorrection",false} |
|
private |
◆ m_doNeighborOn
Gaudi::Property<bool> sTgcDigitizationTool::m_doNeighborOn {this,"neighborOn", true} |
|
private |
◆ m_doPadSharing
Gaudi::Property<bool> sTgcDigitizationTool::m_doPadSharing {this,"padChargeSharing", false} |
|
private |
◆ m_doSmearing
Gaudi::Property<bool> sTgcDigitizationTool::m_doSmearing {this,"doSmearing",false} |
|
private |
◆ m_doToFCorrection
Gaudi::Property<bool> sTgcDigitizationTool::m_doToFCorrection {this,"doToFCorrection",false} |
|
private |
◆ m_effiKey
◆ m_energyDepositThreshold
Gaudi::Property<double> sTgcDigitizationTool::m_energyDepositThreshold {this,"energyDepositThreshold",300.0*CLHEP::eV,"Minimum energy deposit for hit to be digitized"} |
|
private |
◆ m_filterPassed
bool PileUpToolBase::m_filterPassed {true} |
|
protectedinherited |
◆ 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
◆ m_hitTimeMergeThreshold
const double sTgcDigitizationTool::m_hitTimeMergeThreshold {30.f} |
|
private |
◆ m_idHelperSvc
◆ m_inputObjectName
std::string sTgcDigitizationTool::m_inputObjectName {""} |
|
private |
◆ 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_limitElectronKineticEnergy
Gaudi::Property<double> sTgcDigitizationTool::m_limitElectronKineticEnergy {this,"limitElectronKineticEnergy",5.0*CLHEP::MeV,"Minimum kinetic energy for electron hit to be digitized"} |
|
private |
◆ m_mergeSvc
◆ m_onlyUseContainerName
Gaudi::Property<bool> sTgcDigitizationTool::m_onlyUseContainerName {this, "OnlyUseContainerName", true, "Don't use the ReadHandleKey directly. Just extract the container name from it."} |
|
private |
◆ m_outputDigitCollectionKey
◆ m_outputSDO_CollectionKey
◆ m_rndmEngineName
Gaudi::Property<std::string> sTgcDigitizationTool::m_rndmEngineName {this,"RndmEngine","MuonDigitization","Random engine name"} |
|
private |
◆ m_rndmSvc
◆ m_runVoltage
Gaudi::Property<double> sTgcDigitizationTool::m_runVoltage {this,"operatingHVinkV",2.8} |
|
private |
◆ m_smearingTool
◆ m_STGCHitCollList
◆ m_thpcsTGC
◆ m_timeJitterElectronicsPad
const double sTgcDigitizationTool::m_timeJitterElectronicsPad {2.f} |
|
private |
◆ m_timeJitterElectronicsStrip
const double sTgcDigitizationTool::m_timeJitterElectronicsStrip {2.f} |
|
private |
◆ m_useCondThresholds
Gaudi::Property<bool> sTgcDigitizationTool::m_useCondThresholds {this, "useCondThresholds", false, "Use conditions data to get VMM charge threshold values"} |
|
private |
◆ 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.
The documentation for this class was generated from the following files:
JetConstituentVector::iterator iterator
void setSeed(const std::string &algName, const EventContext &ctx)
Set the random seed using a string (e.g.
const Identifier & identify(const UncalibratedMeasurement *meas)
Returns the associated identifier from the muon measurement.
std::pair< HepMcParticleLink, MuonMCData > Deposit
void set_charge(float newCharge)
const HepMcParticleLink & particleLink() const
Digitize a given hit, determining the time and charge spread on wires, pads and strips.
#define ATH_MSG_VERBOSE(x)
const std::string & key() const
Return the StoreGate ID for the referenced object.
const Amg::Vector3D & center() const
Returns the center position of the Surface.
virtual const Trk::PlaneSurface & surface() const override
access to chamber surface (phi orientation), uses the first gas gap
void stable_sort(std::reverse_iterator< DataModel_detail::iterator< DVL > > beg, std::reverse_iterator< DataModel_detail::iterator< DVL > > end, Compare comp)
Specialization of stable_sort for DataVector/List.
std::list< value_t > type
type of the collection of timed data object
float eventTime() const
t0 offset of the bunch xing containing the hit in ns.
a link optimized in size for a GenParticle in a McEventCollection
std::string toString(const Translation3D &translation, int precision=4)
GeoPrimitvesToStringConverter.
virtual int surfaceHash(const Identifier &id) const override final
returns the hash to be used to look up the surface and transform in the MuonClusterReadoutElement tra...
An sTgcReadoutElement corresponds to a single STGC module; therefore typicaly a barrel muon station c...
Eigen::Affine3d Transform3D
Out copy_if(In first, const In &last, Out res, const Pred &p)
iterator insert(iterator position, value_type pElem)
Add a new element to the collection.
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
const Amg::Vector3D & globalDirection() const
double kineticEnergy() const
double globalTime() const
A wrapper class for event-slot-local random engines.
static HepMcParticleLink getRedirectedLink(const HepMcParticleLink &particleLink, uint32_t eventIndex, const EventContext &ctx)
Return a HepMcParticleLink pointing at the same particle, but in a different GenEvent.
StatusCode initialize(bool used=true)
Eigen::Matrix< double, 3, 1 > Vector3D
CLHEP::HepRandomEngine * getEngine(const EventContext &ctx) const
Retrieve the random engine corresponding to the provided EventContext.
int particleEncoding() const
bool isPileup(int origin)
from pileup
const_iterator end() const noexcept
Return a const_iterator pointing past the end of the collection.
Identifier identify() const
unsigned short eventId() const
the index of the component event in PileUpEventInfo.
The MuonDetectorManager stores the transient representation of the Muon Spectrometer geometry and pro...
#define ATH_MSG_WARNING(x)
bool getThreshold(const Identifier &, float &) const
double depositEnergy() const
CLHEP::HepRandomEngine * rndmEngine
const Amg::Vector3D & globalPrePosition() const
a struct encapsulating the identifier of a pile-up event
const Amg::Transform3D & transform() const
Returns HepGeom::Transform3D by reference.
const Amg::Vector3D & globalPosition() const