ATLAS Offline Software
Loading...
Searching...
No Matches
Classes | Public Types | Public Member Functions | Protected Member Functions | Private Types | Private Member Functions | Private Attributes | List of all members
MuonValR4::MuonHoughTransformTester Class Reference

#include <MuonHoughTransformTester.h>

Inheritance diagram for MuonValR4::MuonHoughTransformTester:

Classes

struct  ObjectMatching

Public Types

using TruthHitCol = std::unordered_set<const xAOD::MuonSimHit*>

Public Member Functions

virtual ~MuonHoughTransformTester ()=default
virtual StatusCode initialize () override
virtual StatusCode execute (const EventContext &ctx) override
 Execute method.
virtual StatusCode finalize () override
 AthHistogramAlgorithm (const std::string &name, ISvcLocator *pSvcLocator)
 Constructor with parameters:
virtual StatusCode sysInitialize ()
 Initialization method invoked by the framework.
const ServiceHandle< ITHistSvc > & histSvc () const
 The standard THistSvc (for writing histograms and TTrees and more to a root file) Returns (kind of) a pointer to the THistSvc.
virtual bool isClonable () const override
 Specify if the algorithm is clonable.
virtual StatusCode sysExecute (const EventContext &ctx) override
 Execute an algorithm.
virtual const DataObjIDColl & extraOutputDeps () const override
 Return the list of extra output dependencies.
virtual bool filterPassed (const EventContext &ctx) const
 Get filter decision:
virtual void setFilterPassed (bool state, const EventContext &ctx) const
 Set filter decision:
ServiceHandle< StoreGateSvc > & evtStore ()
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > & detStore () const
 The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode sysStart () override
 Handle START transition.
virtual std::vector< Gaudi::DataHandle * > inputHandles () const override
 Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * > outputHandles () const override
 Return this algorithm's output handles.
Gaudi::Details::PropertyBase & declareProperty (Gaudi::Property< T, V, H > &t)
void updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream & msg () const
bool msgLvl (const MSG::Level lvl) const

Protected Member Functions

virtual bool isReEntrant () const override final
 Legacy algorithms are not thread-safe.
void renounceArray (SG::VarHandleKeyArray &handlesArray)
 remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > renounce (T &h)
void extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
 Add StoreName to extra input/output deps as needed.
StatusCode configAthHistogramming (const ServiceHandle< ITHistSvc > &histSvc, const std::string &prefix, const std::string &rootDir, const std::string &histNamePrefix, const std::string &histNamePostfix, const std::string &histTitlePrefix, const std::string &histTitlePostfix)
 To be called to fill the internal configuration.
TH1 * bookGetPointer (const TH1 &hist, std::string_view tDir="", std::string_view stream="")
 Simplify the booking and registering (into THistSvc) of histograms.
TH1 * bookGetPointer (TH1 *hist, std::string_view tDir="", std::string_view stream="")
 Simplify the booking and registering (into THistSvc) of histograms.
TH1 * bookGetPointer (TH1 &histRef, std::string_view tDir="", std::string_view stream="")
 Simplify the booking and registering (into THistSvc) of histograms.
TTree * bookGetPointer (const TTree &treeRef, std::string_view tDir="", std::string_view stream="")
 Simplify the booking and registering (into THistSvc) of TTrees.
TGraph * bookGetPointer (const TGraph &graphRef, std::string_view tDir="", std::string_view stream="")
 Simplify the booking and registering (into THistSvc) of TGraphs.
TEfficiency * bookGetPointer (const TEfficiency &eff, std::string_view tDir="", std::string_view stream="")
 Simplify the booking and registering (into THistSvc) of TEfficiency.
TEfficiency * bookGetPointer (TEfficiency *eff, std::string_view tDir="", std::string_view stream="")
 Simplify the booking and registering (into THistSvc) of TEfficiency.
TEfficiency * bookGetPointer (TEfficiency &effRef, std::string_view tDir="", std::string_view stream="")
 Simplify the booking and registering (into THistSvc) of TEfficiency.
StatusCode book (const TH1 &hist, std::string_view tDir="", std::string_view stream="")
 Simplify the booking and registering (into THistSvc) of histograms.
StatusCode book (TH1 *hist, std::string_view tDir="", std::string_view stream="")
 Simplify the booking and registering (into THistSvc) of histograms.
StatusCode book (TH1 &histRef, std::string_view tDir="", std::string_view stream="")
 Simplify the booking and registering (into THistSvc) of histograms.
StatusCode book (const TTree &treeRef, std::string_view tDir="", std::string_view stream="")
 Simplify the booking and registering (into THistSvc) of TTrees.
StatusCode book (const TGraph &graphRef, std::string_view tDir="", std::string_view stream="")
 Simplify the booking and registering (into THistSvc) of TGraphs.
StatusCode book (const TEfficiency &eff, std::string_view tDir="", std::string_view stream="")
 Simplify the booking and registering (into THistSvc) of TEfficiency.
StatusCode book (TEfficiency *eff, std::string_view tDir="", std::string_view stream="")
 Simplify the booking and registering (into THistSvc) of TEfficiency.
StatusCode book (TEfficiency &effRef, std::string_view tDir="", std::string_view stream="")
 Simplify the booking and registering (into THistSvc) of TEfficiency.
TH1 * hist (std::string_view histName, std::string_view tDir="", std::string_view stream="")
 Simplify the retrieval of registered histograms of any type.
TH2 * hist2d (std::string_view histName, std::string_view tDir="", std::string_view stream="")
 Simplify the retrieval of registered 2-d histograms.
TH3 * hist3d (std::string_view histName, std::string_view tDir="", std::string_view stream="")
 Simplify the retrieval of registered 3-d histograms.
TTree * tree (std::string_view treeName, std::string_view tDir="", std::string_view stream="")
 Simplify the retrieval of registered TTrees.
TGraph * graph (std::string_view graphName, std::string_view tDir="", std::string_view stream="")
 Simplify the retrieval of registered TGraphs.
TEfficiency * efficiency (std::string_view effName, std::string_view tDir="", std::string_view stream="")
 Simplify the retrieval of registered TEfficiency.

Private Types

using FloatVecBrPtr_t = std::shared_ptr<MuonVal::VectorBranch<float>>
typedef ServiceHandle< StoreGateSvc > StoreGateSvc_t
typedef uint32_t hash_t
 typedef for the internal hash
typedef std::map< const hash_t, TH1 * > HistMap_t
 Typedef for convenience.
typedef std::map< const hash_t, TEfficiency * > EffMap_t
 Typedef for convenience.
typedef std::map< const hash_t, TTree * > TreeMap_t
 Typedef for convenience.
typedef std::map< const hash_t, TGraph * > GraphMap_t
 Typedef for convenience.

Private Member Functions

std::vector< ObjectMatching > matchWithTruth (const MuonR4::SegmentSeedContainer &seedContainer, const xAOD::MuonSegmentContainer &segmentContainer, const xAOD::MuonSegmentContainer *truthSegments) const
unsigned int countOnSameSide (const xAOD::MuonSegment &truthSeg, const xAOD::MuonSegment &recoSeg) const
 Calculates how many measurements from the segment fit have the same drift sign as when evaluated with the truth parameters.
void fillChamberInfo (const MuonGMR4::SpectrometerSector *chamber)
 Fill the current chamber info into the output.
void fillTruthInfo (const ActsTrk::GeometryContext &gctx, const xAOD::MuonSegment *truthSegment)
 Fill the associated truth information into the tree.
void fillBucketInfo (const MuonR4::SpacePointBucket &bucket)
 Fill the hit summary info of the associated bucket.
void fillSeedInfo (const ObjectMatching &obj)
 Fill the info associated to the seed.
void fillSegmentInfo (const ObjectMatching &obj)
 Fill the info assciated to the segment.
void fillRecoSummary (const xAOD::MuonSegment &recoSegment)
void fillTruthSummary (const xAOD::MuonSegment &recoSegment)
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey>
std::string buildBookingString (std::string_view histName, std::string_view tDir, std::string_view stream, bool usePrefixPostfix=false) const
 Method to build individual booking string.
hash_t hash (std::string_view histName) const
 Method to calculate a 32-bit hash from a string.

Private Attributes

MuonVal::MuonTesterTree m_tree {"MuonEtaHoughTest","MuonEtaHoughTransformTest"}
SG::ReadHandleKey< xAOD::MuonSegmentContainer > m_truthSegmentKey {this, "TruthSegmentKey","MuonTruthSegments", "truth segment container"}
 Key to the truth segment.
SG::ReadDecorHandleKeyArray< xAOD::MuonSegmentContainer > m_truthSegLinkKeys {this, "TruthSegLinkKeys", {}}
 Declare the dependencies on the decorations.
Gaudi::Property< std::vector< std::string > > m_truthLinks {this, "TruthSegLinks", {"simHitLinks", "truthParticleLink"}}
 Name of the decorations for the truth segment.
SG::ReadHandleKey< xAOD::MuonSegmentContainer > m_recoSegKey {this, "SegmentKey", "MsSegments"}
 Key to the xAOD::MuonSegment container.
Gaudi::Property< std::vector< std::string > > m_recoSegLinks {this, "RecoSegLinks", {"truthSegmentLink", "truthParticleLink"}}
 name of the truth link decorations for the reco segment container
SG::ReadHandleKeyArray< MuonR4::SegmentSeedContainer > m_patternSeedKeys {this, "SegmentSeedKeys", {"MuonHoughStationSegmentSeeds"}}
 List of the two segment seed containers from which the segments are buiit (Complets the pattern finding step).
SG::ReadHandleKeyArray< MuonR4::SpacePointContainer > m_spKeys {this, "SpacePointKeys", {"MuonSpacePoints"}}
 List of the space point containers in the event legacy + NSW containers.
ActsTrk::GeoContextReadKey_t m_geoCtxKey {this, "AlignmentKey", "ActsAlignment", "cond handle key"}
 Tracking geometry context.
ServiceHandle< Muon::IMuonIdHelperSvc > m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}
Gaudi::Property< bool > m_isMC {this, "isMC", false, "Toggle whether the job is ran on MC or not"}
Gaudi::Property< bool > m_writeSpacePoints
MuonVal::ScalarBranch< int > & m_out_chamberIndex {m_tree.newScalar<int>("chamberIndex")}
 ====== Common block: Filled for all entries ===========
MuonVal::ScalarBranch< short > & m_out_stationSide {m_tree.newScalar<short>("stationSide")}
 +1 for A-, -1 of C-side
MuonVal::ScalarBranch< int > & m_out_stationPhi {m_tree.newScalar<int>("stationPhi")}
 phi index of the station
MuonVal::ScalarBranch< float > & m_out_bucketStart {m_tree.newScalar<float>("bucket_start", 1)}
MuonVal::ScalarBranch< float > & m_out_bucketEnd {m_tree.newScalar<float>("bucket_end", -1)}
MuonVal::ScalarBranch< float > & m_out_bucketEtaHitGap {m_tree.newScalar<float>("bucket_etaHitGap", 0.)}
std::shared_ptr< SpacePointTesterModule > m_spTester {}
 Branch dumping all the space points from the difference buckets.
MuonVal::MatrixBranch< unsigned char > & m_spMatchedToPattern {m_tree.newMatrix<unsigned char>("seed_matchedSpacPoins")}
 Branch indicating which space points in the tree are associated to the i-th pattern.
MuonVal::MatrixBranch< unsigned char > & m_spMatchedToSegment {m_tree.newMatrix<unsigned char>("segment_matchedSpacePoints")}
 Branch indicating which space points in the tree are associated to the i-th segment.
MuonVal::ScalarBranch< unsigned char > & m_out_nSpacePoints {m_tree.newScalar<unsigned char>("bucket_nHits",0)}
 Number of all space points in the bucket.
MuonVal::ScalarBranch< unsigned char > & m_out_nPrecSpacePoints {m_tree.newScalar<unsigned char>("bucket_nPrecMeas",0)}
 Number of precision hits in the bucket.
MuonVal::ScalarBranch< unsigned char > & m_out_nPhiSpacePoints {m_tree.newScalar<unsigned char>("bucket_nPhiMeass",0)}
 Number of phi hits in the bucket.
MuonVal::ScalarBranch< unsigned char > & m_out_nTrueSpacePoints {m_tree.newScalar<unsigned char>("bucket_nTrueMeas",0)}
 Number of all space points in the bucket.
MuonVal::ScalarBranch< unsigned char > & m_out_nTruePrecSpacePoints {m_tree.newScalar<unsigned char>("bucket_nTruePrecMeas",0)}
 Number of precision hits in the bucket.
MuonVal::ScalarBranch< unsigned char > & m_out_nTruePhiSpacePoints {m_tree.newScalar<unsigned char>("bucket_nTruePhiMeass",0)}
 Number of phi hits in the bucket.
MuonVal::ScalarBranch< char > & m_out_hasTruth {m_tree.newScalar<char>("gen_exists",false)}
 ======= Truth block: Filled if we have a truth match. ============
MuonVal::ScalarBranch< float > & m_out_gen_Eta {m_tree.newScalar<float>("gen_eta",-10.)}
 global particle properties
MuonVal::ScalarBranch< float > & m_out_gen_Phi {m_tree.newScalar<float>("gen_phi",-10.)}
MuonVal::ScalarBranch< float > & m_out_gen_Pt {m_tree.newScalar<float>("gen_pt",-10.)}
MuonVal::ScalarBranch< short > & m_out_gen_Q {m_tree.newScalar<short>("gen_q", 0)}
MuonVal::ScalarBranch< float > & m_out_gen_truthBeta {m_tree.newScalar<float>("gen_beta", -1)}
MuonVal::ScalarBranch< float > & m_out_gen_y0 {m_tree.newScalar<float>("gen_y0", 0.0)}
 Truth - segment parameters.
MuonVal::ScalarBranch< float > & m_out_gen_tanbeta {m_tree.newScalar<float>("gen_tanBeta", 0.0)}
MuonVal::ScalarBranch< float > & m_out_gen_tanalpha {m_tree.newScalar<float>("gen_tanAlpha", 0.0)}
MuonVal::ScalarBranch< float > & m_out_gen_x0 {m_tree.newScalar<float>("gen_x0", 0.0)}
MuonVal::ScalarBranch< float > & m_out_gen_time {m_tree.newScalar<float>("gen_time", 0.0)}
MuonVal::ScalarBranch< int > & m_out_gen_truthOrigin {m_tree.newScalar<int>("gen_origin", -1)}
 MC truth calssifier definition.
MuonVal::ScalarBranch< int > & m_out_gen_truthType {m_tree.newScalar<int>("gen_type", -1)}
MuonVal::ScalarBranch< int > & m_out_gen_truthPdgId {m_tree.newScalar<int>("gen_pdgId", 0)}
MuonVal::ScalarBranch< float > & m_out_gen_beamSpotR {m_tree.newScalar<float>("gen_beamSpotR", -1.f)}
 Beamspot approach.
MuonVal::ScalarBranch< float > & m_out_gen_beamSpotZ {m_tree.newScalar<float>("gen_beamSpotZ", -1.f)}
MuonVal::ScalarBranch< float > & m_out_gen_deflection {m_tree.newScalar<float>("gen_dThetaPosDir", -1.f)}
MuonVal::ScalarBranch< float > & m_out_gen_deflectionEta {m_tree.newScalar<float>("gen_dEtaPosDir", -3.f)}
MuonVal::ScalarBranch< unsigned short > & m_out_gen_nPrecHits {m_tree.newScalar<unsigned short>("gen_nPrecHits",0)}
 Truth - hit count summary.
MuonVal::ScalarBranch< unsigned short > & m_out_gen_nTrigEtaHits {m_tree.newScalar<unsigned short>("gen_nTrigEtaHits",0)}
MuonVal::ScalarBranch< unsigned short > & m_out_gen_nTrigPhiHits {m_tree.newScalar<unsigned short>("gen_nTrigPhiHits",0)}
MuonVal::ScalarBranch< unsigned short > & m_out_gen_nMmEtaHits {m_tree.newScalar<unsigned short>("gen_nMmEtaHits",0)}
MuonVal::ScalarBranch< unsigned short > & m_out_gen_nMmStereoHits {m_tree.newScalar<unsigned short>("gen_nMmStereoHits",0)}
MuonVal::ScalarBranch< unsigned short > & m_out_gen_nStgcHits {m_tree.newScalar<unsigned short>("gen_nStgcHits",0)}
MuonVal::ScalarBranch< float > & m_out_gen_minYhit {m_tree.newScalar<float>("gen_hitMinY0", 1.0)}
MuonVal::ScalarBranch< float > & m_out_gen_maxYhit {m_tree.newScalar<float>("gen_hitMaxY0", -1.0)}
MuonVal::ScalarBranch< unsigned > & m_out_seed_n {m_tree.newScalar<unsigned>("nSeeds", 0)}
 ========== Seed block: Filled when we have one or multiple seeds ============= seed count
MuonVal::VectorBranch< unsigned short > & m_out_seed_hasPhiExtension {m_tree.newVector<unsigned short>("seed_hasPhiExtension", false)}
MuonVal::VectorBranch< float > & m_out_seed_y0 {m_tree.newVector<float>("seed_y0", 0.0)}
MuonVal::VectorBranch< float > & m_out_seed_x0 {m_tree.newVector<float>("seed_x0", 0.0)}
MuonVal::VectorBranch< float > & m_out_seed_tanbeta {m_tree.newVector<float>("seed_tanBeta", 0.0)}
MuonVal::VectorBranch< float > & m_out_seed_tanalpha {m_tree.newVector<float>("seed_tanAlpha", 0.0)}
MuonVal::VectorBranch< float > & m_out_seed_minYhit {m_tree.newVector<float>("seed_hitMinY0", 1.0)}
MuonVal::VectorBranch< float > & m_out_seed_maxYhit {m_tree.newVector<float>("seed_hitMaxY0", -1.0)}
MuonVal::VectorBranch< unsigned short > & m_out_seed_nPrecHits {m_tree.newVector<unsigned short>("seed_nPrecHits", 0)}
MuonVal::VectorBranch< unsigned short > & m_out_seed_nEtaHits {m_tree.newVector<unsigned short>("seed_nTrigEtaHits", 0)}
MuonVal::VectorBranch< unsigned short > & m_out_seed_nPhiHits {m_tree.newVector<unsigned short>("seed_nTrigPhiHits", 0)}
MuonVal::VectorBranch< unsigned short > & m_out_seed_nTruePrecHits {m_tree.newVector<unsigned short>("seed_nTruePrecHits", 0)}
MuonVal::VectorBranch< unsigned short > & m_out_seed_nTrueEtaHits {m_tree.newVector<unsigned short>("seed_nTrueTrigEtaHits", 0)}
MuonVal::VectorBranch< unsigned short > & m_out_seed_nTruePhiHits {m_tree.newVector<unsigned short>("seed_nTrueTrigPhiHits", 0)}
MuonVal::VectorBranch< unsigned short > & m_out_seed_nMmEtaHits {m_tree.newVector<unsigned short>("seed_nMmEtaHits", 0)}
MuonVal::VectorBranch< unsigned short > & m_out_seed_nMmStereoHits {m_tree.newVector<unsigned short>("seed_nMmStereoHits", 0)}
MuonVal::VectorBranch< unsigned short > & m_out_seed_nTrueMmEtaHits {m_tree.newVector<unsigned short>("seed_nMmTrueEtaHits", 0)}
MuonVal::VectorBranch< unsigned short > & m_out_seed_nTrueMmStereoHits {m_tree.newVector<unsigned short>("seed_nMmTrueStereoHits", 0)}
MuonVal::VectorBranch< unsigned short > & m_out_seed_nsTgcStripHits {m_tree.newVector<unsigned short>("seed_nStgcStripHits", 0)}
MuonVal::VectorBranch< unsigned short > & m_out_seed_nsTgcWireHits {m_tree.newVector<unsigned short>("seed_nStgcWireHits", 0)}
MuonVal::VectorBranch< unsigned short > & m_out_seed_nsTgcPadHits {m_tree.newVector<unsigned short>("seed_nStgcPadHits", 0)}
MuonVal::VectorBranch< unsigned short > & m_out_seed_nTruesTgcStripHits {m_tree.newVector<unsigned short>("seed_nStgcTrueStripHits", 0)}
MuonVal::VectorBranch< unsigned short > & m_out_seed_nTruesTgcWireHits {m_tree.newVector<unsigned short>("seed_nStgcTrueWireHits", 0)}
MuonVal::VectorBranch< unsigned short > & m_out_seed_nTruesTgcPadHits {m_tree.newVector<unsigned short>("seed_nStgcTruePadHits", 0)}
MuonVal::VectorBranch< unsigned char > & m_out_seed_ledToSegment {m_tree.newVector<unsigned char>("seed_becameSegment",false)}
MuonVal::ScalarBranch< unsigned > & m_out_segment_n {m_tree.newScalar<unsigned>("nSegments", 0)}
 ========== Segment block: Filled when we have one or multiple segments =============
MuonVal::VectorBranch< float > & m_out_segment_chi2 {m_tree.newVector<float>("segment_chi2", -1.)}
MuonVal::VectorBranch< uint16_t > & m_out_segment_nDoF {m_tree.newVector<uint16_t>("segment_nDoF", 0)}
MuonVal::VectorBranch< char > & m_out_segment_hasTimeFit {m_tree.newVector<char>("segment_hasTimeFit", false)}
MuonVal::VectorBranch< uint16_t > & m_out_segment_fitIter {m_tree.newVector<uint16_t>("segment_nIter", 0)}
MuonVal::VectorBranch< float > & m_out_segment_y0 {m_tree.newVector<float>("segment_y0", 0.)}
MuonVal::VectorBranch< float > & m_out_segment_x0 {m_tree.newVector<float>("segment_x0", 0.)}
MuonVal::VectorBranch< float > & m_out_segment_theta {m_tree.newVector<float>("segment_theta", 0.)}
MuonVal::VectorBranch< float > & m_out_segment_phi {m_tree.newVector<float>("segment_phi", 0.)}
MuonVal::VectorBranch< float > & m_out_segment_time {m_tree.newVector<float>("segment_t0", 0.)}
std::array< FloatVecBrPtr_t, Acts::sumUpToN(Acts::toUnderlying(MuonR4::SegmentFit::ParamDefs::nPars))> m_segmentCov {}
MuonVal::VectorBranch< unsigned short > & m_out_segment_nPrecHits {m_tree.newVector<unsigned short>("segment_nPrecHits", 0)}
 Hit counts on segment.
MuonVal::VectorBranch< unsigned short > & m_out_segment_nTrigEtaHits {m_tree.newVector<unsigned short>("segment_nTrigEtaHits", 0)}
MuonVal::VectorBranch< unsigned short > & m_out_segment_nTrigPhiHits {m_tree.newVector<unsigned short>("segment_nTrigPhiHits", 0)}
MuonVal::VectorBranch< unsigned short > & m_out_segment_nPrecOutliers {m_tree.newVector<unsigned short>("segment_nPrecOutliers", 0)}
MuonVal::VectorBranch< unsigned short > & m_out_segment_nTrigEtaOutliers {m_tree.newVector<unsigned short>("segment_nTrigEtaOutliers", 0)}
MuonVal::VectorBranch< unsigned short > & m_out_segment_nTrigPhiOutliers {m_tree.newVector<unsigned short>("segment_nTrigPhiOutliers", 0)}
MuonVal::VectorBranch< unsigned short > & m_out_segment_nPrecHoles {m_tree.newVector<unsigned short>("segment_nPrecHoles", 0)}
MuonVal::VectorBranch< unsigned short > & m_out_segment_nTrigEtaHoles {m_tree.newVector<unsigned short>("segment_nTrigEtaHoles", 0)}
MuonVal::VectorBranch< unsigned short > & m_out_segment_nTrigPhiHoles {m_tree.newVector<unsigned short>("segment_nTrigPhiHoles", 0)}
MuonVal::VectorBranch< unsigned short > & m_out_segment_nTruePrecHits {m_tree.newVector<unsigned short>("segment_nTruePrecHits", 0)}
 True matched hit counters.
MuonVal::VectorBranch< unsigned short > & m_out_segment_nTrueTrigEtaHits {m_tree.newVector<unsigned short>("segment_nTrueTrigEtaHits", 0)}
MuonVal::VectorBranch< unsigned short > & m_out_segment_nTrueTrigPhiHits {m_tree.newVector<unsigned short>("segment_nTrueTrigPhiHits", 0)}
MuonVal::VectorBranch< unsigned short > & m_out_segment_nTruePrecOutliers {m_tree.newVector<unsigned short>("segment_nTruePrecOutliers", 0)}
MuonVal::VectorBranch< unsigned short > & m_out_segment_nTrueTrigEtaOutliers {m_tree.newVector<unsigned short>("segment_nTrueTrigEtaOutliers", 0)}
MuonVal::VectorBranch< unsigned short > & m_out_segment_nTrueTrigPhiOutliers {m_tree.newVector<unsigned short>("segment_nTrueTrigPhiOutliers", 0)}
MuonVal::VectorBranch< unsigned short > & m_out_segment_nMmEtaHits {m_tree.newVector<unsigned short>("segment_nMmEtaHits", 0)}
 NSW hit counters.
MuonVal::VectorBranch< unsigned short > & m_out_segment_nMmStereoHits {m_tree.newVector<unsigned short>("segment_nMmStereoHits", 0)}
MuonVal::VectorBranch< unsigned short > & m_out_segment_nSTgcStripHits {m_tree.newVector<unsigned short>("segment_nStgcStripHits", 0)}
MuonVal::VectorBranch< unsigned short > & m_out_segment_nSTgcWireHits {m_tree.newVector<unsigned short>("segment_nStgcWireHits", 0)}
MuonVal::VectorBranch< unsigned short > & m_out_segment_nSTgcPadHits {m_tree.newVector<unsigned short>("segment_nStgcPadHits", 0)}
MuonVal::VectorBranch< unsigned short > & m_out_segment_nMmTrueEtaHits {m_tree.newVector<unsigned short>("segment_nMmTrueEtaHits", 0)}
MuonVal::VectorBranch< unsigned short > & m_out_segment_nMmTrueStereoHits {m_tree.newVector<unsigned short>("segment_nMmTrueStereoHits", 0)}
MuonVal::VectorBranch< unsigned short > & m_out_segment_nSTgcTrueStripHits {m_tree.newVector<unsigned short>("segment_nStgcTrueStripHits", 0)}
MuonVal::VectorBranch< unsigned short > & m_out_segment_nSTgcTrueWireHits {m_tree.newVector<unsigned short>("segment_nStgcTrueWireHits", 0)}
MuonVal::VectorBranch< unsigned short > & m_out_segment_nSTgcTruePadHits {m_tree.newVector<unsigned short>("segment_nStgcTruePadHits", 0)}
MuonVal::VectorBranch< unsigned short > & m_out_segment_nMmEtaOutliers {m_tree.newVector<unsigned short>("segment_nMmEtaOutliers", 0)}
MuonVal::VectorBranch< unsigned short > & m_out_segment_nMmStereoOutliers {m_tree.newVector<unsigned short>("segment_nMmStereoOutliers", 0)}
MuonVal::VectorBranch< unsigned short > & m_out_segment_nSTgcStripOutliers {m_tree.newVector<unsigned short>("segment_nStgcStripOutliers", 0)}
MuonVal::VectorBranch< unsigned short > & m_out_segment_nSTgcWireOutliers {m_tree.newVector<unsigned short>("segment_nStgcWireOutliers", 0)}
MuonVal::VectorBranch< unsigned short > & m_out_segment_nSTgcPadOutliers {m_tree.newVector<unsigned short>("segment_nStgcPadOutliers", 0)}
MuonVal::VectorBranch< unsigned short > & m_out_segment_nMmTrueEtaOutliers {m_tree.newVector<unsigned short>("segment_nMmTrueEtaOutliers", 0)}
MuonVal::VectorBranch< unsigned short > & m_out_segment_nMmTrueStereoOutliers {m_tree.newVector<unsigned short>("segment_nMmTrueStereoOutliers", 0)}
MuonVal::VectorBranch< unsigned short > & m_out_segment_nSTgcTrueStripOutliers {m_tree.newVector<unsigned short>("segment_nStgcTrueStripOutliers", 0)}
MuonVal::VectorBranch< unsigned short > & m_out_segment_nSTgcTrueWireOutliers {m_tree.newVector<unsigned short>("segment_nStgcTrueWireOutliers", 0)}
MuonVal::VectorBranch< unsigned short > & m_out_segment_nSTgcTruePadOutliers {m_tree.newVector<unsigned short>("segment_nStgcTruePadOutliers", 0)}
MuonVal::VectorBranch< float > & m_out_segment_minYhit {m_tree.newVector<float>("segment_hitMinY0", 1.0)}
MuonVal::VectorBranch< float > & m_out_segment_maxYhit {m_tree.newVector<float>("segment_hitMinY0", -1.0)}
MuonVal::VectorBranch< float > & m_out_segment_minTrueYhit {m_tree.newVector<float>("segment_trueHitMinY0", 1.0)}
MuonVal::VectorBranch< float > & m_out_segment_maxTrueYhit {m_tree.newVector<float>("segment_trueHitMaxY0", -1.0)}
ToolHandle< MuonValR4::IPatternVisualizationTool > m_visionTool {this, "VisualizationTool", ""}
 Pattern visualization tool.
const MuonGMR4::MuonDetectorManager * m_detMgr {nullptr}
ServiceHandle< ITHistSvc > m_histSvc
 Default constructor: AthHistogramAlgorithm();.
std::string m_prefix
 Name of the ROOT output stream (file).
std::string m_rootDir
 Name of the ROOT directory.
std::string m_histNamePrefix
 The prefix for the histogram THx name.
std::string m_histNamePostfix
 The postfix for the histogram THx name.
std::string m_histTitlePrefix
 The prefix for the histogram THx title.
std::string m_histTitlePostfix
 The postfix for the histogram THx title.
DataObjIDColl m_extendedExtraObjects
 Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.
StoreGateSvc_t m_evtStore
 Pointer to StoreGate (event store by default).
StoreGateSvc_t m_detStore
 Pointer to StoreGate (detector store by default).
std::vector< SG::VarHandleKeyArray * > m_vhka
bool m_varHandleArraysDeclared
HistMap_t m_histMap
 The map of histogram names to their pointers.
EffMap_t m_effMap
 The map of histogram names to their pointers.
TreeMap_t m_treeMap
 The map of TTree names to their pointers.
GraphMap_t m_graphMap
 The map of TGraph names to their pointers.
std::string m_streamName
 Name of the ROOT output stream (file).
std::string m_name
 Instance name.
MsgStream m_msg
 Cached Message Stream.

Detailed Description

Definition at line 38 of file MuonHoughTransformTester.h.

Member Typedef Documentation

◆ EffMap_t

typedef std::map< const hash_t, TEfficiency* > AthHistogramming::EffMap_t
privateinherited

Typedef for convenience.

Definition at line 199 of file AthHistogramming.h.

◆ FloatVecBrPtr_t

using MuonValR4::MuonHoughTransformTester::FloatVecBrPtr_t = std::shared_ptr<MuonVal::VectorBranch<float>>
private

Definition at line 258 of file MuonHoughTransformTester.h.

◆ GraphMap_t

typedef std::map< const hash_t, TGraph* > AthHistogramming::GraphMap_t
privateinherited

Typedef for convenience.

Definition at line 213 of file AthHistogramming.h.

◆ hash_t

typedef uint32_t AthHistogramming::hash_t
privateinherited

typedef for the internal hash

Definition at line 171 of file AthHistogramming.h.

◆ HistMap_t

typedef std::map< const hash_t, TH1* > AthHistogramming::HistMap_t
privateinherited

Typedef for convenience.

Definition at line 192 of file AthHistogramming.h.

◆ StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::StoreGateSvc_t
privateinherited

Definition at line 376 of file AthCommonDataStore.h.

◆ TreeMap_t

typedef std::map< const hash_t, TTree* > AthHistogramming::TreeMap_t
privateinherited

Typedef for convenience.

Definition at line 206 of file AthHistogramming.h.

◆ TruthHitCol

using MuonValR4::MuonHoughTransformTester::TruthHitCol = std::unordered_set<const xAOD::MuonSimHit*>

Definition at line 47 of file MuonHoughTransformTester.h.

Constructor & Destructor Documentation

◆ ~MuonHoughTransformTester()

virtual MuonValR4::MuonHoughTransformTester::~MuonHoughTransformTester ( )
virtualdefault

Member Function Documentation

◆ AthHistogramAlgorithm()

AthHistogramAlgorithm::AthHistogramAlgorithm ( const std::string & name,
ISvcLocator * pSvcLocator )

Constructor with parameters:

Definition at line 40 of file AthHistogramAlgorithm.cxx.

32 :
33 ::AthAlgorithm( name, pSvcLocator ),
34 ::AthHistogramming( name ),
35 m_histSvc ( "THistSvc/THistSvc", name )
36{
37 //
38 // Property declaration
39 //
40 // The histogram service
41 declareProperty("THistSvc",
42 m_histSvc = ServiceHandle<ITHistSvc>("THistSvc/THistSvc", name),
43 "Handle to a THistSvc instance: it will be used to write "
44 "ROOT objects to ROOT files" );
45 // declareProperty("THistService", m_histSvc, "The THistSvc" );
46
47 declareProperty("RootStreamName", m_prefix = "/ANALYSIS", "Name of the output ROOT stream (file) that the THistSvc uses");
48 declareProperty("RootDirName", m_rootDir = "",
49 "Name of the ROOT directory inside the ROOT file where the histograms will go");
50
51 declareProperty( "HistNamePrefix", m_histNamePrefix = "", "The prefix for the histogram THx name" );
52 declareProperty( "HistNamePostfix", m_histNamePostfix = "", "The postfix for the histogram THx name" );
53
54 declareProperty( "HistTitlePrefix", m_histTitlePrefix = "", "The prefix for the histogram THx title" );
55 declareProperty( "HistTitlePostfix", m_histTitlePostfix = "", "The postfix for the histogram THx title" );
56}
AthAlgorithm::AthAlgorithm
AthAlgorithm(const std::string &name, ISvcLocator *pSvcLocator)
Constructor.
Definition AthAlgorithm.cxx:10
AthCommonAlgorithm< Gaudi::Algorithm >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T, V, H > &t)
Definition AthCommonDataStore.h:145
AthHistogramAlgorithm::m_histNamePrefix
std::string m_histNamePrefix
The prefix for the histogram THx name.
Definition AthHistogramAlgorithm.h:94
AthHistogramAlgorithm::m_histSvc
ServiceHandle< ITHistSvc > m_histSvc
Default constructor: AthHistogramAlgorithm();.
Definition AthHistogramAlgorithm.h:83
AthHistogramAlgorithm::m_prefix
std::string m_prefix
Name of the ROOT output stream (file).
Definition AthHistogramAlgorithm.h:88
AthHistogramAlgorithm::m_histNamePostfix
std::string m_histNamePostfix
The postfix for the histogram THx name.
Definition AthHistogramAlgorithm.h:97
AthHistogramAlgorithm::m_histTitlePostfix
std::string m_histTitlePostfix
The postfix for the histogram THx title.
Definition AthHistogramAlgorithm.h:103
AthHistogramAlgorithm::m_rootDir
std::string m_rootDir
Name of the ROOT directory.
Definition AthHistogramAlgorithm.h:91
AthHistogramAlgorithm::m_histTitlePrefix
std::string m_histTitlePrefix
The prefix for the histogram THx title.
Definition AthHistogramAlgorithm.h:100
AthHistogramming::AthHistogramming
AthHistogramming(const std::string &name)
Constructor with parameters:
Definition AthHistogramming.cxx:39

◆ book() [1/8]

StatusCode AthHistogramming::book ( const TEfficiency & eff,
std::string_view tDir = "",
std::string_view stream = "" )
inlineprotectedinherited

Simplify the booking and registering (into THistSvc) of TEfficiency.

Definition at line 329 of file AthHistogramming.h.

330{
331 // We need to create a non-const clone
332 TEfficiency* effClone = dynamic_cast< TEfficiency* >( eff.Clone() );
333 if ( !effClone ) {
334 m_msg << MSG::ERROR << "Couldn't create a TEfficiency clone" << endmsg;
335 return StatusCode::FAILURE;
336 }
337 return this->book( *effClone, tDir, stream );
338}
endmsg
#define endmsg
Definition AnalysisConfig_Ntuple.cxx:54
AthHistogramming::book
StatusCode book(const TH1 &hist, std::string_view tDir="", std::string_view stream="")
Simplify the booking and registering (into THistSvc) of histograms.
Definition AthHistogramming.h:297
AthHistogramming::m_msg
MsgStream m_msg
Cached Message Stream.
Definition AthHistogramming.h:242
dqt_zlumi_alleff_HIST.eff
int eff
Definition dqt_zlumi_alleff_HIST.py:113

◆ book() [2/8]

StatusCode AthHistogramming::book ( const TGraph & graphRef,
std::string_view tDir = "",
std::string_view stream = "" )
inlineprotectedinherited

Simplify the booking and registering (into THistSvc) of TGraphs.

◆ book() [3/8]

StatusCode AthHistogramming::book ( const TH1 & hist,
std::string_view tDir = "",
std::string_view stream = "" )
inlineprotectedinherited

Simplify the booking and registering (into THistSvc) of histograms.

Definition at line 297 of file AthHistogramming.h.

298{
299 // We need to create a non-const clone
300 TH1* histClone = dynamic_cast< TH1* >( hist.Clone() );
301 if ( !histClone ) {
302 m_msg << MSG::ERROR << "Couldn't create a TH1 clone" << endmsg;
303 return StatusCode::FAILURE;
304 }
305 return this->book( *histClone, tDir, stream );
306}
AthHistogramming::hist
TH1 * hist(std::string_view histName, std::string_view tDir="", std::string_view stream="")
Simplify the retrieval of registered histograms of any type.
Definition AthHistogramming.cxx:182

◆ book() [4/8]

StatusCode AthHistogramming::book ( const TTree & treeRef,
std::string_view tDir = "",
std::string_view stream = "" )
inlineprotectedinherited

Simplify the booking and registering (into THistSvc) of TTrees.

Definition at line 397 of file AthHistogramming.h.

398{
399 // Call the other Book method and see if it returns a valid pointer
400 TTree* treePointer = this->bookGetPointer( treeRef, tDir, stream );
401 if ( treePointer )
402 {
403 return StatusCode::SUCCESS;
404 }
405 else
406 {
407 return StatusCode::FAILURE;
408 }
409}
AthHistogramming::bookGetPointer
TH1 * bookGetPointer(const TH1 &hist, std::string_view tDir="", std::string_view stream="")
Simplify the booking and registering (into THistSvc) of histograms.
Definition AthHistogramming.h:254

◆ book() [5/8]

StatusCode AthHistogramming::book ( TEfficiency & effRef,
std::string_view tDir = "",
std::string_view stream = "" )
inlineprotectedinherited

Simplify the booking and registering (into THistSvc) of TEfficiency.

Definition at line 350 of file AthHistogramming.h.

351{
352 // Call the other Book method and see if it returns a valid pointer
353 TEfficiency* effPointer = this->bookGetPointer( effRef, tDir, stream );
354 if ( !effPointer ) {
355 m_msg << MSG::ERROR << "Couldn't book a TEfficiency" << endmsg;
356 return StatusCode::FAILURE;
357 }
358 return StatusCode::SUCCESS;
359}

◆ book() [6/8]

StatusCode AthHistogramming::book ( TEfficiency * eff,
std::string_view tDir = "",
std::string_view stream = "" )
inlineprotectedinherited

Simplify the booking and registering (into THistSvc) of TEfficiency.

Definition at line 340 of file AthHistogramming.h.

341{
342 if ( !eff ) {
343 m_msg << MSG::ERROR << "Got a zero pointer to a TEfficiency" << endmsg;
344 return StatusCode::FAILURE;
345 }
346 return this->book( *eff, tDir, stream );
347}

◆ book() [7/8]

StatusCode AthHistogramming::book ( TH1 & histRef,
std::string_view tDir = "",
std::string_view stream = "" )
inlineprotectedinherited

Simplify the booking and registering (into THistSvc) of histograms.

Definition at line 318 of file AthHistogramming.h.

319{
320 // Call the other Book method and see if it returns a valid pointer
321 TH1* histPointer = this->bookGetPointer( histRef, tDir, stream );
322 if ( !histPointer ) {
323 m_msg << MSG::ERROR << "Couldn't book a TH1" << endmsg;
324 return StatusCode::FAILURE;
325 }
326 return StatusCode::SUCCESS;
327}

◆ book() [8/8]

StatusCode AthHistogramming::book ( TH1 * hist,
std::string_view tDir = "",
std::string_view stream = "" )
inlineprotectedinherited

Simplify the booking and registering (into THistSvc) of histograms.

Definition at line 308 of file AthHistogramming.h.

309{
310 if ( !hist ) {
311 m_msg << MSG::ERROR << "Got a zero pointer to a TH1" << endmsg;
312 return StatusCode::FAILURE;
313 }
314 return this->book( *hist, tDir, stream );
315}

◆ bookGetPointer() [1/8]

TEfficiency * AthHistogramming::bookGetPointer ( const TEfficiency & eff,
std::string_view tDir = "",
std::string_view stream = "" )
inlineprotectedinherited

Simplify the booking and registering (into THistSvc) of TEfficiency.

Definition at line 275 of file AthHistogramming.h.

276{
277 // We need to create a non-const clone
278 TEfficiency* histClone = dynamic_cast< TEfficiency* >( hist.Clone() );
279 if ( !histClone ) {
280 m_msg << MSG::ERROR << "Couldn't create a TEfficiency clone in bookGetPointer" << endmsg;
281 return 0;
282 }
283 return this->bookGetPointer( *histClone, tDir, stream );
284
285}

◆ bookGetPointer() [2/8]

TGraph * AthHistogramming::bookGetPointer ( const TGraph & graphRef,
std::string_view tDir = "",
std::string_view stream = "" )
protectedinherited

Simplify the booking and registering (into THistSvc) of TGraphs.

Definition at line 374 of file AthHistogramming.cxx.

375{
376 // Get a pointer
377 const TGraph* graphPointer = &graphRef;
378
379 // Check that we got a valid pointer
380 if ( !graphPointer )
381 {
382 m_msg << MSG::WARNING
383 << "We got an invalid TGraph pointer in the BookGetPointer(TGraph*) method of the class" << m_name
384 << "!" << endmsg;
385 return NULL;
386 }
387
388 // Modify the name and title according to the prefixes of this classes instance
389 std::string graphName = graphPointer->GetName();
390 const std::string graphTitle = graphPointer->GetTitle();
391
392 // Check if the hash for this graphName already exists, i.e., if we have a hash collision
393 const hash_t graphHash = this->hash(graphName);
394 GraphMap_t::const_iterator it = m_graphMap.find( graphHash );
395 if ( it != m_graphMap.end() ) // It does exist!
396 {
397 m_msg << MSG::WARNING
398 << "Detected a hash collision. The hash for the TGraph with name=" << graphName
399 << " already exists and points to a TGraph with name=" << it->second->GetName()
400 << " NOT going to book the new histogram and returning a NULL pointer!" << endmsg;
401 return NULL;
402 }
403
404 // Create a clone that has the new name
405 TGraph* graphClone = dynamic_cast< TGraph* >( graphPointer->Clone((m_histNamePrefix+graphName+m_histNamePostfix).c_str()) );
406 if( !graphClone )
407 {
408 m_msg << MSG::WARNING
409 << "We couldn't clone the TGraph in the BookGetPointer(TGraph&) method of the class" << m_name
410 << "!" << endmsg;
411 return NULL;
412 }
413 graphClone->SetTitle ((m_histTitlePrefix+graphTitle+m_histTitlePostfix).c_str());
414
415 // Massage the final string to book things
416 std::string bookingString = buildBookingString( graphName, tDir, stream );
417
418 // Register the TGraph into the THistSvc
419 if ( !((histSvc()->regGraph(bookingString, graphClone)).isSuccess()) )
420 {
421 m_msg << MSG::WARNING
422 << "Problem registering TGraph with name " << graphName
423 << ", title " << graphTitle
424 << " in " << m_name << "!" << endmsg;
425 return NULL;
426 }
427
428 // Also register it in the local map of string to pointer
429 m_graphMap.insert( m_graphMap.end(), std::pair< const hash_t, TGraph* >( graphHash, graphClone ) );
430
431 return graphClone;
432}
AthHistogramming::histSvc
const ServiceHandle< ITHistSvc > & histSvc() const
The standard THistSvc (for writing histograms and TTrees and more to a root file) Returns (kind of) a...
Definition AthHistogramming.h:415
AthHistogramming::hash
hash_t hash(std::string_view histName) const
Method to calculate a 32-bit hash from a string.
Definition AthHistogramming.h:422
AthHistogramming::buildBookingString
std::string buildBookingString(std::string_view histName, std::string_view tDir, std::string_view stream, bool usePrefixPostfix=false) const
Method to build individual booking string.
Definition AthHistogramming.cxx:500
AthHistogramming::m_histNamePostfix
std::string m_histNamePostfix
The postfix for the histogram THx name.
Definition AthHistogramming.h:229
AthHistogramming::hash_t
uint32_t hash_t
typedef for the internal hash
Definition AthHistogramming.h:171
AthHistogramming::m_histTitlePostfix
std::string m_histTitlePostfix
The postfix for the histogram THx title.
Definition AthHistogramming.h:235
AthHistogramming::m_histTitlePrefix
std::string m_histTitlePrefix
The prefix for the histogram THx title.
Definition AthHistogramming.h:232
AthHistogramming::m_name
std::string m_name
Instance name.
Definition AthHistogramming.h:239
AthHistogramming::m_histNamePrefix
std::string m_histNamePrefix
The prefix for the histogram THx name.
Definition AthHistogramming.h:226
AthHistogramming::m_graphMap
GraphMap_t m_graphMap
The map of TGraph names to their pointers.
Definition AthHistogramming.h:216

◆ bookGetPointer() [3/8]

TH1 * AthHistogramming::bookGetPointer ( const TH1 & hist,
std::string_view tDir = "",
std::string_view stream = "" )
inlineprotectedinherited

Simplify the booking and registering (into THistSvc) of histograms.

Definition at line 254 of file AthHistogramming.h.

255{
256 // We need to create a non-const clone
257 TH1* histClone = dynamic_cast< TH1* >( hist.Clone() );
258 if ( !histClone ) {
259 m_msg << MSG::ERROR << "Couldn't create a TH1 clone in bookGetPointer" << endmsg;
260 return 0;
261 }
262 return this->bookGetPointer( *histClone, tDir, stream );
263
264}

◆ bookGetPointer() [4/8]

TTree * AthHistogramming::bookGetPointer ( const TTree & treeRef,
std::string_view tDir = "",
std::string_view stream = "" )
protectedinherited

Simplify the booking and registering (into THistSvc) of TTrees.

Definition at line 268 of file AthHistogramming.cxx.

269{
270 // Get a pointer
271 const TTree* treePointer = &treeRef;
272
273 // Check that we got a valid pointer
274 if ( !treePointer )
275 {
276 m_msg << MSG::WARNING
277 << "We got an invalid TTree pointer in the BookGetPointer(TTree*) method of the class" << m_name
278 << "!" << endmsg;
279 return NULL;
280 }
281
282 // Modify the name and title according to the prefixes of this classes instance
283 std::string treeName = treePointer->GetName();
284 const std::string treeTitle = treePointer->GetTitle();
285
286 // Check if the hash for this treeName already exists, i.e., if we have a hash collision
287 const hash_t treeHash = this->hash(treeName);
288 TreeMap_t::const_iterator it = m_treeMap.find( treeHash );
289 if ( it != m_treeMap.end() ) // It does exist!
290 {
291 m_msg << MSG::WARNING
292 << "Detected a hash collision. The hash for the TTree with name=" << treeName
293 << " already exists and points to a TTree with name=" << it->second->GetName()
294 << " NOT going to book the new histogram and returning a NULL pointer!" << endmsg;
295 return NULL;
296 }
297
298 // Create a clone that has the new name
299 TTree* treeClone = dynamic_cast< TTree* >( treePointer->Clone(treeName.c_str()) );
300 if( !treeClone )
301 {
302 m_msg << MSG::WARNING
303 << "We couldn't clone the TTree in the BookGetPointer(TTree&) method of the class" << m_name
304 << "!" << endmsg;
305 return NULL;
306 }
307 treeClone->SetTitle (treeTitle.c_str());
308
309 // Massage the final string to book things
310 std::string bookingString = buildBookingString( treeName, tDir, stream );
311
312 // Register the TTree into the THistSvc
313 if ( !((histSvc()->regTree(bookingString, treeClone)).isSuccess()) )
314 {
315 m_msg << MSG::WARNING
316 << "Problem registering TTree with name " << treeName
317 << ", title " << treeTitle
318 << " in " << m_name << "!" << endmsg;
319 return NULL;
320 }
321
322 // Also register it in the local map of string to pointer
323 m_treeMap.insert( m_treeMap.end(), std::pair< const hash_t, TTree* >( treeHash, treeClone ) );
324
325 return treeClone;
326}
AthHistogramming::m_treeMap
TreeMap_t m_treeMap
The map of TTree names to their pointers.
Definition AthHistogramming.h:209

◆ bookGetPointer() [5/8]

TEfficiency * AthHistogramming::bookGetPointer ( TEfficiency & effRef,
std::string_view tDir = "",
std::string_view stream = "" )
protectedinherited

Simplify the booking and registering (into THistSvc) of TEfficiency.

Definition at line 139 of file AthHistogramming.cxx.

140{
141 std::string originalName{effRef.GetName()};
142 const auto effName = splitName(originalName).second;
143 const std::string effTitle(effRef.GetTitle());
144 std::string bookingString = buildBookingString(originalName, tDir, stream);
145 std::string finalEffName{m_histNamePrefix};
146 finalEffName += effName;
147 finalEffName += m_histNamePostfix;
148 effRef.SetTitle((m_histTitlePrefix + effTitle + m_histTitlePostfix).c_str());
149 effRef.SetName(finalEffName.c_str());
150
151 const hash_t effHash = this->hash(effName);
152 EffMap_t::const_iterator it = m_effMap.find(effHash);
153 if (it != m_effMap.end()) {
154 m_msg << MSG::WARNING
155 << "Detected a hash collision. The hash for the TEfficiency with name=" << effName
156 << " already exists and points to a TEfficiency with name=" << it->second->GetName()
157 << " NOT going to book the new TEfficiency and returning a NULL pointer!" << endmsg;
158 return nullptr;
159 }
160
161 if (!histSvc()->regEfficiency(bookingString, &effRef).isSuccess()) {
162 m_msg << MSG::WARNING
163 << "Problem registering TEfficiency with name " << effName
164 << ", name prefix " << m_histNamePrefix
165 << ", title " << effTitle
166 << ", title prefix " << m_histTitlePrefix
167 << ", and title postfix " << m_histTitlePostfix
168 << " in " << m_name << "!" << endmsg;
169 return nullptr;
170 }
171
172 m_effMap.insert(m_effMap.end(), std::pair<const hash_t, TEfficiency*>(effHash, &effRef));
173
174 return &effRef;
175}
AthHistogramming::m_effMap
EffMap_t m_effMap
The map of histogram names to their pointers.
Definition AthHistogramming.h:202

◆ bookGetPointer() [6/8]

TEfficiency * AthHistogramming::bookGetPointer ( TEfficiency * eff,
std::string_view tDir = "",
std::string_view stream = "" )
inlineprotectedinherited

Simplify the booking and registering (into THistSvc) of TEfficiency.

Definition at line 287 of file AthHistogramming.h.

288{
289 if ( !hist ) {
290 m_msg << MSG::ERROR << "Got a zero pointer to a TEfficiency in bookGetPointer" << endmsg;
291 return 0;
292 }
293 return this->bookGetPointer( *hist, tDir, stream );
294}

◆ bookGetPointer() [7/8]

TH1 * AthHistogramming::bookGetPointer ( TH1 & histRef,
std::string_view tDir = "",
std::string_view stream = "" )
protectedinherited

Simplify the booking and registering (into THistSvc) of histograms.

Definition at line 97 of file AthHistogramming.cxx.

97 {
98
99 const std::string originalName{histRef.GetName()};
100 const auto histName = splitName(originalName).second;
101
102 const std::string histTitle(histRef.GetTitle());
103 std::string bookingString = buildBookingString(originalName, tDir, stream);
104
105 std::string finalHistName{m_histNamePrefix};
106 finalHistName += histName;
107 finalHistName += m_histNamePostfix;
108
109 histRef.SetTitle((m_histTitlePrefix + histTitle + m_histTitlePostfix).c_str());
110 histRef.SetName(finalHistName.c_str());
111
112 const hash_t histHash = this->hash(histName);
113 HistMap_t::const_iterator it = m_histMap.find(histHash);
114 if (it != m_histMap.end()) {
115 m_msg << MSG::WARNING
116 << "Detected a hash collision. The hash for the histogram with name=" << histName
117 << " already exists and points to a histogram with name=" << it->second->GetName()
118 << " NOT going to book the new histogram and returning a NULL pointer!" << endmsg;
119 return nullptr;
120 }
121
122 if (!histSvc()->regHist(bookingString, &histRef).isSuccess()) {
123 m_msg << MSG::WARNING
124 << "Problem registering histogram with name " << histName
125 << ", name prefix " << m_histNamePrefix
126 << ", title " << histTitle
127 << ", title prefix " << m_histTitlePrefix
128 << ", and title postfix " << m_histTitlePostfix
129 << " in " << m_name << "!" << endmsg;
130 return nullptr;
131 }
132
133 m_histMap.insert(m_histMap.end(), std::pair<const hash_t, TH1*>(histHash, &histRef));
134
135 return &histRef;
136}
AthHistogramming::m_histMap
HistMap_t m_histMap
The map of histogram names to their pointers.
Definition AthHistogramming.h:195

◆ bookGetPointer() [8/8]

TH1 * AthHistogramming::bookGetPointer ( TH1 * hist,
std::string_view tDir = "",
std::string_view stream = "" )
inlineprotectedinherited

Simplify the booking and registering (into THistSvc) of histograms.

Definition at line 266 of file AthHistogramming.h.

267{
268 if ( !hist ) {
269 m_msg << MSG::ERROR << "Got a zero pointer to a TH1 in bookGetPointer" << endmsg;
270 return 0;
271 }
272 return this->bookGetPointer( *hist, tDir, stream );
273}

◆ buildBookingString()

std::string AthHistogramming::buildBookingString ( std::string_view histName,
std::string_view tDir,
std::string_view stream,
bool usePrefixPostfix = false ) const
privateinherited

Method to build individual booking string.

Definition at line 500 of file AthHistogramming.cxx.

501 {
502 if (tDir.empty()) {
503 tDir = m_rootDir;
504 }
505 if (stream.empty()) {
506 stream = m_streamName;
507 }
508 const auto [histDir, baseName] = splitName(histName);
509 std::string bookingString{"/"};
510 bookingString += stream;
511 bookingString += '/';
512 bookingString += tDir;
513 if (!histDir.empty()) {
514 bookingString += '/';
515 bookingString += histDir;
516 }
517 bookingString += '/';
518 if (usePrefixPostfix) {
519 bookingString += m_histNamePrefix;
520 }
521 bookingString += baseName;
522 if (usePrefixPostfix) {
523 bookingString += m_histNamePostfix;
524 }
525 const auto tail = std::ranges::unique(
526 bookingString, [](char lhs, char rhs) { return lhs == '/' && rhs == '/'; });
527 bookingString.erase(tail.begin(), tail.end());
528 return bookingString;
529}
AthHistogramming::m_rootDir
std::string m_rootDir
Name of the ROOT directory.
Definition AthHistogramming.h:223
AthHistogramming::m_streamName
std::string m_streamName
Name of the ROOT output stream (file).
Definition AthHistogramming.h:220
tail
std::string tail(std::string s, const std::string &pattern)
tail of a string
Definition computils.cxx:461

◆ configAthHistogramming()

StatusCode AthHistogramming::configAthHistogramming ( const ServiceHandle< ITHistSvc > & histSvc,
const std::string & prefix,
const std::string & rootDir,
const std::string & histNamePrefix,
const std::string & histNamePostfix,
const std::string & histTitlePrefix,
const std::string & histTitlePostfix )
protectedinherited

To be called to fill the internal configuration.

Definition at line 64 of file AthHistogramming.cxx.

68{
69 m_histSvc = histSvc;
70 m_streamName = prefix;
71 m_rootDir = rootDir;
72 m_histNamePrefix = histNamePrefix;
73 m_histNamePostfix = histNamePostfix;
74 m_histTitlePrefix = histTitlePrefix;
75 m_histTitlePostfix = histTitlePostfix;
76
77 return StatusCode::SUCCESS;
78}
AthHistogramming::m_histSvc
ServiceHandle< ITHistSvc > m_histSvc
Pointer to the THistSvc (event store by default).
Definition AthHistogramming.h:188

◆ countOnSameSide()

unsigned int MuonValR4::MuonHoughTransformTester::countOnSameSide ( const xAOD::MuonSegment & truthSeg,
const xAOD::MuonSegment & recoSeg ) const
private

Calculates how many measurements from the segment fit have the same drift sign as when evaluated with the truth parameters.

Parameters
truthSegReference to the truth segment
recoSegReference to the reco segment.

Definition at line 109 of file MuonHoughTransformTester.cxx.

110 {
111 unsigned int same{0};
112 using namespace SegmentFit;
113 const MuonR4::Segment* detailSeg = detailedSegment(recoSeg);
114 const auto[truePos, trueDir] = makeLine(localSegmentPars(truthSeg));
115 const auto[recoPos, recoDir] = makeLine(localSegmentPars(recoSeg));
116 const std::vector<int> truthSigns = SeedingAux::strawSigns(truePos, trueDir, detailSeg->measurements());
117 const std::vector<int> recoSigns = SeedingAux::strawSigns(recoPos, recoDir, detailSeg->measurements());
118 for (unsigned int s = 0 ; s < truthSigns.size(); ++s) {
119 same += (truthSigns[s] != 0) && truthSigns[s] == recoSigns[s];
120 }
121 return same;
122 }
MuonR4::Segment::measurements
const MeasVec & measurements() const
Returns the associated measurements.
Definition MuonSpectrometer/MuonPhaseII/Event/MuonPatternEvent/MuonPatternEvent/Segment.h:50
MuonR4::SegmentFit::localSegmentPars
Parameters localSegmentPars(const xAOD::MuonSegment &seg)
Returns the localSegPars decoration from a xAODMuon::Segment.
Definition SegmentFitterEventData.cxx:76
MuonR4::SegmentFit::makeLine
std::pair< Amg::Vector3D, Amg::Vector3D > makeLine(const Parameters &pars)
Returns the parsed parameters into an Eigen line parametrization.
Definition SegmentFitterEventData.cxx:69
MuonR4::detailedSegment
const Segment * detailedSegment(const xAOD::MuonSegment &seg)
Helper function to navigate from the xAOD::MuonSegment to the MuonR4::Segment.
Definition TrackingHelpers.cxx:45

◆ declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareGaudiProperty ( Gaudi::Property< T, V, H > & hndl,
const SG::VarHandleKeyType &  )
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

158 {
159 return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
160 hndl.value(),
161 hndl.documentation());
162
163 }

◆ declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty ( Gaudi::Property< T, V, H > & t)
inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

145 {
146 typedef typename SG::HandleClassifier<T>::type htype;
147 return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
148 }
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition AthCommonDataStore.h:156

◆ detStore()

const ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::detStore ( ) const
inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

95{ return m_detStore; }

◆ efficiency()

TEfficiency * AthHistogramming::efficiency ( std::string_view effName,
std::string_view tDir = "",
std::string_view stream = "" )
protectedinherited

Simplify the retrieval of registered TEfficiency.

Definition at line 214 of file AthHistogramming.cxx.

215{
216 // Build a 32 bit hash out of the name
217 const hash_t effHash = this->hash(effName);
218
219 // See if this entry exists in the map
220 EffMap_t::const_iterator it = m_effMap.find( effHash );
221 if ( it == m_effMap.end() ) // It doesn't exist!
222 { // Let's see into the THistSvc if somebody else has registered the TEfficiency...
223 // Massage the final string to book things
224 std::string bookingString = buildBookingString(effName, tDir, stream ,false);
225
226 TEfficiency* effPointer{};
227 if ( !((histSvc()->getEfficiency(bookingString, effPointer)).isSuccess()) )
228 {
229 // Book things
230 std::string bookingString = buildBookingString( effName, tDir, stream, true );
231
232 if ( !((histSvc()->getEfficiency(bookingString, effPointer)).isSuccess()) )
233 {
234 m_msg << MSG::WARNING
235 << "Problem retrieving the TEfficiency with name (including pre- and post-fixes) "
236 << bookingString
237 << " or with name " << effName
238 << " in " << m_name << "... it doesn't exist, neither in the cached map nor in the THistSvc!"
239 << " Will return an NULL pointer... you have to handle it correctly!" << endmsg;
240 return NULL;
241 }
242 // If we get to here, we actually found the TEfficiency in the THistSvc.
243 // So let's add it to the local cache map and return its pointer
244 m_effMap.insert( m_effMap.end(), std::pair< const hash_t, TEfficiency* >( effHash, effPointer ) );
245 return effPointer;
246 }
247 // If we get to here, we actually found the TEfficiency in the THistSvc.
248 // So let's add it to the local cache map and return its pointer
249 m_effMap.insert( m_effMap.end(), std::pair< const hash_t, TEfficiency* >( effHash, effPointer ) );
250 return effPointer;
251 }
252
253 // Return the pointer to the TEfficiency that we got from the local cache map
254 return it->second;
255}
AthenaInternal::getEfficiency
std::pair< StatusCode, TEfficiency * > getEfficiency(ITHistSvc &svc, const std::string &name)
Definition AthenaPythonDict.h:59

◆ evtStore()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::evtStore ( )
inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

85{ return m_evtStore; }

◆ execute()

StatusCode MuonValR4::MuonHoughTransformTester::execute ( const EventContext & ctx)
overridevirtual

Execute method.

Implements AthAlgorithm.

Definition at line 245 of file MuonHoughTransformTester.cxx.

245 {
246
247 const ActsTrk::GeometryContext* gctxPtr{nullptr};
248 ATH_CHECK(SG::get(gctxPtr, m_geoCtxKey, ctx));
249 const ActsTrk::GeometryContext& gctx{*gctxPtr};
250
251 ConstDataVector<MuonR4::SegmentSeedContainer> segmentSeeds{SG::VIEW_ELEMENTS};
252 for (const SG::ReadHandleKey<SegmentSeedContainer>& key : m_patternSeedKeys) {
253 const SegmentSeedContainer* readSegmentSeeds{nullptr};
254 ATH_CHECK(SG::get(readSegmentSeeds, key, ctx));
255 segmentSeeds.insert(segmentSeeds.end(), readSegmentSeeds->begin(), readSegmentSeeds->end());
256 }
257
258 const xAOD::MuonSegmentContainer* truthSegments{nullptr};
259 ATH_CHECK(SG::get(truthSegments, m_truthSegmentKey, ctx));
260
261 const xAOD::MuonSegmentContainer* recoSegments{nullptr};
262 ATH_CHECK(SG::get(recoSegments, m_recoSegKey, ctx));
263
264 ATH_MSG_DEBUG("Succesfully retrieved input collections. Seeds: "<<segmentSeeds.size()
265 <<", segments: "<<recoSegments->size()
266 <<", truth segments: "<<(truthSegments? truthSegments->size() : -1)
267 <<".");
268 std::vector<ObjectMatching> objects = matchWithTruth(*segmentSeeds.asDataVector(),
269 *recoSegments, truthSegments);
270 for (const ObjectMatching& obj : objects) {
271 fillChamberInfo(obj.chamber);
272 fillSeedInfo(obj);
273 fillSegmentInfo(obj);
274 if(m_isMC) fillTruthInfo(gctx, obj.truthSegment);
275 ATH_CHECK(m_tree.fill(ctx));
276 }
277 return StatusCode::SUCCESS;
278 }
ATH_CHECK
#define ATH_CHECK
Evaluate an expression and check for errors.
Definition AthCheckMacros.h:40
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x,...)
Definition AthMsgStreamMacros.h:43
ConstDataVector::end
iterator end() noexcept
Return an iterator pointing past the end of the collection.
ConstDataVector::insert
iterator insert(iterator position, value_type pElem)
Add a new element to the collection.
ConstDataVector::asDataVector
const DV * asDataVector() const
Return a pointer to this object, as a const DataVector.
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
MuonValR4::MuonHoughTransformTester::fillTruthInfo
void fillTruthInfo(const ActsTrk::GeometryContext &gctx, const xAOD::MuonSegment *truthSegment)
Fill the associated truth information into the tree.
Definition MuonHoughTransformTester.cxx:284
MuonValR4::MuonHoughTransformTester::matchWithTruth
std::vector< ObjectMatching > matchWithTruth(const MuonR4::SegmentSeedContainer &seedContainer, const xAOD::MuonSegmentContainer &segmentContainer, const xAOD::MuonSegmentContainer *truthSegments) const
Definition MuonHoughTransformTester.cxx:124
MuonValR4::MuonHoughTransformTester::m_recoSegKey
SG::ReadHandleKey< xAOD::MuonSegmentContainer > m_recoSegKey
Key to the xAOD::MuonSegment container.
Definition MuonHoughTransformTester.h:104
MuonValR4::MuonHoughTransformTester::m_patternSeedKeys
SG::ReadHandleKeyArray< MuonR4::SegmentSeedContainer > m_patternSeedKeys
List of the two segment seed containers from which the segments are buiit (Complets the pattern findi...
Definition MuonHoughTransformTester.h:108
MuonValR4::MuonHoughTransformTester::fillSegmentInfo
void fillSegmentInfo(const ObjectMatching &obj)
Fill the info assciated to the segment.
Definition MuonHoughTransformTester.cxx:557
MuonValR4::MuonHoughTransformTester::fillChamberInfo
void fillChamberInfo(const MuonGMR4::SpectrometerSector *chamber)
Fill the current chamber info into the output.
Definition MuonHoughTransformTester.cxx:279
MuonValR4::MuonHoughTransformTester::m_truthSegmentKey
SG::ReadHandleKey< xAOD::MuonSegmentContainer > m_truthSegmentKey
Key to the truth segment.
Definition MuonHoughTransformTester.h:98
MuonValR4::MuonHoughTransformTester::m_geoCtxKey
ActsTrk::GeoContextReadKey_t m_geoCtxKey
Tracking geometry context.
Definition MuonHoughTransformTester.h:112
MuonValR4::MuonHoughTransformTester::fillSeedInfo
void fillSeedInfo(const ObjectMatching &obj)
Fill the info associated to the seed.
Definition MuonHoughTransformTester.cxx:426
MuonR4::SegmentSeedContainer
DataVector< SegmentSeed > SegmentSeedContainer
Definition MuonPatternContainer.h:15
SG::VIEW_ELEMENTS
@ VIEW_ELEMENTS
this data object is a view, it does not own its elmts
Definition OwnershipPolicy.h:18
SG::get
const T * get(const ReadCondHandleKey< T > &key, const EventContext &ctx)
Convenience function to retrieve an object given a ReadCondHandleKey.
Definition ReadCondHandle.h:281
xAOD::MuonSegmentContainer
MuonSegmentContainer_v1 MuonSegmentContainer
Definition of the current "MuonSegment container version".
Definition MuonSegmentContainer.h:14

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase & ExtraDeps)
protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

◆ extraOutputDeps()

const DataObjIDColl & AthCommonAlgorithm< Gaudi::Algorithm >::extraOutputDeps ( ) const
overridevirtualinherited

Return the list of extra output dependencies.

This list is extended to include symlinks implied by inheritance relations.

Definition at line 89 of file AthCommonAlgorithm.cxx.

54{
55 // If we didn't find any symlinks to add, just return the collection
56 // from the base class. Otherwise, return the extended collection.
57 if (!m_extendedExtraObjects.empty()) {
58 return m_extendedExtraObjects;
59 }
60 return BaseAlg::extraOutputDeps();
61}
AthCommonAlgorithm
Common base class for algorithms.
Definition AthCommonAlgorithm.h:38

◆ fillBucketInfo()

void MuonValR4::MuonHoughTransformTester::fillBucketInfo ( const MuonR4::SpacePointBucket & bucket)
private

Fill the hit summary info of the associated bucket.

Definition at line 376 of file MuonHoughTransformTester.cxx.

376 {
377 m_out_bucketEnd = bucket.coveredMax();
378 m_out_bucketStart = bucket.coveredMin();
379 m_out_nSpacePoints = bucket.size();
380
381 ATH_MSG_DEBUG("Filling bucket with "<<bucket.size()<<" space points between "<< bucket.coveredMin() <<" and "<< bucket.coveredMax() );
382
383 // Because the space points are first ordered by layers and then local y within the layer we need to resort them to compute the max gap in y between consecutive hits in the bucket
384 std::vector<const MuonR4::SpacePoint*> etaHits{};
385 etaHits.reserve(bucket.size());
386 for (const auto& sp : bucket) {
387 if (sp->measuresEta()) {
388 etaHits.push_back(sp.get());
389 }
390 }
391 std::ranges::sort(etaHits, [](const MuonR4::SpacePoint* a,
392 const MuonR4::SpacePoint* b) {
393 return a->localPosition().y() < b->localPosition().y();
394 });
395
396
397 double maxEtaHitGap{-1.f};
398 for (std::size_t i = 1; i < etaHits.size(); ++i) {
399 maxEtaHitGap = std::max(maxEtaHitGap,
400 std::abs(etaHits[i]->localPosition().y()
401 - etaHits[i - 1]->localPosition().y()));
402 }
403
404 m_out_bucketEtaHitGap = maxEtaHitGap;
405
406
407 m_out_nPrecSpacePoints = std::ranges::count_if(bucket, [](const SpacePointBucket::value_type& sp){
408 return isPrecision(*sp);
409 });
410 m_out_nPhiSpacePoints = std::ranges::count_if(bucket, [](const SpacePointBucket::value_type& sp){
411 return sp->measuresPhi();
412 });
413 if (!m_visionTool.isEnabled()){
414 return;
415 }
416 m_out_nTrueSpacePoints = std::ranges::count_if(bucket,[this](const SpacePointBucket::value_type& sp){
417 return m_visionTool->isLabeled(*sp);
418 });
419 m_out_nTruePrecSpacePoints = std::ranges::count_if(bucket,[this](const SpacePointBucket::value_type& sp){
420 return isPrecision(*sp) && m_visionTool->isLabeled(*sp);
421 });
422 m_out_nTruePhiSpacePoints = std::ranges::count_if(bucket,[this](const SpacePointBucket::value_type& sp){
423 return sp->measuresPhi() && m_visionTool->isLabeled(*sp);
424 });
425 }
sp
static Double_t sp
Definition LArPhysWaveHECTool.cxx:37
a
static Double_t a
Definition LArPhysWaveHECTool.cxx:38
y
#define y
MuonValR4::MuonHoughTransformTester::m_out_nTruePhiSpacePoints
MuonVal::ScalarBranch< unsigned char > & m_out_nTruePhiSpacePoints
Number of phi hits in the bucket.
Definition MuonHoughTransformTester.h:154
MuonValR4::MuonHoughTransformTester::m_visionTool
ToolHandle< MuonValR4::IPatternVisualizationTool > m_visionTool
Pattern visualization tool.
Definition MuonHoughTransformTester.h:314
MuonValR4::MuonHoughTransformTester::m_out_bucketEtaHitGap
MuonVal::ScalarBranch< float > & m_out_bucketEtaHitGap
Definition MuonHoughTransformTester.h:133
MuonValR4::MuonHoughTransformTester::m_out_nPhiSpacePoints
MuonVal::ScalarBranch< unsigned char > & m_out_nPhiSpacePoints
Number of phi hits in the bucket.
Definition MuonHoughTransformTester.h:147
MuonValR4::MuonHoughTransformTester::m_out_bucketEnd
MuonVal::ScalarBranch< float > & m_out_bucketEnd
Definition MuonHoughTransformTester.h:132
MuonValR4::MuonHoughTransformTester::m_out_nTrueSpacePoints
MuonVal::ScalarBranch< unsigned char > & m_out_nTrueSpacePoints
Number of all space points in the bucket.
Definition MuonHoughTransformTester.h:150
MuonValR4::MuonHoughTransformTester::m_out_nPrecSpacePoints
MuonVal::ScalarBranch< unsigned char > & m_out_nPrecSpacePoints
Number of precision hits in the bucket.
Definition MuonHoughTransformTester.h:145
MuonValR4::MuonHoughTransformTester::m_out_nTruePrecSpacePoints
MuonVal::ScalarBranch< unsigned char > & m_out_nTruePrecSpacePoints
Number of precision hits in the bucket.
Definition MuonHoughTransformTester.h:152
MuonValR4::MuonHoughTransformTester::m_out_nSpacePoints
MuonVal::ScalarBranch< unsigned char > & m_out_nSpacePoints
Number of all space points in the bucket.
Definition MuonHoughTransformTester.h:143
MuonValR4::MuonHoughTransformTester::m_out_bucketStart
MuonVal::ScalarBranch< float > & m_out_bucketStart
Definition MuonHoughTransformTester.h:131

◆ fillChamberInfo()

void MuonValR4::MuonHoughTransformTester::fillChamberInfo ( const MuonGMR4::SpectrometerSector * chamber)
private

Fill the current chamber info into the output.

Parameters
chamberPointer to the reference sector to which the view belongs to

Definition at line 279 of file MuonHoughTransformTester.cxx.

279 {
280 m_out_chamberIndex = Acts::toUnderlying(msSector->chamberIndex());
281 m_out_stationSide = msSector->side();
282 m_out_stationPhi = msSector->stationPhi();
283 }
MuonValR4::MuonHoughTransformTester::m_out_stationPhi
MuonVal::ScalarBranch< int > & m_out_stationPhi
phi index of the station
Definition MuonHoughTransformTester.h:129
MuonValR4::MuonHoughTransformTester::m_out_chamberIndex
MuonVal::ScalarBranch< int > & m_out_chamberIndex
====== Common block: Filled for all entries ===========
Definition MuonHoughTransformTester.h:125
MuonValR4::MuonHoughTransformTester::m_out_stationSide
MuonVal::ScalarBranch< short > & m_out_stationSide
+1 for A-, -1 of C-side
Definition MuonHoughTransformTester.h:127

◆ fillRecoSummary()

void MuonValR4::MuonHoughTransformTester::fillRecoSummary ( const xAOD::MuonSegment & recoSegment)
private

◆ fillSeedInfo()

void MuonValR4::MuonHoughTransformTester::fillSeedInfo ( const ObjectMatching & obj)
private

Fill the info associated to the seed.

Parameters
objPointer to the matching object connecting the seeds & segment & truth

Helper lambda to shorten a bit the syntax to count the hits of a certain kind

True hit count

Definition at line 426 of file MuonHoughTransformTester.cxx.

426 {
427
428 m_out_seed_n = obj.matchedSeeds.size();
429 for (const auto [iseed, seed] : Acts::enumerate(obj.matchedSeeds)){
430 if (iseed ==0) {
431 fillBucketInfo(*seed->parentBucket());
432 }
433 double minYhit = m_out_bucketEnd.getVariable();
434 double maxYhit = m_out_bucketStart.getVariable();
435 for (const SpacePoint* hit : seed->getHitsInMax()){
436 minYhit = std::min(hit->localPosition().y(),minYhit);
437 maxYhit = std::max(hit->localPosition().y(),maxYhit);
438 }
439 m_out_seed_minYhit.push_back(minYhit);
440 m_out_seed_maxYhit.push_back(maxYhit);
441
442 m_out_seed_hasPhiExtension.push_back(seed->hasPhiExtension());
443 m_out_seed_y0.push_back(seed->interceptY());
444 m_out_seed_tanbeta.push_back(seed->tanBeta());
445 if (seed->hasPhiExtension()){
446 m_out_seed_x0.push_back(seed->interceptX());
447 m_out_seed_tanalpha.push_back(seed->tanAlpha());
448 } else{
449 m_out_seed_x0.push_back(-999);
450 m_out_seed_tanalpha.push_back(-999);
451 }
452 m_out_seed_ledToSegment.push_back(obj.matchedSeedFoundSegment.at(iseed));
453
454
457 auto hitCounter = [seed](auto lambda) {
458 return std::count_if(seed->getHitsInMax().begin(),
459 seed->getHitsInMax().end(), lambda);
460 };
461
462 m_out_seed_nPrecHits += hitCounter([](const SpacePoint* sp) {
463 return isPrecision(*sp);
464 });
465 m_out_seed_nEtaHits += hitCounter([](const SpacePoint* sp) {
466 return !isPrecision(*sp) && sp->measuresEta();
467 });
468 m_out_seed_nPhiHits += hitCounter([](const SpacePoint* sp) {
469 return sp->measuresPhi();
470 });
471
472 m_out_seed_nTruePrecHits += hitCounter([this](const SpacePoint* sp) {
473 return isPrecision(*sp) &&
474 (!m_visionTool.isEnabled() || m_visionTool->isLabeled(*sp));
475 });
476 m_out_seed_nTrueEtaHits += hitCounter([this](const SpacePoint* sp) {
477 return !isPrecision(*sp) && sp->measuresEta() &&
478 (!m_visionTool.isEnabled() || m_visionTool->isLabeled(*sp));
479 });
480 m_out_seed_nTruePhiHits += hitCounter([this](const SpacePoint* sp) {
481 return sp->measuresPhi() &&
482 (!m_visionTool.isEnabled() || m_visionTool->isLabeled(*sp));
483 });
484
485 /***
486 * Split hit counts for the NSW!
487 */
488 m_out_seed_nMmEtaHits += hitCounter([this](const SpacePoint* sp){
489 return sp->type() == xAOD::UncalibMeasType::MMClusterType &&
490 !m_idHelperSvc->mmIdHelper().isStereo(sp->identify());
491 });
492 m_out_seed_nMmStereoHits += hitCounter([this](const SpacePoint* sp){
493 return sp->type() == xAOD::UncalibMeasType::MMClusterType &&
494 m_idHelperSvc->mmIdHelper().isStereo(sp->identify());
495 });
496
497 m_out_seed_nsTgcStripHits+=hitCounter([](const SpacePoint* sp){
498 return sp->type() == xAOD::UncalibMeasType::sTgcStripType &&
499 isPrecision(*sp);
500 });
501 m_out_seed_nsTgcWireHits+=hitCounter([this](const SpacePoint* sp) {
502 return sp->type() == xAOD::UncalibMeasType::sTgcStripType &&
503 sp->measuresPhi() &&
504 m_idHelperSvc->stgcIdHelper().channelType(sp->identify()) !=
505 sTgcIdHelper::sTgcChannelTypes::Pad;
506 });
507 m_out_seed_nsTgcPadHits.push_back(hitCounter([this](const SpacePoint* sp){
508 return sp->type() == xAOD::UncalibMeasType::sTgcStripType &&
509 m_idHelperSvc->stgcIdHelper().channelType(sp->identify()) ==
510 sTgcIdHelper::sTgcChannelTypes::Pad;
511 }));
512
514 m_out_seed_nTrueMmEtaHits += hitCounter([this](const SpacePoint* sp){
515 return sp->type() == xAOD::UncalibMeasType::MMClusterType &&
516 (!m_visionTool.isEnabled() || m_visionTool->isLabeled(*sp)) &&
517 !m_idHelperSvc->mmIdHelper().isStereo(sp->identify());
518 });
519 m_out_seed_nTrueMmStereoHits += hitCounter([this](const SpacePoint* sp){
520 return sp->type() == xAOD::UncalibMeasType::MMClusterType &&
521 (!m_visionTool.isEnabled() || m_visionTool->isLabeled(*sp)) &&
522 m_idHelperSvc->mmIdHelper().isStereo(sp->identify());
523 });
524
525 m_out_seed_nTruesTgcStripHits+=hitCounter([this](const SpacePoint* sp){
526 return sp->type() == xAOD::UncalibMeasType::sTgcStripType &&
527 (!m_visionTool.isEnabled() || m_visionTool->isLabeled(*sp)) &&
528 isPrecision(*sp);
529 });
530 m_out_seed_nTruesTgcWireHits+=hitCounter([this](const SpacePoint* sp) {
531 return sp->type() == xAOD::UncalibMeasType::sTgcStripType &&
532 (!m_visionTool.isEnabled() || m_visionTool->isLabeled(*sp)) &&
533 sp->measuresPhi() &&
534 m_idHelperSvc->stgcIdHelper().channelType(sp->identify()) !=
535 sTgcIdHelper::sTgcChannelTypes::Pad;
536 });
537 m_out_seed_nTruesTgcPadHits.push_back(hitCounter([this](const SpacePoint* sp){
538 return sp->type() == xAOD::UncalibMeasType::sTgcStripType &&
539 (!m_visionTool.isEnabled() || m_visionTool->isLabeled(*sp)) &&
540 m_idHelperSvc->stgcIdHelper().channelType(sp->identify()) ==
541 sTgcIdHelper::sTgcChannelTypes::Pad;
542 }));
543
544 if (m_writeSpacePoints) {
545 std::vector<unsigned char> treeIdxs{};
546 for (const HoughHitType & houghSP: seed->getHitsInMax()){
547 if (m_writeSpacePoints){
548 unsigned treeIdx = m_spTester->push_back(*houghSP);
549 treeIdxs.push_back(treeIdx);
550 }
551 }
552 m_spMatchedToPattern[iseed] = std::move(treeIdxs);
553 }
554 }
555 }
hit
bool hit(const Container &ids, int pdgId)
Definition JetIRCSafeLabelTool.cxx:64
MuonValR4::MuonHoughTransformTester::m_out_seed_maxYhit
MuonVal::VectorBranch< float > & m_out_seed_maxYhit
Definition MuonHoughTransformTester.h:213
MuonValR4::MuonHoughTransformTester::m_out_seed_ledToSegment
MuonVal::VectorBranch< unsigned char > & m_out_seed_ledToSegment
Definition MuonHoughTransformTester.h:237
MuonValR4::MuonHoughTransformTester::m_out_seed_nTrueEtaHits
MuonVal::VectorBranch< unsigned short > & m_out_seed_nTrueEtaHits
Definition MuonHoughTransformTester.h:220
MuonValR4::MuonHoughTransformTester::m_idHelperSvc
ServiceHandle< Muon::IMuonIdHelperSvc > m_idHelperSvc
Definition MuonHoughTransformTester.h:114
MuonValR4::MuonHoughTransformTester::m_out_seed_nTrueMmStereoHits
MuonVal::VectorBranch< unsigned short > & m_out_seed_nTrueMmStereoHits
Definition MuonHoughTransformTester.h:227
MuonValR4::MuonHoughTransformTester::m_out_seed_nMmEtaHits
MuonVal::VectorBranch< unsigned short > & m_out_seed_nMmEtaHits
Definition MuonHoughTransformTester.h:223
MuonValR4::MuonHoughTransformTester::m_out_seed_x0
MuonVal::VectorBranch< float > & m_out_seed_x0
Definition MuonHoughTransformTester.h:207
MuonValR4::MuonHoughTransformTester::m_out_seed_nTruePrecHits
MuonVal::VectorBranch< unsigned short > & m_out_seed_nTruePrecHits
Definition MuonHoughTransformTester.h:219
MuonValR4::MuonHoughTransformTester::m_out_seed_y0
MuonVal::VectorBranch< float > & m_out_seed_y0
Definition MuonHoughTransformTester.h:206
MuonValR4::MuonHoughTransformTester::m_out_seed_hasPhiExtension
MuonVal::VectorBranch< unsigned short > & m_out_seed_hasPhiExtension
Definition MuonHoughTransformTester.h:204
MuonValR4::MuonHoughTransformTester::m_spMatchedToPattern
MuonVal::MatrixBranch< unsigned char > & m_spMatchedToPattern
Branch indicating which space points in the tree are associated to the i-th pattern.
Definition MuonHoughTransformTester.h:138
MuonValR4::MuonHoughTransformTester::m_out_seed_nsTgcStripHits
MuonVal::VectorBranch< unsigned short > & m_out_seed_nsTgcStripHits
Definition MuonHoughTransformTester.h:229
MuonValR4::MuonHoughTransformTester::m_out_seed_nEtaHits
MuonVal::VectorBranch< unsigned short > & m_out_seed_nEtaHits
Definition MuonHoughTransformTester.h:216
MuonValR4::MuonHoughTransformTester::fillBucketInfo
void fillBucketInfo(const MuonR4::SpacePointBucket &bucket)
Fill the hit summary info of the associated bucket.
Definition MuonHoughTransformTester.cxx:376
MuonValR4::MuonHoughTransformTester::m_out_seed_nTruesTgcPadHits
MuonVal::VectorBranch< unsigned short > & m_out_seed_nTruesTgcPadHits
Definition MuonHoughTransformTester.h:235
MuonValR4::MuonHoughTransformTester::m_out_seed_n
MuonVal::ScalarBranch< unsigned > & m_out_seed_n
========== Seed block: Filled when we have one or multiple seeds ============= seed count
Definition MuonHoughTransformTester.h:200
MuonValR4::MuonHoughTransformTester::m_out_seed_nTruePhiHits
MuonVal::VectorBranch< unsigned short > & m_out_seed_nTruePhiHits
Definition MuonHoughTransformTester.h:221
MuonValR4::MuonHoughTransformTester::m_out_seed_nMmStereoHits
MuonVal::VectorBranch< unsigned short > & m_out_seed_nMmStereoHits
Definition MuonHoughTransformTester.h:224
MuonValR4::MuonHoughTransformTester::m_out_seed_nsTgcWireHits
MuonVal::VectorBranch< unsigned short > & m_out_seed_nsTgcWireHits
Definition MuonHoughTransformTester.h:230
MuonValR4::MuonHoughTransformTester::m_out_seed_minYhit
MuonVal::VectorBranch< float > & m_out_seed_minYhit
Definition MuonHoughTransformTester.h:212
MuonValR4::MuonHoughTransformTester::m_out_seed_nTrueMmEtaHits
MuonVal::VectorBranch< unsigned short > & m_out_seed_nTrueMmEtaHits
Definition MuonHoughTransformTester.h:226
MuonValR4::MuonHoughTransformTester::m_out_seed_tanbeta
MuonVal::VectorBranch< float > & m_out_seed_tanbeta
Definition MuonHoughTransformTester.h:208
MuonValR4::MuonHoughTransformTester::m_out_seed_nPrecHits
MuonVal::VectorBranch< unsigned short > & m_out_seed_nPrecHits
Definition MuonHoughTransformTester.h:215
MuonValR4::MuonHoughTransformTester::m_out_seed_tanalpha
MuonVal::VectorBranch< float > & m_out_seed_tanalpha
Definition MuonHoughTransformTester.h:209
MuonValR4::MuonHoughTransformTester::m_out_seed_nsTgcPadHits
MuonVal::VectorBranch< unsigned short > & m_out_seed_nsTgcPadHits
Definition MuonHoughTransformTester.h:231
MuonValR4::MuonHoughTransformTester::m_out_seed_nPhiHits
MuonVal::VectorBranch< unsigned short > & m_out_seed_nPhiHits
Definition MuonHoughTransformTester.h:217
MuonValR4::MuonHoughTransformTester::m_out_seed_nTruesTgcWireHits
MuonVal::VectorBranch< unsigned short > & m_out_seed_nTruesTgcWireHits
Definition MuonHoughTransformTester.h:234
MuonValR4::MuonHoughTransformTester::m_spTester
std::shared_ptr< SpacePointTesterModule > m_spTester
Branch dumping all the space points from the difference buckets.
Definition MuonHoughTransformTester.h:136
MuonValR4::MuonHoughTransformTester::m_out_seed_nTruesTgcStripHits
MuonVal::VectorBranch< unsigned short > & m_out_seed_nTruesTgcStripHits
Definition MuonHoughTransformTester.h:233
Generate_dsid_ranseed.seed
seed
Definition Generate_dsid_ranseed.py:10
MuonR4::HoughHitType
const SpacePoint * HoughHitType
Definition MuonHoughDefs.h:24

◆ fillSegmentInfo()

void MuonValR4::MuonHoughTransformTester::fillSegmentInfo ( const ObjectMatching & obj)
private

Fill the info assciated to the segment.

Parameters
objPointer to the matching object connecting the seeds & segment & truth

Parameters and covariance

Fit quality

Helper lambda to shorten a bit the syntax to count the hits of a certain kind

True matched precision hit

True matched trigger eta hit

True matched trigger phi hit

True matched precision outlier

True matched trigger eta outlier

True matched trigger phi outlier

True NSW hit counts

Definition at line 557 of file MuonHoughTransformTester.cxx.

557 {
558 using namespace SegmentFit;
559
560 m_out_segment_n = obj.matchedSegments.size();
561 for (const xAOD::MuonSegment* segment : obj.matchedSegments) {
562
564 const auto pars = localSegmentPars(*segment);
565 const auto cov = localSegmentCov(*segment);
566
567 m_out_segment_theta.push_back(pars[Acts::toUnderlying(ParamDefs::theta)]);
568 m_out_segment_phi.push_back(pars[Acts::toUnderlying(ParamDefs::phi)]);
569 m_out_segment_y0.push_back(pars[Acts::toUnderlying(ParamDefs::y0)]);
570 m_out_segment_x0.push_back(pars[Acts::toUnderlying(ParamDefs::x0)]);
571 m_out_segment_time.push_back(pars[Acts::toUnderlying(ParamDefs::t0)] +
572 segment->position().mag() * c_inv);
573
574 for (std::size_t i =0; i < Acts::toUnderlying(ParamDefs::nPars); ++i) {
575 for (std::size_t j = 0; j <=i; ++j) {
576 const std::size_t vecIdx = Acts::vecIdxFromSymMat<Acts::toUnderlying(ParamDefs::nPars)>(i,j);
577 m_segmentCov[vecIdx]->push_back((*cov)(i,j));
578 }
579 }
580
582 const MuonR4::Segment* detailSeg = detailedSegment(*segment);
583 m_out_segment_fitIter.push_back(detailSeg->nFitIterations());
584 m_out_segment_chi2.push_back(segment->chiSquared());
585 m_out_segment_nDoF.push_back(segment->numberDoF());
586 m_out_segment_hasTimeFit.push_back(detailSeg->hasTimeFit());
589 auto hitCounter = [detailSeg](auto lambda) {
590 return std::count_if(detailSeg->measurements().begin(),
591 detailSeg->measurements().end(), lambda);
592 };
593
594 m_out_segment_nPrecHits += segment->nPrecisionHits();
595 m_out_segment_nTrigEtaHits += segment->nTrigEtaLayers();
596 m_out_segment_nTrigPhiHits += segment->nPhiLayers();
597
598 m_out_segment_nPrecOutliers += segment->nPrecisionOutliers();
599 m_out_segment_nTrigEtaOutliers += segment->nTriggerEtaOutliers();
600 m_out_segment_nTrigPhiOutliers += segment->nTriggerPhiOutliers();
601
602 m_out_segment_nPrecHoles += segment->nPrecisionHoles();
603 m_out_segment_nTrigEtaHoles += segment->nTriggerEtaHoles();
604 m_out_segment_nTrigPhiHoles += segment->nTriggerPhiHoles();
606 m_out_segment_nTruePrecHits += hitCounter([this](const auto& meas) {
607 return meas->fitState() == CalibratedSpacePoint::State::Valid &&
608 isPrecision(*meas) && (!m_visionTool.isEnabled() ||
609 m_visionTool->isLabeled(*meas->spacePoint()));
610 });
612 m_out_segment_nTrueTrigEtaHits += hitCounter([this](const auto& meas) {
613 return meas->fitState() == CalibratedSpacePoint::State::Valid &&
614 !isPrecision(*meas) && meas->measuresEta() &&
615 meas->spacePoint() &&
616 (!m_visionTool.isEnabled() || m_visionTool->isLabeled(*meas->spacePoint()));
617 });
619 m_out_segment_nTrueTrigPhiHits += hitCounter([this](const auto& meas) {
620 return meas->fitState() == CalibratedSpacePoint::State::Valid &&
621 !isPrecision(*meas) && meas->measuresPhi() &&
622 meas->spacePoint() &&
623 (!m_visionTool.isEnabled() || m_visionTool->isLabeled(*meas->spacePoint()));
624 });
626 m_out_segment_nTruePrecOutliers += hitCounter([this](const auto& meas) {
627 return meas->fitState() != CalibratedSpacePoint::State::Valid &&
628 isPrecision(*meas) && (!m_visionTool.isEnabled() ||
629 m_visionTool->isLabeled(*meas->spacePoint()));
630 });
632 m_out_segment_nTrueTrigEtaOutliers += hitCounter([this](const auto& meas) {
633 return meas->fitState() != CalibratedSpacePoint::State::Valid &&
634 !isPrecision(*meas) && meas->measuresEta() &&
635 meas->spacePoint() &&
636 (!m_visionTool.isEnabled() || m_visionTool->isLabeled(*meas->spacePoint()));
637 });
639 m_out_segment_nTrueTrigPhiOutliers += hitCounter([this](const auto& meas) {
640 return meas->fitState() != CalibratedSpacePoint::State::Valid &&
641 !isPrecision(*meas) && meas->measuresPhi() &&
642 meas->spacePoint() &&
643 (!m_visionTool.isEnabled() || m_visionTool->isLabeled(*meas->spacePoint()));
644 });
645
646 /***
647 * Split hit counts for the NSW!
648 */
649 m_out_segment_nMmEtaHits.push_back(hitCounter([this](const auto& meas){
650 return meas->fitState() == CalibratedSpacePoint::State::Valid &&
651 meas->type() == xAOD::UncalibMeasType::MMClusterType &&
652 !m_idHelperSvc->mmIdHelper().isStereo(meas->spacePoint()->identify());
653 }));
654 m_out_segment_nMmStereoHits.push_back(hitCounter([this](const auto& meas){
655 return meas->fitState() == CalibratedSpacePoint::State::Valid &&
656 meas->type() == xAOD::UncalibMeasType::MMClusterType &&
657 m_idHelperSvc->mmIdHelper().isStereo(meas->spacePoint()->identify());
658 }));
659 m_out_segment_nMmEtaOutliers.push_back(hitCounter([this](const auto& meas){
660 return meas->fitState() != CalibratedSpacePoint::State::Valid &&
661 meas->type() == xAOD::UncalibMeasType::MMClusterType &&
662 !m_idHelperSvc->mmIdHelper().isStereo(meas->spacePoint()->identify());
663 }));
664 m_out_segment_nMmStereoOutliers.push_back(hitCounter([this](const auto& meas){
665 return meas->fitState() != CalibratedSpacePoint::State::Valid &&
666 meas->type() == xAOD::UncalibMeasType::MMClusterType &&
667 m_idHelperSvc->mmIdHelper().isStereo(meas->spacePoint()->identify());
668 }));
669
670 m_out_segment_nSTgcStripHits.push_back(hitCounter([](const auto& meas){
671 return meas->fitState() == CalibratedSpacePoint::State::Valid &&
672 meas->type() == xAOD::UncalibMeasType::sTgcStripType &&
673 isPrecision(*meas);
674 }));
675 m_out_segment_nSTgcWireHits.push_back(hitCounter([this](const auto& meas){
676 return meas->fitState() == CalibratedSpacePoint::State::Valid &&
677 meas->type() == xAOD::UncalibMeasType::sTgcStripType &&
678 meas->measuresPhi() &&
679 m_idHelperSvc->stgcIdHelper().channelType(meas->spacePoint()->identify()) !=
680 sTgcIdHelper::sTgcChannelTypes::Pad;
681 }));
682 m_out_segment_nSTgcPadHits.push_back(hitCounter([this](const auto& meas){
683 return meas->fitState() == CalibratedSpacePoint::State::Valid &&
684 meas->type() == xAOD::UncalibMeasType::sTgcStripType &&
685 m_idHelperSvc->stgcIdHelper().channelType(meas->spacePoint()->identify()) ==
686 sTgcIdHelper::sTgcChannelTypes::Pad;
687 }));
688 m_out_segment_nSTgcStripOutliers.push_back(hitCounter([](const auto& meas){
689 return meas->fitState() != CalibratedSpacePoint::State::Valid &&
690 meas->type() == xAOD::UncalibMeasType::sTgcStripType &&
691 isPrecision(*meas);
692 }));
693 m_out_segment_nSTgcWireOutliers.push_back(hitCounter([this](const auto& meas){
694 return meas->fitState() != CalibratedSpacePoint::State::Valid &&
695 meas->type() == xAOD::UncalibMeasType::sTgcStripType &&
696 meas->measuresPhi() &&
697 m_idHelperSvc->stgcIdHelper().channelType(meas->spacePoint()->identify()) !=
698 sTgcIdHelper::sTgcChannelTypes::Pad;
699 }));
700 m_out_segment_nSTgcPadOutliers.push_back(hitCounter([this](const auto& meas){
701 return meas->fitState() != CalibratedSpacePoint::State::Valid &&
702 meas->type() == xAOD::UncalibMeasType::sTgcStripType &&
703 m_idHelperSvc->stgcIdHelper().channelType(meas->spacePoint()->identify()) ==
704 sTgcIdHelper::sTgcChannelTypes::Pad;
705 }));
707 m_out_segment_nMmTrueEtaHits.push_back(hitCounter([this](const auto& meas){
708 return meas->fitState() == CalibratedSpacePoint::State::Valid &&
709 meas->type() == xAOD::UncalibMeasType::MMClusterType &&
710 (!m_visionTool.isEnabled() || m_visionTool->isLabeled(*meas->spacePoint())) &&
711 !m_idHelperSvc->mmIdHelper().isStereo(meas->spacePoint()->identify());
712 }));
713 m_out_segment_nMmTrueStereoHits.push_back(hitCounter([this](const auto& meas){
714 return meas->fitState() == CalibratedSpacePoint::State::Valid &&
715 meas->type() == xAOD::UncalibMeasType::MMClusterType &&
716 (!m_visionTool.isEnabled() || m_visionTool->isLabeled(*meas->spacePoint())) &&
717 m_idHelperSvc->mmIdHelper().isStereo(meas->spacePoint()->identify());
718 }));
719 m_out_segment_nMmTrueEtaOutliers.push_back(hitCounter([this](const auto& meas){
720 return meas->fitState() != CalibratedSpacePoint::State::Valid &&
721 meas->type() == xAOD::UncalibMeasType::MMClusterType &&
722 (!m_visionTool.isEnabled() || m_visionTool->isLabeled(*meas->spacePoint())) &&
723 !m_idHelperSvc->mmIdHelper().isStereo(meas->spacePoint()->identify());
724 }));
725 m_out_segment_nMmTrueStereoOutliers.push_back(hitCounter([this](const auto& meas){
726 return meas->fitState() != CalibratedSpacePoint::State::Valid &&
727 meas->type() == xAOD::UncalibMeasType::MMClusterType &&
728 (!m_visionTool.isEnabled() || m_visionTool->isLabeled(*meas->spacePoint())) &&
729 m_idHelperSvc->mmIdHelper().isStereo(meas->spacePoint()->identify());
730 }));
731 m_out_segment_nSTgcTrueStripHits.push_back(hitCounter([this](const auto& meas){
732 return meas->fitState() == CalibratedSpacePoint::State::Valid &&
733 meas->type() == xAOD::UncalibMeasType::sTgcStripType &&
734 (!m_visionTool.isEnabled() || m_visionTool->isLabeled(*meas->spacePoint())) &&
735 isPrecision(*meas);
736 }));
737 m_out_segment_nSTgcTrueWireHits.push_back(hitCounter([this](const auto& meas){
738 return meas->fitState() == CalibratedSpacePoint::State::Valid &&
739 meas->type() == xAOD::UncalibMeasType::sTgcStripType &&
740 (!m_visionTool.isEnabled() || m_visionTool->isLabeled(*meas->spacePoint())) &&
741 meas->measuresPhi() &&
742 m_idHelperSvc->stgcIdHelper().channelType(meas->spacePoint()->identify()) !=
743 sTgcIdHelper::sTgcChannelTypes::Pad;
744 }));
745 m_out_segment_nSTgcTruePadHits.push_back(hitCounter([this](const auto& meas){
746 return meas->fitState() == CalibratedSpacePoint::State::Valid &&
747 meas->type() == xAOD::UncalibMeasType::sTgcStripType &&
748 (!m_visionTool.isEnabled() || m_visionTool->isLabeled(*meas->spacePoint())) &&
749 m_idHelperSvc->stgcIdHelper().channelType(meas->spacePoint()->identify()) ==
750 sTgcIdHelper::sTgcChannelTypes::Pad;
751 }));
752 m_out_segment_nSTgcTrueStripOutliers.push_back(hitCounter([this](const auto& meas){
753 return meas->fitState() != CalibratedSpacePoint::State::Valid &&
754 meas->type() == xAOD::UncalibMeasType::sTgcStripType &&
755 (!m_visionTool.isEnabled() || m_visionTool->isLabeled(*meas->spacePoint())) &&
756 isPrecision(*meas);
757 }));
758 m_out_segment_nSTgcTrueWireOutliers.push_back(hitCounter([this](const auto& meas){
759 return meas->fitState() != CalibratedSpacePoint::State::Valid &&
760 meas->type() == xAOD::UncalibMeasType::sTgcStripType &&
761 (!m_visionTool.isEnabled() || m_visionTool->isLabeled(*meas->spacePoint())) &&
762 meas->measuresPhi() &&
763 m_idHelperSvc->stgcIdHelper().channelType(meas->spacePoint()->identify()) !=
764 sTgcIdHelper::sTgcChannelTypes::Pad;
765 }));
766 m_out_segment_nSTgcTruePadOutliers.push_back(hitCounter([this](const auto& meas){
767 return meas->fitState() != CalibratedSpacePoint::State::Valid &&
768 meas->type() == xAOD::UncalibMeasType::sTgcStripType &&
769 (!m_visionTool.isEnabled() || m_visionTool->isLabeled(*meas->spacePoint())) &&
770 m_idHelperSvc->stgcIdHelper().channelType(meas->spacePoint()->identify()) ==
771 sTgcIdHelper::sTgcChannelTypes::Pad;
772 }));
773
774 double minYhit = 1._km;
775 double maxYhit = -1._km;
776 double minYTruehit = 1._km;
777 double maxYTruehit = -1._km;
778
779 std::vector<unsigned char> matched{};
780 for (const auto & meas : detailSeg->measurements()){
781 // skip dummy measurement from beam spot constraint
782 ATH_MSG_VERBOSE(__func__<<"() - "<<__LINE__<<" Dump "<<(*meas));
783 if (meas->type() == xAOD::UncalibMeasType::Other) {
784 continue;
785 }
786 minYhit = std::min(meas->localPosition().y(),minYhit);
787 maxYhit = std::max(meas->localPosition().y(),maxYhit);
788 if (!m_visionTool.isEnabled() || m_visionTool->isLabeled(*meas->spacePoint())) {
789 minYTruehit = std::min(meas->localPosition().y(), minYTruehit);
790 maxYTruehit = std::max(meas->localPosition().y(), maxYTruehit);
791 }
792 if (m_writeSpacePoints) {
793 unsigned treeIdx = m_spTester->push_back(*meas->spacePoint());
794 if (treeIdx >= matched.size()){
795 matched.resize(treeIdx +1);
796 }
797 matched[treeIdx] = true;
798 }
799 }
800
801 m_out_segment_minYhit += minYhit;
802 m_out_segment_maxYhit += maxYhit;
803 m_out_segment_minTrueYhit += minYTruehit;
804 m_out_segment_maxTrueYhit += maxYTruehit;
805 if (m_writeSpacePoints) {
806 m_spMatchedToSegment.push_back(std::move(matched));
807 }
808 }
809 }
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x,...)
Definition AthMsgStreamMacros.h:42
MuonR4::Segment::nFitIterations
unsigned int nFitIterations() const
Returns how many iterations the fitter needed to make the segment converge.
Definition MuonSpectrometer/MuonPhaseII/Event/MuonPatternEvent/MuonPatternEvent/Segment.h:56
MuonValR4::MuonHoughTransformTester::m_out_segment_nMmStereoHits
MuonVal::VectorBranch< unsigned short > & m_out_segment_nMmStereoHits
Definition MuonHoughTransformTester.h:284
MuonValR4::MuonHoughTransformTester::m_out_segment_n
MuonVal::ScalarBranch< unsigned > & m_out_segment_n
========== Segment block: Filled when we have one or multiple segments =============
Definition MuonHoughTransformTester.h:242
MuonValR4::MuonHoughTransformTester::m_out_segment_nTrigPhiOutliers
MuonVal::VectorBranch< unsigned short > & m_out_segment_nTrigPhiOutliers
Definition MuonHoughTransformTester.h:268
MuonValR4::MuonHoughTransformTester::m_out_segment_hasTimeFit
MuonVal::VectorBranch< char > & m_out_segment_hasTimeFit
Definition MuonHoughTransformTester.h:248
MuonValR4::MuonHoughTransformTester::m_segmentCov
std::array< FloatVecBrPtr_t, Acts::sumUpToN(Acts::toUnderlying(MuonR4::SegmentFit::ParamDefs::nPars))> m_segmentCov
Definition MuonHoughTransformTester.h:259
MuonValR4::MuonHoughTransformTester::m_out_segment_nTrigPhiHits
MuonVal::VectorBranch< unsigned short > & m_out_segment_nTrigPhiHits
Definition MuonHoughTransformTester.h:264
MuonValR4::MuonHoughTransformTester::m_out_segment_nSTgcTruePadHits
MuonVal::VectorBranch< unsigned short > & m_out_segment_nSTgcTruePadHits
Definition MuonHoughTransformTester.h:293
MuonValR4::MuonHoughTransformTester::m_out_segment_nTruePrecOutliers
MuonVal::VectorBranch< unsigned short > & m_out_segment_nTruePrecOutliers
Definition MuonHoughTransformTester.h:278
MuonValR4::MuonHoughTransformTester::m_out_segment_nSTgcPadOutliers
MuonVal::VectorBranch< unsigned short > & m_out_segment_nSTgcPadOutliers
Definition MuonHoughTransformTester.h:299
MuonValR4::MuonHoughTransformTester::m_out_segment_maxTrueYhit
MuonVal::VectorBranch< float > & m_out_segment_maxTrueYhit
Definition MuonHoughTransformTester.h:311
MuonValR4::MuonHoughTransformTester::m_out_segment_nSTgcTrueStripHits
MuonVal::VectorBranch< unsigned short > & m_out_segment_nSTgcTrueStripHits
Definition MuonHoughTransformTester.h:291
MuonValR4::MuonHoughTransformTester::m_out_segment_nSTgcTruePadOutliers
MuonVal::VectorBranch< unsigned short > & m_out_segment_nSTgcTruePadOutliers
Definition MuonHoughTransformTester.h:305
MuonValR4::MuonHoughTransformTester::m_out_segment_nTruePrecHits
MuonVal::VectorBranch< unsigned short > & m_out_segment_nTruePrecHits
True matched hit counters.
Definition MuonHoughTransformTester.h:274
MuonValR4::MuonHoughTransformTester::m_out_segment_nSTgcTrueWireHits
MuonVal::VectorBranch< unsigned short > & m_out_segment_nSTgcTrueWireHits
Definition MuonHoughTransformTester.h:292
MuonValR4::MuonHoughTransformTester::m_out_segment_nTrigPhiHoles
MuonVal::VectorBranch< unsigned short > & m_out_segment_nTrigPhiHoles
Definition MuonHoughTransformTester.h:272
MuonValR4::MuonHoughTransformTester::m_out_segment_time
MuonVal::VectorBranch< float > & m_out_segment_time
Definition MuonHoughTransformTester.h:256
MuonValR4::MuonHoughTransformTester::m_spMatchedToSegment
MuonVal::MatrixBranch< unsigned char > & m_spMatchedToSegment
Branch indicating which space points in the tree are associated to the i-th segment.
Definition MuonHoughTransformTester.h:140
MuonValR4::MuonHoughTransformTester::m_out_segment_nSTgcTrueStripOutliers
MuonVal::VectorBranch< unsigned short > & m_out_segment_nSTgcTrueStripOutliers
Definition MuonHoughTransformTester.h:303
MuonValR4::MuonHoughTransformTester::m_out_segment_nPrecOutliers
MuonVal::VectorBranch< unsigned short > & m_out_segment_nPrecOutliers
Definition MuonHoughTransformTester.h:266
MuonValR4::MuonHoughTransformTester::m_out_segment_nMmStereoOutliers
MuonVal::VectorBranch< unsigned short > & m_out_segment_nMmStereoOutliers
Definition MuonHoughTransformTester.h:296
MuonValR4::MuonHoughTransformTester::m_out_segment_nTrigEtaHits
MuonVal::VectorBranch< unsigned short > & m_out_segment_nTrigEtaHits
Definition MuonHoughTransformTester.h:263
MuonValR4::MuonHoughTransformTester::m_out_segment_nSTgcStripOutliers
MuonVal::VectorBranch< unsigned short > & m_out_segment_nSTgcStripOutliers
Definition MuonHoughTransformTester.h:297
MuonValR4::MuonHoughTransformTester::m_out_segment_nTrigEtaHoles
MuonVal::VectorBranch< unsigned short > & m_out_segment_nTrigEtaHoles
Definition MuonHoughTransformTester.h:271
MuonValR4::MuonHoughTransformTester::m_out_segment_nSTgcWireOutliers
MuonVal::VectorBranch< unsigned short > & m_out_segment_nSTgcWireOutliers
Definition MuonHoughTransformTester.h:298
MuonValR4::MuonHoughTransformTester::m_out_segment_chi2
MuonVal::VectorBranch< float > & m_out_segment_chi2
Definition MuonHoughTransformTester.h:246
MuonValR4::MuonHoughTransformTester::m_out_segment_nMmTrueEtaOutliers
MuonVal::VectorBranch< unsigned short > & m_out_segment_nMmTrueEtaOutliers
Definition MuonHoughTransformTester.h:301
MuonValR4::MuonHoughTransformTester::m_out_segment_nTrueTrigEtaHits
MuonVal::VectorBranch< unsigned short > & m_out_segment_nTrueTrigEtaHits
Definition MuonHoughTransformTester.h:275
MuonValR4::MuonHoughTransformTester::m_out_segment_phi
MuonVal::VectorBranch< float > & m_out_segment_phi
Definition MuonHoughTransformTester.h:255
MuonValR4::MuonHoughTransformTester::m_out_segment_nTrueTrigPhiOutliers
MuonVal::VectorBranch< unsigned short > & m_out_segment_nTrueTrigPhiOutliers
Definition MuonHoughTransformTester.h:280
MuonValR4::MuonHoughTransformTester::m_out_segment_theta
MuonVal::VectorBranch< float > & m_out_segment_theta
Definition MuonHoughTransformTester.h:254
MuonValR4::MuonHoughTransformTester::m_out_segment_nMmTrueStereoHits
MuonVal::VectorBranch< unsigned short > & m_out_segment_nMmTrueStereoHits
Definition MuonHoughTransformTester.h:290
MuonValR4::MuonHoughTransformTester::m_out_segment_nTrigEtaOutliers
MuonVal::VectorBranch< unsigned short > & m_out_segment_nTrigEtaOutliers
Definition MuonHoughTransformTester.h:267
MuonValR4::MuonHoughTransformTester::m_out_segment_minYhit
MuonVal::VectorBranch< float > & m_out_segment_minYhit
Definition MuonHoughTransformTester.h:308
MuonValR4::MuonHoughTransformTester::m_out_segment_nMmEtaOutliers
MuonVal::VectorBranch< unsigned short > & m_out_segment_nMmEtaOutliers
Definition MuonHoughTransformTester.h:295
MuonValR4::MuonHoughTransformTester::m_out_segment_nMmTrueStereoOutliers
MuonVal::VectorBranch< unsigned short > & m_out_segment_nMmTrueStereoOutliers
Definition MuonHoughTransformTester.h:302
MuonValR4::MuonHoughTransformTester::m_out_segment_x0
MuonVal::VectorBranch< float > & m_out_segment_x0
Definition MuonHoughTransformTester.h:253
MuonValR4::MuonHoughTransformTester::m_out_segment_nSTgcPadHits
MuonVal::VectorBranch< unsigned short > & m_out_segment_nSTgcPadHits
Definition MuonHoughTransformTester.h:287
MuonValR4::MuonHoughTransformTester::m_out_segment_nMmEtaHits
MuonVal::VectorBranch< unsigned short > & m_out_segment_nMmEtaHits
NSW hit counters.
Definition MuonHoughTransformTester.h:283
MuonValR4::MuonHoughTransformTester::m_out_segment_nTrueTrigPhiHits
MuonVal::VectorBranch< unsigned short > & m_out_segment_nTrueTrigPhiHits
Definition MuonHoughTransformTester.h:276
MuonValR4::MuonHoughTransformTester::m_out_segment_maxYhit
MuonVal::VectorBranch< float > & m_out_segment_maxYhit
Definition MuonHoughTransformTester.h:309
MuonValR4::MuonHoughTransformTester::m_out_segment_nSTgcTrueWireOutliers
MuonVal::VectorBranch< unsigned short > & m_out_segment_nSTgcTrueWireOutliers
Definition MuonHoughTransformTester.h:304
MuonValR4::MuonHoughTransformTester::m_out_segment_minTrueYhit
MuonVal::VectorBranch< float > & m_out_segment_minTrueYhit
Definition MuonHoughTransformTester.h:310
MuonValR4::MuonHoughTransformTester::m_out_segment_nSTgcWireHits
MuonVal::VectorBranch< unsigned short > & m_out_segment_nSTgcWireHits
Definition MuonHoughTransformTester.h:286
MuonValR4::MuonHoughTransformTester::m_out_segment_nPrecHits
MuonVal::VectorBranch< unsigned short > & m_out_segment_nPrecHits
Hit counts on segment.
Definition MuonHoughTransformTester.h:262
MuonValR4::MuonHoughTransformTester::m_out_segment_nMmTrueEtaHits
MuonVal::VectorBranch< unsigned short > & m_out_segment_nMmTrueEtaHits
Definition MuonHoughTransformTester.h:289
MuonValR4::MuonHoughTransformTester::m_out_segment_nDoF
MuonVal::VectorBranch< uint16_t > & m_out_segment_nDoF
Definition MuonHoughTransformTester.h:247
MuonValR4::MuonHoughTransformTester::m_out_segment_fitIter
MuonVal::VectorBranch< uint16_t > & m_out_segment_fitIter
Definition MuonHoughTransformTester.h:249
MuonValR4::MuonHoughTransformTester::m_out_segment_y0
MuonVal::VectorBranch< float > & m_out_segment_y0
Definition MuonHoughTransformTester.h:252
MuonValR4::MuonHoughTransformTester::m_out_segment_nTrueTrigEtaOutliers
MuonVal::VectorBranch< unsigned short > & m_out_segment_nTrueTrigEtaOutliers
Definition MuonHoughTransformTester.h:279
MuonValR4::MuonHoughTransformTester::m_out_segment_nPrecHoles
MuonVal::VectorBranch< unsigned short > & m_out_segment_nPrecHoles
Definition MuonHoughTransformTester.h:270
MuonValR4::MuonHoughTransformTester::m_out_segment_nSTgcStripHits
MuonVal::VectorBranch< unsigned short > & m_out_segment_nSTgcStripHits
Definition MuonHoughTransformTester.h:285
xAOD::MuonSegment_v1::nTrigEtaLayers
std::uint8_t nTrigEtaLayers() const
Returns the number of trigger eta hits.
xAOD::MuonSegment_v1::nTriggerPhiHoles
std::uint8_t nTriggerPhiHoles() const
Returns the number of trigger phi holes.
xAOD::MuonSegment_v1::numberDoF
float numberDoF() const
Returns the numberDoF.
xAOD::MuonSegment_v1::nPrecisionOutliers
std::uint8_t nPrecisionOutliers() const
Returns the number of precision outliers.
xAOD::MuonSegment_v1::nTriggerPhiOutliers
std::uint8_t nTriggerPhiOutliers() const
Returns the number of trigger phi outliers.
xAOD::MuonSegment_v1::chiSquared
float chiSquared() const
xAOD::MuonSegment_v1::nPrecisionHits
std::uint8_t nPrecisionHits() const
Returns the number of precision hits.
xAOD::MuonSegment_v1::nPrecisionHoles
std::uint8_t nPrecisionHoles() const
Returns the number of precision holes.
xAOD::MuonSegment_v1::position
Amg::Vector3D position() const
Returns the position as Amg::Vector.
Definition MuonSegment_v1.cxx:19
xAOD::MuonSegment_v1::nTriggerEtaHoles
std::uint8_t nTriggerEtaHoles() const
Returns the number of trigger eta holes.
xAOD::MuonSegment_v1::nPhiLayers
std::uint8_t nPhiLayers() const
Returns the number of trigger phi hits.
xAOD::MuonSegment_v1::nTriggerEtaOutliers
std::uint8_t nTriggerEtaOutliers() const
Returns the number of trigger eta outliers.
MuonR4::SegmentFit::localSegmentCov
std::optional< Covariance > localSegmentCov(const xAOD::MuonSegment &seg)
Returns the localCovariance decoration from a xAOD::MuonSegment.
Definition SegmentFitterEventData.cxx:84
TauHitVars::j
float j(const xAOD::IParticle &, const xAOD::TrackMeasurementValidation &hit, const Eigen::Matrix3d &jab_inv)
Definition ConstituentLoaderTauHit.cxx:102
xAOD::MuonSegment
MuonSegment_v1 MuonSegment
Reference the current persistent version:
Definition Event/xAOD/xAODMuon/xAODMuon/MuonSegment.h:13

◆ fillTruthInfo()

void MuonValR4::MuonHoughTransformTester::fillTruthInfo ( const ActsTrk::GeometryContext & gctx,
const xAOD::MuonSegment * truthSegment )
private

Fill the associated truth information into the tree.

Parameters
truthSegmentPointer to the truth parameters in form of a segment
gctxGeometry context for the alignment of the spectrometer sector

Definition at line 284 of file MuonHoughTransformTester.cxx.

285 {
286 if (!segment) {
287 return;
288 }
289 const xAOD::TruthParticle* truthMuon = getTruthMatchedParticle(*segment);
290 m_out_hasTruth = true;
291
292 const Amg::Vector3D segDir{segment->direction()};
293 static const SG::ConstAccessor<float> acc_pt{"pt"};
294 static const SG::ConstAccessor<float> acc_charge{"charge"};
295 // eta is interpreted as the eta-location
296 m_out_gen_Q = acc_charge(*segment);
297 if (truthMuon) {
298 m_out_gen_Pt = truthMuon->pt();
299 m_out_gen_Eta = truthMuon->eta();
300 m_out_gen_Phi = truthMuon->phi();
301 m_out_gen_truthPdgId = truthMuon->pdgId();
302 m_out_gen_truthBeta = truthMuon->p4().Beta();
303 } else {
304 m_out_gen_Pt = acc_pt(*segment);
305 m_out_gen_Eta = segDir.eta();
306 m_out_gen_Phi = segDir.phi();
307 }
308 m_out_gen_deflection = Amg::angle(segDir, segment->position());
309 m_out_gen_deflectionEta = segDir.eta() - segment->position().eta();
310
311 const auto [chamberPos, chamberDir] = SegmentFit::makeLine(SegmentFit::localSegmentPars(*segment));
312
313 ATH_MSG_DEBUG("Number of precision Hits in the truth segment is "<<segment->nPrecisionHits()<<" and number of phi layers is "
314 <<segment->nPhiLayers()<<" and number of trigger eta layers is "<<segment->nTrigEtaLayers());
315 m_out_gen_nPrecHits = segment->nPrecisionHits();
316 m_out_gen_nTrigEtaHits = segment->nTrigEtaLayers();
317 m_out_gen_nTrigPhiHits = segment->nPhiLayers();
318 using namespace Acts::detail::LineHelper;
319 const Acts::Intersection3D bsExtp = lineIntersect<3>(Amg::Vector3D::Zero(),
320 Amg::Vector3D::UnitZ(),
321 segment->position(),
322 segment->direction());
323 const Amg::Vector3D closePoint = bsExtp.position();
324
325 m_out_gen_beamSpotR = closePoint.perp();
326 m_out_gen_beamSpotZ = std::abs(closePoint.z());
327 unsigned nMmEtaHits{0}, nMmStereoHits{0}, nStgcHits{0};
328 for (const xAOD::MuonSimHit* simHit : getMatchingSimHits(*segment)) {
329 if (!m_out_gen_truthBeta.isUpdated()) {
330 m_out_gen_truthBeta = simHit->beta();
331 m_out_gen_truthPdgId = simHit->pdgId();
332 }
333 nStgcHits += m_idHelperSvc->technologyIndex(simHit->identify()) == TechnologyIndex::STGC;
334 if(m_idHelperSvc->technologyIndex(simHit->identify()) != TechnologyIndex::MM) {
335 continue;
336 }
337 const bool isStereo = m_idHelperSvc->mmIdHelper().isStereo(simHit->identify());
338 nMmEtaHits += (!isStereo);
339 nMmStereoHits += isStereo;
340 }
341 m_out_gen_nMmEtaHits = nMmEtaHits;
342 m_out_gen_nMmStereoHits = nMmStereoHits;
343 m_out_gen_nStgcHits = nStgcHits;
344
345 m_out_gen_tanbeta = houghTanBeta(chamberDir);
346 m_out_gen_tanalpha = houghTanAlpha(chamberDir);
347 m_out_gen_y0 = chamberPos.y();
348 m_out_gen_x0 = chamberPos.x();
349 m_out_gen_time = segment->t0();
350
351 double minYhit = std::numeric_limits<double>::max();
352 double maxYhit = -1 * std::numeric_limits<double>::max();
353 for (const xAOD::MuonSimHit* hit : getMatchingSimHits(*segment)){
354 // Tell clang to optimize assuming FP operations may trap.
355 // cf. ATLASRECTS-8447
356 CXXUTILS_TRAPPING_FP;
357 const Identifier hitId = hit->identify();
358 const MuonGMR4::MuonReadoutElement* RE = m_detMgr->getReadoutElement(hitId);
359 const IdentifierHash hash{m_idHelperSvc->isMdt(hitId) ? RE->measurementHash(hitId)
360 : RE->layerHash(hitId) };
361 const Acts::Transform3 localToChamber = RE->msSector()->globalToLocalTransform(gctx) * RE->localToGlobalTransform(gctx, hash);
362 const Amg::Vector3D chamberPos = localToChamber * xAOD::toEigen(hit->localPosition());
363 minYhit = std::min(chamberPos.y(), minYhit);
364 maxYhit = std::max(chamberPos.y(), maxYhit);
365 }
366 m_out_gen_minYhit = minYhit;
367 m_out_gen_maxYhit = maxYhit;
368
369
370 if (truthMuon) {
371 using namespace xAOD::TruthHelpers;
372 m_out_gen_truthType = getParticleTruthType(*truthMuon);
373 m_out_gen_truthOrigin = getParticleTruthOrigin(*truthMuon);
374 }
375 }
MuonGMR4::MuonReadoutElement::msSector
const SpectrometerSector * msSector() const
Returns the pointer to the envelope volume enclosing all chambers in the sector.
MuonGMR4::MuonReadoutElement::localToGlobalTransform
const Acts::Transform3 & localToGlobalTransform(const ActsTrk::GeometryContext &ctx) const override final
Returns the transformation from the local coordinate system of the readout element into the global AT...
Definition MuonPhaseII/MuonDetDescr/MuonReadoutGeometryR4/src/MuonReadoutElement.cxx:78
MuonGMR4::MuonReadoutElement::measurementHash
virtual IdentifierHash measurementHash(const Identifier &measId) const =0
The measurement hash is a continous numbering schema of all readout channels described by the specifi...
MuonGMR4::MuonReadoutElement::layerHash
virtual IdentifierHash layerHash(const Identifier &measId) const =0
The layer hash removes the bits from the IdentifierHash corresponding to the measurement's channel nu...
MuonGMR4::SpectrometerSector::globalToLocalTransform
const Acts::Transform3 & globalToLocalTransform(const ActsTrk::GeometryContext &gctx) const
Returns the global -> local transformation from the ATLAS global.
Definition SpectrometerSector.cxx:78
MuonValR4::MuonHoughTransformTester::m_out_gen_tanalpha
MuonVal::ScalarBranch< float > & m_out_gen_tanalpha
Definition MuonHoughTransformTester.h:171
MuonValR4::MuonHoughTransformTester::m_out_gen_Pt
MuonVal::ScalarBranch< float > & m_out_gen_Pt
Definition MuonHoughTransformTester.h:164
MuonValR4::MuonHoughTransformTester::m_out_gen_truthBeta
MuonVal::ScalarBranch< float > & m_out_gen_truthBeta
Definition MuonHoughTransformTester.h:166
MuonValR4::MuonHoughTransformTester::m_detMgr
const MuonGMR4::MuonDetectorManager * m_detMgr
Definition MuonHoughTransformTester.h:316
MuonValR4::MuonHoughTransformTester::m_out_gen_deflection
MuonVal::ScalarBranch< float > & m_out_gen_deflection
Definition MuonHoughTransformTester.h:182
MuonValR4::MuonHoughTransformTester::m_out_gen_nStgcHits
MuonVal::ScalarBranch< unsigned short > & m_out_gen_nStgcHits
Definition MuonHoughTransformTester.h:191
MuonValR4::MuonHoughTransformTester::m_out_hasTruth
MuonVal::ScalarBranch< char > & m_out_hasTruth
======= Truth block: Filled if we have a truth match. ============
Definition MuonHoughTransformTester.h:159
MuonValR4::MuonHoughTransformTester::m_out_gen_deflectionEta
MuonVal::ScalarBranch< float > & m_out_gen_deflectionEta
Definition MuonHoughTransformTester.h:183
MuonValR4::MuonHoughTransformTester::m_out_gen_nMmEtaHits
MuonVal::ScalarBranch< unsigned short > & m_out_gen_nMmEtaHits
Definition MuonHoughTransformTester.h:189
MuonValR4::MuonHoughTransformTester::m_out_gen_truthType
MuonVal::ScalarBranch< int > & m_out_gen_truthType
Definition MuonHoughTransformTester.h:176
MuonValR4::MuonHoughTransformTester::m_out_gen_truthPdgId
MuonVal::ScalarBranch< int > & m_out_gen_truthPdgId
Definition MuonHoughTransformTester.h:177
MuonValR4::MuonHoughTransformTester::m_out_gen_beamSpotR
MuonVal::ScalarBranch< float > & m_out_gen_beamSpotR
Beamspot approach.
Definition MuonHoughTransformTester.h:180
MuonValR4::MuonHoughTransformTester::m_out_gen_Q
MuonVal::ScalarBranch< short > & m_out_gen_Q
Definition MuonHoughTransformTester.h:165
MuonValR4::MuonHoughTransformTester::m_out_gen_y0
MuonVal::ScalarBranch< float > & m_out_gen_y0
Truth - segment parameters.
Definition MuonHoughTransformTester.h:169
MuonValR4::MuonHoughTransformTester::m_out_gen_nMmStereoHits
MuonVal::ScalarBranch< unsigned short > & m_out_gen_nMmStereoHits
Definition MuonHoughTransformTester.h:190
MuonValR4::MuonHoughTransformTester::m_out_gen_Phi
MuonVal::ScalarBranch< float > & m_out_gen_Phi
Definition MuonHoughTransformTester.h:163
MuonValR4::MuonHoughTransformTester::m_out_gen_beamSpotZ
MuonVal::ScalarBranch< float > & m_out_gen_beamSpotZ
Definition MuonHoughTransformTester.h:181
MuonValR4::MuonHoughTransformTester::m_out_gen_truthOrigin
MuonVal::ScalarBranch< int > & m_out_gen_truthOrigin
MC truth calssifier definition.
Definition MuonHoughTransformTester.h:175
MuonValR4::MuonHoughTransformTester::m_out_gen_maxYhit
MuonVal::ScalarBranch< float > & m_out_gen_maxYhit
Definition MuonHoughTransformTester.h:196
MuonValR4::MuonHoughTransformTester::m_out_gen_minYhit
MuonVal::ScalarBranch< float > & m_out_gen_minYhit
Definition MuonHoughTransformTester.h:195
MuonValR4::MuonHoughTransformTester::m_out_gen_nPrecHits
MuonVal::ScalarBranch< unsigned short > & m_out_gen_nPrecHits
Truth - hit count summary.
Definition MuonHoughTransformTester.h:186
MuonValR4::MuonHoughTransformTester::m_out_gen_Eta
MuonVal::ScalarBranch< float > & m_out_gen_Eta
global particle properties
Definition MuonHoughTransformTester.h:162
MuonValR4::MuonHoughTransformTester::m_out_gen_time
MuonVal::ScalarBranch< float > & m_out_gen_time
Definition MuonHoughTransformTester.h:173
MuonValR4::MuonHoughTransformTester::m_out_gen_x0
MuonVal::ScalarBranch< float > & m_out_gen_x0
Definition MuonHoughTransformTester.h:172
MuonValR4::MuonHoughTransformTester::m_out_gen_nTrigEtaHits
MuonVal::ScalarBranch< unsigned short > & m_out_gen_nTrigEtaHits
Definition MuonHoughTransformTester.h:187
MuonValR4::MuonHoughTransformTester::m_out_gen_tanbeta
MuonVal::ScalarBranch< float > & m_out_gen_tanbeta
Definition MuonHoughTransformTester.h:170
MuonValR4::MuonHoughTransformTester::m_out_gen_nTrigPhiHits
MuonVal::ScalarBranch< unsigned short > & m_out_gen_nTrigPhiHits
Definition MuonHoughTransformTester.h:188
Amg::angle
double angle(const Amg::Vector3D &v1, const Amg::Vector3D &v2)
calculates the opening angle between two vectors
Definition GeoPrimitivesHelpers.h:43
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition GeoPrimitives.h:48
MuonR4::getTruthMatchedParticle
const xAOD::TruthParticle * getTruthMatchedParticle(const xAOD::MuonSegment &segment)
Returns the particle truth-matched to the segment.
Definition MuonSimHitHelpers.cxx:114
MuonR4::houghTanBeta
double houghTanBeta(const Amg::Vector3D &v)
Returns the hough tanBeta [y] / [z].
Definition SegmentFitterEventData.cxx:28
MuonR4::getMatchingSimHits
std::unordered_set< const xAOD::MuonSimHit * > getMatchingSimHits(const xAOD::MuonSegment &segment)
: Returns all sim hits matched to a xAOD::MuonSegment
Definition MuonSimHitHelpers.cxx:38
MuonR4::houghTanAlpha
double houghTanAlpha(const Amg::Vector3D &v)
: Returns the hough tanAlpha [x] / [z]
Definition SegmentFitterEventData.cxx:32
xAOD::TruthHelpers::getParticleTruthType
int getParticleTruthType(const xAOD::IParticle &p)
Return the particle's truth type (as defined by the MC Truth Classifier).
Definition xAODTruthHelpers.cxx:91
xAOD::TruthHelpers::getParticleTruthOrigin
int getParticleTruthOrigin(const xAOD::IParticle &p)
Return the particle's truth origin (as defined by the MC Truth Classifier).
Definition xAODTruthHelpers.cxx:109
xAOD::MuonSimHit
MuonSimHit_v1 MuonSimHit
Defined the version of the MuonSimHit.
Definition MuonSimHit.h:12
xAOD::TruthParticle
TruthParticle_v1 TruthParticle
Typedef to implementation.
Definition Event/xAOD/xAODTruth/xAODTruth/TruthParticle.h:15
CXXUTILS_TRAPPING_FP
#define CXXUTILS_TRAPPING_FP
Definition trapping_fp.h:24

◆ fillTruthSummary()

void MuonValR4::MuonHoughTransformTester::fillTruthSummary ( const xAOD::MuonSegment & recoSegment)
private

◆ filterPassed()

virtual bool AthCommonAlgorithm< Gaudi::Algorithm >::filterPassed ( const EventContext & ctx) const
inlinevirtualinherited

Get filter decision:

Definition at line 93 of file AthCommonAlgorithm.h.

93 {
94 return execState( ctx ).filterPassed();
95 }
AthCommonAlgorithm::filterPassed
virtual bool filterPassed(const EventContext &ctx) const
Get filter decision:
Definition AthCommonAlgorithm.h:93

◆ finalize()

StatusCode MuonValR4::MuonHoughTransformTester::finalize ( )
overridevirtual

Definition at line 241 of file MuonHoughTransformTester.cxx.

241 {
242 ATH_CHECK(m_tree.write());
243 return StatusCode::SUCCESS;
244 }

◆ graph()

TGraph * AthHistogramming::graph ( std::string_view graphName,
std::string_view tDir = "",
std::string_view stream = "" )
protectedinherited

Simplify the retrieval of registered TGraphs.

Definition at line 438 of file AthHistogramming.cxx.

439{
440 // Build a 32 bit hash out of the name
441 const hash_t graphHash = this->hash(graphName);
442
443 // See if this entry exists in the map
444 GraphMap_t::const_iterator it = m_graphMap.find( graphHash );
445 if ( it == m_graphMap.end() ) // It doesn't exist!
446 { // Let's see into the THistSvc if somebody else has registered the TGraph...
447
448 // Massage the final string to book things
449 std::string bookingString = buildBookingString( graphName, tDir, stream, false);
450
451 TGraph* graphPointer(nullptr);
452 if ( !((histSvc()->getGraph(bookingString, graphPointer)).isSuccess()) )
453 {
454 // Massage the final string to book things
455 std::string bookingString = buildBookingString( graphName, tDir, stream, true );
456
457 if ( !((histSvc()->getGraph(bookingString, graphPointer)).isSuccess()) )
458 {
459 m_msg << MSG::WARNING
460 << "Problem retrieving the TGraph with name (including pre- and post-fixes) "
461 << bookingString
462 << " or with name " << graphName
463 << " in " << m_name << "... it doesn't exist, neither in the cached map nor in the THistSvc!"
464 << " Will return an NULL pointer... you have to handle it correctly!" << endmsg;
465 return nullptr;
466 }
467 // If we get to here, we actually found the TGraph in the THistSvc.
468 // So let's add it to the local cache map and return its pointer
469 m_graphMap.insert( m_graphMap.end(), std::pair< const hash_t, TGraph* >( graphHash, graphPointer ) );
470 return graphPointer;
471 }
472 // If we get to here, we actually found the TGraph in the THistSvc.
473 // So let's add it to the local cache map and return its pointer
474 m_graphMap.insert( m_graphMap.end(), std::pair< const hash_t, TGraph* >( graphHash, graphPointer ) );
475 return graphPointer;
476 }
477
478
479 // Return the pointer to the TGraph that we got from the local cache map
480 return it->second;
481}
AthenaInternal::getGraph
std::pair< StatusCode, TGraph * > getGraph(ITHistSvc &svc, const std::string &name)
Definition AthenaPythonDict.h:51

◆ hash()

AthHistogramming::hash_t AthHistogramming::hash ( std::string_view histName) const
inlineprivateinherited

Method to calculate a 32-bit hash from a string.

Definition at line 422 of file AthHistogramming.h.

423{
424 const uint64_t hash64 = CxxUtils::crc64( std::string{histName} );
425 return (hash_t)(hash64 & 0xFFFFFFFF);
426}
CxxUtils::crc64
uint64_t crc64(const CRCTable &table, const char *data, size_t data_len)
Find the CRC-64 of a string,.
Definition crc64.cxx:695
xxh3::hash64
std::uint64_t hash64(const void *data, std::size_t size)
Passthrough to XXH3_64bits.
Definition XXH.cxx:9

◆ hist()

TH1 * AthHistogramming::hist ( std::string_view histName,
std::string_view tDir = "",
std::string_view stream = "" )
protectedinherited

Simplify the retrieval of registered histograms of any type.

Definition at line 182 of file AthHistogramming.cxx.

183 {
184
185 const auto histBaseName = splitName(histName).second;
186 std::string bookingString = buildBookingString(histName, tDir, stream, false);
187
188 const hash_t histHash = this->hash(histBaseName);
189
190 HistMap_t::const_iterator it = m_histMap.find(histHash);
191 if (it == m_histMap.end()) {
192 TH1* histPointer(nullptr);
193
194 if (!histSvc()->getHist(bookingString, histPointer).isSuccess()) {
195 std::string prefixedBookingString = buildBookingString(histName, tDir, stream, true);
196 if (!histSvc()->getHist(prefixedBookingString, histPointer).isSuccess()) {
197 m_msg << MSG::WARNING
198 << "Problem retrieving the histogram with name (including pre- and post-fixes) "
199 << prefixedBookingString
200 << " or with name " << histName
201 << " in " << m_name << "... it doesn't exist, neither in the cached map nor in the THistSvc!"
202 << " Will return an NULL pointer... you have to handle it correctly!" << endmsg;
203 return nullptr;
204 }
205 }
206
207 m_histMap.insert(m_histMap.end(), std::pair<const hash_t, TH1*>(histHash, histPointer));
208 return histPointer;
209 }
210
211 return it->second;
212}
AthenaInternal::getHist
std::pair< StatusCode, TH1 * > getHist(ITHistSvc &svc, const std::string &name, size_t index=0)
Definition AthenaPythonDict.h:42

◆ hist2d()

TH2 * AthHistogramming::hist2d ( std::string_view histName,
std::string_view tDir = "",
std::string_view stream = "" )
inlineprotectedinherited

Simplify the retrieval of registered 2-d histograms.

Definition at line 363 of file AthHistogramming.h.

364{
365 // Get the TH1 pointer
366 TH1* th1Pointer = this->hist(histName, tDir, stream);
367 if ( !th1Pointer )
368 {
369 m_msg << MSG::ERROR
370 << "Cannot get a 2-d histogram with name " << histName
371 << "... will probably seg-fault!" << endmsg;
372 return NULL;
373 }
374 // If the TH1 pointer is valid, simply return the dynamic_cast
375 return dynamic_cast<TH2*>( th1Pointer );
376}

◆ hist3d()

TH3 * AthHistogramming::hist3d ( std::string_view histName,
std::string_view tDir = "",
std::string_view stream = "" )
inlineprotectedinherited

Simplify the retrieval of registered 3-d histograms.

Definition at line 380 of file AthHistogramming.h.

381{
382 // Get the TH1 pointer
383 TH1* th1Pointer = this->hist(histName, tDir, stream);
384 if ( !th1Pointer )
385 {
386 m_msg << MSG::ERROR
387 << "Cannot get a 3-d histogram with name " << histName
388 << "... will probably seg-fault!" << endmsg;
389 return NULL;
390 }
391 // If the TH1 pointer is valid, simply return the dynamic_cast
392 return dynamic_cast<TH3*>( th1Pointer );
393}

◆ histSvc()

const ServiceHandle< ITHistSvc > & AthHistogramAlgorithm::histSvc ( ) const
inlineinherited

The standard THistSvc (for writing histograms and TTrees and more to a root file) Returns (kind of) a pointer to the THistSvc.

Definition at line 113 of file AthHistogramAlgorithm.h.

114{
115 return m_histSvc;
116}

◆ initialize()

StatusCode MuonValR4::MuonHoughTransformTester::initialize ( )
overridevirtual

The collection of readHandle keys should be either 1 or 2

Definition at line 58 of file MuonHoughTransformTester.cxx.

58 {
59 ATH_CHECK(m_geoCtxKey.initialize());
60
61 {
62 int infoOpts = 0;
63 if (m_isMC) infoOpts = EventInfoBranch::isMC;
64 m_tree.addBranch(std::make_unique<EventInfoBranch>(m_tree, infoOpts));
65 }
66
67 ATH_CHECK(m_recoSegKey.initialize());
68 for (const std::string& recoLink : m_recoSegLinks) {
69 m_truthSegLinkKeys.emplace_back(m_recoSegKey, recoLink);
70 }
71 ATH_CHECK(m_truthSegmentKey.initialize(!m_truthSegmentKey.empty()));
72 for (const std::string& link: m_truthLinks) {
73 m_truthSegLinkKeys.emplace_back(m_truthSegmentKey, link);
74 }
75 ATH_CHECK(m_truthSegLinkKeys.initialize(!m_truthSegmentKey.empty()));
76
78 ATH_CHECK(m_patternSeedKeys.initialize());
79 ATH_CHECK(m_spKeys.initialize(m_writeSpacePoints));
80 if (m_writeSpacePoints) {
81 m_spTester = std::make_unique<SpacePointTesterModule>(m_tree, m_spKeys.front().key(), msgLevel());
82 m_tree.addBranch(m_spTester);
83 } else {
84 m_tree.disableBranch(m_spMatchedToPattern.name());
85 m_tree.disableBranch(m_spMatchedToSegment.name());
86 }
87
88 for (std::size_t cov = 0 ; cov < m_segmentCov.size(); ++cov){
89 using namespace MuonR4::SegmentFit;
90 const auto [i, j] = Acts::symMatIndices<Acts::toUnderlying(ParamDefs::nPars)>(cov);
91 ParamDefs pI{static_cast<std::uint8_t>(i)},
92 pJ{static_cast<std::uint8_t>(j)};
93 std::string brName = (pI!= pJ) ? std::format("segment_cov_{:}_{:}", pI, pJ)
94 : std::format("segment_cov_{:}", pI);
95 m_segmentCov[cov] = std::make_shared<MuonVal::VectorBranch<float>>(m_tree, brName);
96 m_tree.addBranch(m_segmentCov[cov]);
97 }
98
99 ATH_CHECK(m_tree.init(this));
100 ATH_CHECK(m_idHelperSvc.retrieve());
101 ATH_CHECK(detStore()->retrieve(m_detMgr));
102
103 ATH_CHECK(m_visionTool.retrieve(EnableTool{!m_visionTool.empty()}));
104
105 return StatusCode::SUCCESS;
106 }
AthCommonAlgorithm< Gaudi::Algorithm >::detStore
const ServiceHandle< StoreGateSvc > & detStore() const
Definition AthCommonDataStore.h:95
MuonValR4::MuonHoughTransformTester::m_spKeys
SG::ReadHandleKeyArray< MuonR4::SpacePointContainer > m_spKeys
List of the space point containers in the event legacy + NSW containers.
Definition MuonHoughTransformTester.h:110
MuonValR4::MuonHoughTransformTester::m_truthSegLinkKeys
SG::ReadDecorHandleKeyArray< xAOD::MuonSegmentContainer > m_truthSegLinkKeys
Declare the dependencies on the decorations.
Definition MuonHoughTransformTester.h:100
MuonValR4::MuonHoughTransformTester::m_truthLinks
Gaudi::Property< std::vector< std::string > > m_truthLinks
Name of the decorations for the truth segment.
Definition MuonHoughTransformTester.h:102
MuonValR4::MuonHoughTransformTester::m_recoSegLinks
Gaudi::Property< std::vector< std::string > > m_recoSegLinks
name of the truth link decorations for the reco segment container
Definition MuonHoughTransformTester.h:106
MuonVal::EventInfoBranch::isMC
@ isMC
Flag determining whether the branch is simulation.
Definition EventInfoBranch.h:20
MuonR4::SegmentFit::ParamDefs
SeedingAux::FitParIndex ParamDefs
Use the same parameter indices as used by the CompSpacePointAuxiliaries.
Definition MuonHoughDefs.h:38

◆ inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::inputHandles ( ) const
overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ isClonable()

virtual bool AthCommonAlgorithm< Gaudi::Algorithm >::isClonable ( ) const
inlineoverridevirtualinherited

Specify if the algorithm is clonable.

Only relevant for non-reentrant algorithms. Actual number of clones needs to be set via the "Cardinality" property.

Reimplemented in AFP_DigiTop, AlgB, AlgT, BCM_Digitization, CscDigitBuilder, CscDigitToCscRDO, G4AtlasAlg, G4RunAlg, HGTD_Digitization, HiveAlgBase, InDet::GNNSeedingTrackMaker, InDet::SCT_Clusterization, InDet::SiSPGNNTrackMaker, InDet::SiSPSeededTrackFinder, InDet::SiTrackerSpacePointFinder, ISF::SimKernelMT, ITk::StripDigitization, ITkPixelCablingAlg, ITkStripCablingAlg, LArHitEMapMaker, LArTTL1Maker, LUCID_DigiTop, LVL1::L1TopoSimulation, MergeCalibHits, MergeGenericMuonSimHitColl, MergeHijingPars, MergeMcEventCollection, MergeTrackRecordCollection, MergeTruthJets, MergeTruthParticles, MuonDigitizer, PileUpMTAlg, PixelDigitization, RoIBResultToxAOD, SCT_ByteStreamErrorsTestAlg, SCT_CablingCondAlgFromCoraCool, SCT_CablingCondAlgFromText, SCT_ConditionsParameterTestAlg, SCT_ConditionsSummaryTestAlg, SCT_ConfigurationConditionsTestAlg, SCT_Digitization, SCT_FlaggedConditionTestAlg, SCT_LinkMaskingTestAlg, SCT_MajorityConditionsTestAlg, SCT_ModuleVetoTestAlg, SCT_MonitorConditionsTestAlg, SCT_PrepDataToxAOD, SCT_RawDataToxAOD, SCT_ReadCalibChipDataTestAlg, SCT_ReadCalibDataTestAlg, SCT_RODVetoTestAlg, SCT_SensorsTestAlg, SCT_SiliconConditionsTestAlg, SCT_StripVetoTestAlg, SCT_TdaqEnabledTestAlg, SCT_TestCablingAlg, SCTEventFlagWriter, SCTRawDataProvider, SCTSiLorentzAngleTestAlg, SCTSiPropertiesTestAlg, SGInputLoader, Simulation::BeamEffectsAlg, TileHitVecToCnt, TileMuonFitter, TilePulseForTileMuonReceiver, TileRawChannelMaker, TRTDigitization, and ZDC_DigiTop.

Definition at line 68 of file AthCommonAlgorithm.h.

68 {
69 return true;
70 }

◆ isReEntrant()

virtual bool AthAlgorithm::isReEntrant ( ) const
inlinefinaloverrideprotectedvirtualinherited

Legacy algorithms are not thread-safe.

Definition at line 47 of file AthAlgorithm.h.

47{ return false; }

◆ matchWithTruth()

std::vector< ObjectMatching > MuonValR4::MuonHoughTransformTester::matchWithTruth ( const MuonR4::SegmentSeedContainer & seedContainer,
const xAOD::MuonSegmentContainer & segmentContainer,
const xAOD::MuonSegmentContainer * truthSegments ) const
private

Step 1 Loop over all reconstructed segments && fill them into the association table

There is an associated truth egment

Thus far no entry in the association map

Sort the segments according to the drift signs

Loop over all remaining seeds and attempt to match them to a segment

Don't recycle the used seeds again

Find the segment that matches best to the seed

find the best matching segment

Finally loop over all truth segments and push back the unused ones

Check that the segment is not used yet

Definition at line 124 of file MuonHoughTransformTester.cxx.

126 {
127 std::vector<ObjectMatching> allAssociations{};
128 std::unordered_set<const SegmentSeed*> usedSeeds{};
131 for (const xAOD::MuonSegment* recoSeg : segmentContainer) {
132 const MuonR4::Segment* segment = detailedSegment(*recoSeg);
133 assert(segment != nullptr);
134 std::vector<ObjectMatching>::iterator assoc_itr = allAssociations.end();
135 const xAOD::MuonSegment* truthSeg = getMatchedTruthSegment(*recoSeg);
137 if (truthSeg) {
138 assoc_itr = std::ranges::find_if(allAssociations, [truthSeg](const ObjectMatching& obj){
139 return obj.truthSegment == truthSeg;
140 });
141 }
143 if (assoc_itr == allAssociations.end()) {
144 ObjectMatching& newObj = allAssociations.emplace_back();
145 newObj.chamber = m_detMgr->getSectorEnvelope(recoSeg->chamberIndex(),
146 recoSeg->sector(),
147 recoSeg->etaIndex());
148 newObj.truthSegment = truthSeg;
149 assoc_itr = allAssociations.end() -1;
150 }
151 ObjectMatching& assocObj{*assoc_itr};
152 assocObj.matchedSegments.push_back(recoSeg);
153 assocObj.matchedSeeds.push_back(segment->parent());
154 assocObj.matchedSeedFoundSegment.push_back(1);
155 usedSeeds.insert(segment->parent());
156 }
157
158 if (truthSegments) {
160 for (ObjectMatching& assocObj : allAssociations) {
161 if (!assocObj.truthSegment) {
162 continue;
163 }
164 std::ranges::sort(assocObj.matchedSegments,
165 [&](const xAOD::MuonSegment* a,
166 const xAOD::MuonSegment* b){
167 return countOnSameSide(*assocObj.truthSegment, *a) >
168 countOnSameSide(*assocObj.truthSegment, *b);
169 });
170 }
171 }
173 for (const SegmentSeed* seed : seedContainer) {
175 if (usedSeeds.count(seed)) {
176 continue;
177 }
179 std::vector<std::pair<const xAOD::MuonSegment*, std::size_t>> segCounts{};
180 std::unordered_set<const xAOD::MuonSimHit* > matchedHits = getMatchingSimHits(*seed);
181 for (const xAOD::MuonSimHit* hit : matchedHits) {
182 const xAOD::MuonSegment* truthSeg = getMatchedTruthSegment(*hit);
183 if (!truthSeg) {
184 continue;
185 }
186 auto count_itr = std::ranges::find_if(segCounts, [truthSeg](const auto& segCounter){
187 return segCounter.first == truthSeg;
188 });
189 if (count_itr != segCounts.end()) {
190 ++(count_itr->second);
191 } else {
192 segCounts.emplace_back(std::make_pair(truthSeg, 1ul));
193 }
194 }
196 std::ranges::sort(segCounts, [](const auto& a, const auto& b){
197 return a.second > b.second;
198 });
199 // Add a criterion on the number of counts?
200 const xAOD::MuonSegment* truthSeg = segCounts.size()
201 ? segCounts.front().first : nullptr;
202 if (truthSeg) {
203 auto assoc_itr = std::ranges::find_if(allAssociations,
204 [truthSeg](const ObjectMatching& obj){
205 return obj.truthSegment == truthSeg;
206 });
207 if (assoc_itr == allAssociations.end()) {
208 ObjectMatching & newObj = allAssociations.emplace_back();
209 newObj.chamber = seed->msSector();
210 newObj.truthSegment = truthSeg;
211 assoc_itr = allAssociations.end() -1;
212 }
213 assoc_itr->matchedSeeds.push_back(seed);
214 assoc_itr->matchedSeedFoundSegment.push_back(0);
215 } else {
216 ObjectMatching & newObj = allAssociations.emplace_back();
217 newObj.chamber = seed->msSector();
218 newObj.matchedSeeds.push_back(seed);
219 newObj.matchedSeedFoundSegment.push_back(0);
220 }
221 }
223 if (truthSegments) {
224 for (const xAOD::MuonSegment* truthSeg : *truthSegments) {
226 if (std::ranges::any_of(allAssociations, [truthSeg](const auto& assocObj){
227 return assocObj.truthSegment == truthSeg;
228 })) {
229 continue;
230 }
231 ObjectMatching & newObj = allAssociations.emplace_back();
232 newObj.chamber = m_detMgr->getSectorEnvelope(truthSeg->chamberIndex(),
233 truthSeg->sector(),
234 truthSeg->etaIndex());
235 newObj.truthSegment = truthSeg;
236 }
237 }
238 return allAssociations;
239 }
MuonR4::Segment::parent
const SegmentSeed * parent() const
Returns the seed out of which the segment was built.
Definition MuonSpectrometer/MuonPhaseII/Event/MuonPatternEvent/MuonPatternEvent/Segment.h:52
MuonR4::getMatchedTruthSegment
const xAOD::MuonSegment * getMatchedTruthSegment(const xAOD::MuonSegment &segment)
Returns the truth-matched segment.
Definition MuonSimHitHelpers.cxx:125
MuonValR4::MuonHoughTransformTester::ObjectMatching::matchedSegments
std::vector< const xAOD::MuonSegment * > matchedSegments
All segments matched to this object.
Definition MuonHoughTransformTester.h:55
MuonValR4::MuonHoughTransformTester::ObjectMatching::chamber
const MuonGMR4::SpectrometerSector * chamber
Associated chamber.
Definition MuonHoughTransformTester.h:51

◆ msg()

MsgStream & AthCommonMsg< Gaudi::Algorithm >::msg ( ) const
inlineinherited

Definition at line 24 of file AthCommonMsg.h.

24 {
25 return this->msgStream();
26 }

◆ msgLvl()

bool AthCommonMsg< Gaudi::Algorithm >::msgLvl ( const MSG::Level lvl) const
inlineinherited

Definition at line 30 of file AthCommonMsg.h.

30 {
31 return this->msgLevel(lvl);
32 }

◆ outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::outputHandles ( ) const
overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ renounce()

std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::renounce ( T & h)
inlineprotectedinherited

Definition at line 368 of file AthCommonDataStore.h.

369 {
370 h.renounce();
371 PBASE::renounce (h);
372 }
AthCommonDataStore::renounce
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > renounce(T &h)
Definition AthCommonDataStore.h:368

◆ renounceArray()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::renounceArray ( SG::VarHandleKeyArray & handlesArray)
inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 352 of file AthCommonDataStore.h.

352 {
353 handlesArray.renounce();
354 }

◆ setFilterPassed()

virtual void AthCommonAlgorithm< Gaudi::Algorithm >::setFilterPassed ( bool state,
const EventContext & ctx ) const
inlinevirtualinherited

Set filter decision:

Definition at line 99 of file AthCommonAlgorithm.h.

99 {
100 execState( ctx ).setFilterPassed( state );
101 }
AthCommonAlgorithm::setFilterPassed
virtual void setFilterPassed(bool state, const EventContext &ctx) const
Set filter decision:
Definition AthCommonAlgorithm.h:99

◆ sysExecute()

StatusCode AthCommonAlgorithm< Gaudi::Algorithm >::sysExecute ( const EventContext & ctx)
overridevirtualinherited

Execute an algorithm.

We override this in order to work around an issue with the Algorithm base class storing the event context in a member variable that can cause crashes in MT jobs.

Reimplemented in AthAnalysisAlgorithm.

Definition at line 80 of file AthCommonAlgorithm.cxx.

41{
42 return BaseAlg::sysExecute (ctx);
43}

◆ sysInitialize()

StatusCode AthHistogramAlgorithm::sysInitialize ( )
virtualinherited

Initialization method invoked by the framework.

This method is responsible for any bookkeeping of initialization required by the framework itself. It will in turn invoke the initialize() method of the derived algorithm, and of any sub-algorithms which it creates.

Reimplemented from AthCommonAlgorithm< Gaudi::Algorithm >.

Reimplemented in AthAnalysisAlgorithm.

Definition at line 75 of file AthHistogramAlgorithm.cxx.

76{
77 // ---- stolen from GaudiKernel/Algorithm::sysInitialize -------
78 // Bypass the initialization if the algorithm
79 // has already been initialized.
80 if ( Gaudi::StateMachine::INITIALIZED <= FSMState() ) return StatusCode::SUCCESS;
81
82 // Set the Algorithm's properties
83 bindPropertiesTo( serviceLocator()->getOptsSvc() );
84
85 // Bypass the initialization if the algorithm is disabled.
86 // Need to do this after bindPropertiesTo.
87 if ( !isEnabled( ) ) return StatusCode::SUCCESS;
88
89 // ---- stolen from GaudiKernel/Algorithm::sysInitialize ------- END ---
90
91
92 // Get the THistSvc
93 ATH_CHECK ( histSvc().retrieve() );
94
95 // Configure the underlying AthHistogramming helper
96 ATH_CHECK ( AthHistogramming::configAthHistogramming( m_histSvc,
97 m_prefix, m_rootDir,
98 m_histNamePrefix, m_histNamePostfix,
99 m_histTitlePrefix, m_histTitlePostfix ) );
100
101 // Print some setup information into the log file
102 ATH_MSG_DEBUG ("Initializing {}...", name());
103 ATH_MSG_DEBUG (" using THistService = " << m_histSvc );
104 ATH_MSG_DEBUG (" using RootStreamName = {}", m_prefix );
105 ATH_MSG_DEBUG (" using RootDirName = {}", m_rootDir );
106 ATH_MSG_DEBUG (" using HistNamePrefix = {}", m_histNamePrefix );
107 ATH_MSG_DEBUG (" using HistNamePostfix = {}", m_histNamePostfix );
108 ATH_MSG_DEBUG (" using HistTitlePrefix = {}", m_histTitlePrefix );
109 ATH_MSG_DEBUG (" using HistTitlePostfix = {}", m_histTitlePostfix );
110
111
112 // re-direct to base class...
113 return AthAlgorithm::sysInitialize();
114}
AthCommonAlgorithm< Gaudi::Algorithm >::sysInitialize
virtual StatusCode sysInitialize() override
Definition AthCommonAlgorithm.cxx:71
AthHistogramAlgorithm::histSvc
const ServiceHandle< ITHistSvc > & histSvc() const
The standard THistSvc (for writing histograms and TTrees and more to a root file) Returns (kind of) a...
Definition AthHistogramAlgorithm.h:113
AthHistogramming::configAthHistogramming
StatusCode configAthHistogramming(const ServiceHandle< ITHistSvc > &histSvc, const std::string &prefix, const std::string &rootDir, const std::string &histNamePrefix, const std::string &histNamePostfix, const std::string &histTitlePrefix, const std::string &histTitlePostfix)
To be called to fill the internal configuration.
Definition AthHistogramming.cxx:64

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::sysStart ( )
overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

◆ tree()

TTree * AthHistogramming::tree ( std::string_view treeName,
std::string_view tDir = "",
std::string_view stream = "" )
protectedinherited

Simplify the retrieval of registered TTrees.

Definition at line 333 of file AthHistogramming.cxx.

334{
335 // Build a 32 bit hash out of the name
336 const hash_t treeHash = this->hash(treeName);
337 // See if this entry exists in the map
338 TreeMap_t::const_iterator it = m_treeMap.find( treeHash );
339 if ( it == m_treeMap.end() ) // It doesn't exist!
340 { // Let's see into the THistSvc if somebody else has registered the TTree...
341 // Massage the final string to book things
342 std::string bookingString = buildBookingString( treeName, tDir, stream);
343
344 TTree* treePointer(NULL);
345 if ( !((histSvc()->getTree(bookingString, treePointer)).isSuccess()) )
346 {
347 m_msg << MSG::WARNING
348 << "Problem retrieving the TTree with name " << treeName
349 << " in " << m_name << "... it doesn't exist, neither in the cached map nor in the THistSvc!"
350 << " Will return an NULL pointer... you have to handle it correctly!" << endmsg;
351 return NULL;
352 }
353 // If we get to here, we actually found the TTree in the THistSvc.
354 // So let's add it to the local cache map and return its pointer
355 m_treeMap.insert( m_treeMap.end(), std::pair< const hash_t, TTree* >( treeHash, treePointer ) );
356 return treePointer;
357 }
358
359 // Return the pointer to the TTree that we got from the local cache map
360 return it->second;
361}
AthenaInternal::getTree
std::pair< StatusCode, TTree * > getTree(ITHistSvc &svc, const std::string &name)
Definition AthenaPythonDict.h:67

◆ updateVHKA()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::updateVHKA ( Gaudi::Details::PropertyBase & )
inlineinherited

Definition at line 298 of file AthCommonDataStore.h.

298 {
299 for (auto &a : m_vhka) {
300 std::vector<SG::VarHandleKey*> keys = a->keys();
301 for (auto k : keys) {
302 k->setOwner(this);
303 }
304 }
305 }

Member Data Documentation

◆ m_detMgr

const MuonGMR4::MuonDetectorManager* MuonValR4::MuonHoughTransformTester::m_detMgr {nullptr}
private

Definition at line 316 of file MuonHoughTransformTester.h.

316{nullptr};

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_detStore
privateinherited

Pointer to StoreGate (detector store by default).

Definition at line 381 of file AthCommonDataStore.h.

◆ m_effMap

EffMap_t AthHistogramming::m_effMap
privateinherited

The map of histogram names to their pointers.

Definition at line 202 of file AthHistogramming.h.

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_evtStore
privateinherited

Pointer to StoreGate (event store by default).

Definition at line 378 of file AthCommonDataStore.h.

◆ m_extendedExtraObjects

DataObjIDColl AthCommonAlgorithm< Gaudi::Algorithm >::m_extendedExtraObjects
privateinherited

Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.

Empty if no symlinks were found.

Definition at line 108 of file AthCommonAlgorithm.h.

◆ m_geoCtxKey

ActsTrk::GeoContextReadKey_t MuonValR4::MuonHoughTransformTester::m_geoCtxKey {this, "AlignmentKey", "ActsAlignment", "cond handle key"}
private

Tracking geometry context.

Definition at line 112 of file MuonHoughTransformTester.h.

112{this, "AlignmentKey", "ActsAlignment", "cond handle key"};

◆ m_graphMap

GraphMap_t AthHistogramming::m_graphMap
privateinherited

The map of TGraph names to their pointers.

Definition at line 216 of file AthHistogramming.h.

◆ m_histMap

HistMap_t AthHistogramming::m_histMap
privateinherited

The map of histogram names to their pointers.

Definition at line 195 of file AthHistogramming.h.

◆ m_histNamePostfix

std::string AthHistogramAlgorithm::m_histNamePostfix
privateinherited

The postfix for the histogram THx name.

Definition at line 97 of file AthHistogramAlgorithm.h.

◆ m_histNamePrefix

std::string AthHistogramAlgorithm::m_histNamePrefix
privateinherited

The prefix for the histogram THx name.

Definition at line 94 of file AthHistogramAlgorithm.h.

◆ m_histSvc

ServiceHandle<ITHistSvc> AthHistogramAlgorithm::m_histSvc
privateinherited

Default constructor: AthHistogramAlgorithm();.

a handle on the Hist/TTree registration service

Definition at line 83 of file AthHistogramAlgorithm.h.

◆ m_histTitlePostfix

std::string AthHistogramAlgorithm::m_histTitlePostfix
privateinherited

The postfix for the histogram THx title.

Definition at line 103 of file AthHistogramAlgorithm.h.

◆ m_histTitlePrefix

std::string AthHistogramAlgorithm::m_histTitlePrefix
privateinherited

The prefix for the histogram THx title.

Definition at line 100 of file AthHistogramAlgorithm.h.

◆ m_idHelperSvc

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

Definition at line 114 of file MuonHoughTransformTester.h.

114{this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"};

◆ m_isMC

Gaudi::Property<bool> MuonValR4::MuonHoughTransformTester::m_isMC {this, "isMC", false, "Toggle whether the job is ran on MC or not"}
private

Definition at line 117 of file MuonHoughTransformTester.h.

117{this, "isMC", false, "Toggle whether the job is ran on MC or not"};

◆ m_msg

MsgStream AthHistogramming::m_msg
privateinherited

Cached Message Stream.

Definition at line 242 of file AthHistogramming.h.

◆ m_name

std::string AthHistogramming::m_name
privateinherited

Instance name.

Definition at line 239 of file AthHistogramming.h.

◆ m_out_bucketEnd

MuonVal::ScalarBranch<float>& MuonValR4::MuonHoughTransformTester::m_out_bucketEnd {m_tree.newScalar<float>("bucket_end", -1)}
private

Definition at line 132 of file MuonHoughTransformTester.h.

132{m_tree.newScalar<float>("bucket_end", -1)};

◆ m_out_bucketEtaHitGap

MuonVal::ScalarBranch<float>& MuonValR4::MuonHoughTransformTester::m_out_bucketEtaHitGap {m_tree.newScalar<float>("bucket_etaHitGap", 0.)}
private

Definition at line 133 of file MuonHoughTransformTester.h.

133{m_tree.newScalar<float>("bucket_etaHitGap", 0.)};

◆ m_out_bucketStart

MuonVal::ScalarBranch<float>& MuonValR4::MuonHoughTransformTester::m_out_bucketStart {m_tree.newScalar<float>("bucket_start", 1)}
private

Definition at line 131 of file MuonHoughTransformTester.h.

131{m_tree.newScalar<float>("bucket_start", 1)};

◆ m_out_chamberIndex

MuonVal::ScalarBranch<int>& MuonValR4::MuonHoughTransformTester::m_out_chamberIndex {m_tree.newScalar<int>("chamberIndex")}
private

====== Common block: Filled for all entries ===========

chamber index field

Definition at line 125 of file MuonHoughTransformTester.h.

125{m_tree.newScalar<int>("chamberIndex")};

◆ m_out_gen_beamSpotR

MuonVal::ScalarBranch<float>& MuonValR4::MuonHoughTransformTester::m_out_gen_beamSpotR {m_tree.newScalar<float>("gen_beamSpotR", -1.f)}
private

Beamspot approach.

Definition at line 180 of file MuonHoughTransformTester.h.

180{m_tree.newScalar<float>("gen_beamSpotR", -1.f)};

◆ m_out_gen_beamSpotZ

MuonVal::ScalarBranch<float>& MuonValR4::MuonHoughTransformTester::m_out_gen_beamSpotZ {m_tree.newScalar<float>("gen_beamSpotZ", -1.f)}
private

Definition at line 181 of file MuonHoughTransformTester.h.

181{m_tree.newScalar<float>("gen_beamSpotZ", -1.f)};

◆ m_out_gen_deflection

MuonVal::ScalarBranch<float>& MuonValR4::MuonHoughTransformTester::m_out_gen_deflection {m_tree.newScalar<float>("gen_dThetaPosDir", -1.f)}
private

Definition at line 182 of file MuonHoughTransformTester.h.

182{m_tree.newScalar<float>("gen_dThetaPosDir", -1.f)};

◆ m_out_gen_deflectionEta

MuonVal::ScalarBranch<float>& MuonValR4::MuonHoughTransformTester::m_out_gen_deflectionEta {m_tree.newScalar<float>("gen_dEtaPosDir", -3.f)}
private

Definition at line 183 of file MuonHoughTransformTester.h.

183{m_tree.newScalar<float>("gen_dEtaPosDir", -3.f)};

◆ m_out_gen_Eta

MuonVal::ScalarBranch<float>& MuonValR4::MuonHoughTransformTester::m_out_gen_Eta {m_tree.newScalar<float>("gen_eta",-10.)}
private

global particle properties

Definition at line 162 of file MuonHoughTransformTester.h.

162{m_tree.newScalar<float>("gen_eta",-10.)};

◆ m_out_gen_maxYhit

MuonVal::ScalarBranch<float>& MuonValR4::MuonHoughTransformTester::m_out_gen_maxYhit {m_tree.newScalar<float>("gen_hitMaxY0", -1.0)}
private

Definition at line 196 of file MuonHoughTransformTester.h.

196{m_tree.newScalar<float>("gen_hitMaxY0", -1.0)};

◆ m_out_gen_minYhit

MuonVal::ScalarBranch<float>& MuonValR4::MuonHoughTransformTester::m_out_gen_minYhit {m_tree.newScalar<float>("gen_hitMinY0", 1.0)}
private

Definition at line 195 of file MuonHoughTransformTester.h.

195{m_tree.newScalar<float>("gen_hitMinY0", 1.0)};

◆ m_out_gen_nMmEtaHits

MuonVal::ScalarBranch<unsigned short>& MuonValR4::MuonHoughTransformTester::m_out_gen_nMmEtaHits {m_tree.newScalar<unsigned short>("gen_nMmEtaHits",0)}
private

Definition at line 189 of file MuonHoughTransformTester.h.

189{m_tree.newScalar<unsigned short>("gen_nMmEtaHits",0)};

◆ m_out_gen_nMmStereoHits

MuonVal::ScalarBranch<unsigned short>& MuonValR4::MuonHoughTransformTester::m_out_gen_nMmStereoHits {m_tree.newScalar<unsigned short>("gen_nMmStereoHits",0)}
private

Definition at line 190 of file MuonHoughTransformTester.h.

190{m_tree.newScalar<unsigned short>("gen_nMmStereoHits",0)};

◆ m_out_gen_nPrecHits

MuonVal::ScalarBranch<unsigned short>& MuonValR4::MuonHoughTransformTester::m_out_gen_nPrecHits {m_tree.newScalar<unsigned short>("gen_nPrecHits",0)}
private

Truth - hit count summary.

Definition at line 186 of file MuonHoughTransformTester.h.

186{m_tree.newScalar<unsigned short>("gen_nPrecHits",0)};

◆ m_out_gen_nStgcHits

MuonVal::ScalarBranch<unsigned short>& MuonValR4::MuonHoughTransformTester::m_out_gen_nStgcHits {m_tree.newScalar<unsigned short>("gen_nStgcHits",0)}
private

Definition at line 191 of file MuonHoughTransformTester.h.

191{m_tree.newScalar<unsigned short>("gen_nStgcHits",0)};

◆ m_out_gen_nTrigEtaHits

MuonVal::ScalarBranch<unsigned short>& MuonValR4::MuonHoughTransformTester::m_out_gen_nTrigEtaHits {m_tree.newScalar<unsigned short>("gen_nTrigEtaHits",0)}
private

Definition at line 187 of file MuonHoughTransformTester.h.

187{m_tree.newScalar<unsigned short>("gen_nTrigEtaHits",0)};

◆ m_out_gen_nTrigPhiHits

MuonVal::ScalarBranch<unsigned short>& MuonValR4::MuonHoughTransformTester::m_out_gen_nTrigPhiHits {m_tree.newScalar<unsigned short>("gen_nTrigPhiHits",0)}
private

Definition at line 188 of file MuonHoughTransformTester.h.

188{m_tree.newScalar<unsigned short>("gen_nTrigPhiHits",0)};

◆ m_out_gen_Phi

MuonVal::ScalarBranch<float>& MuonValR4::MuonHoughTransformTester::m_out_gen_Phi {m_tree.newScalar<float>("gen_phi",-10.)}
private

Definition at line 163 of file MuonHoughTransformTester.h.

163{m_tree.newScalar<float>("gen_phi",-10.)};

◆ m_out_gen_Pt

MuonVal::ScalarBranch<float>& MuonValR4::MuonHoughTransformTester::m_out_gen_Pt {m_tree.newScalar<float>("gen_pt",-10.)}
private

Definition at line 164 of file MuonHoughTransformTester.h.

164{m_tree.newScalar<float>("gen_pt",-10.)};

◆ m_out_gen_Q

MuonVal::ScalarBranch<short>& MuonValR4::MuonHoughTransformTester::m_out_gen_Q {m_tree.newScalar<short>("gen_q", 0)}
private

Definition at line 165 of file MuonHoughTransformTester.h.

165{m_tree.newScalar<short>("gen_q", 0)};

◆ m_out_gen_tanalpha

MuonVal::ScalarBranch<float>& MuonValR4::MuonHoughTransformTester::m_out_gen_tanalpha {m_tree.newScalar<float>("gen_tanAlpha", 0.0)}
private

Definition at line 171 of file MuonHoughTransformTester.h.

171{m_tree.newScalar<float>("gen_tanAlpha", 0.0)};

◆ m_out_gen_tanbeta

MuonVal::ScalarBranch<float>& MuonValR4::MuonHoughTransformTester::m_out_gen_tanbeta {m_tree.newScalar<float>("gen_tanBeta", 0.0)}
private

Definition at line 170 of file MuonHoughTransformTester.h.

170{m_tree.newScalar<float>("gen_tanBeta", 0.0)};

◆ m_out_gen_time

MuonVal::ScalarBranch<float>& MuonValR4::MuonHoughTransformTester::m_out_gen_time {m_tree.newScalar<float>("gen_time", 0.0)}
private

Definition at line 173 of file MuonHoughTransformTester.h.

173{m_tree.newScalar<float>("gen_time", 0.0)};

◆ m_out_gen_truthBeta

MuonVal::ScalarBranch<float>& MuonValR4::MuonHoughTransformTester::m_out_gen_truthBeta {m_tree.newScalar<float>("gen_beta", -1)}
private

Definition at line 166 of file MuonHoughTransformTester.h.

166{m_tree.newScalar<float>("gen_beta", -1)};

◆ m_out_gen_truthOrigin

MuonVal::ScalarBranch<int>& MuonValR4::MuonHoughTransformTester::m_out_gen_truthOrigin {m_tree.newScalar<int>("gen_origin", -1)}
private

MC truth calssifier definition.

Definition at line 175 of file MuonHoughTransformTester.h.

175{m_tree.newScalar<int>("gen_origin", -1)};

◆ m_out_gen_truthPdgId

MuonVal::ScalarBranch<int>& MuonValR4::MuonHoughTransformTester::m_out_gen_truthPdgId {m_tree.newScalar<int>("gen_pdgId", 0)}
private

Definition at line 177 of file MuonHoughTransformTester.h.

177{m_tree.newScalar<int>("gen_pdgId", 0)};

◆ m_out_gen_truthType

MuonVal::ScalarBranch<int>& MuonValR4::MuonHoughTransformTester::m_out_gen_truthType {m_tree.newScalar<int>("gen_type", -1)}
private

Definition at line 176 of file MuonHoughTransformTester.h.

176{m_tree.newScalar<int>("gen_type", -1)};

◆ m_out_gen_x0

MuonVal::ScalarBranch<float>& MuonValR4::MuonHoughTransformTester::m_out_gen_x0 {m_tree.newScalar<float>("gen_x0", 0.0)}
private

Definition at line 172 of file MuonHoughTransformTester.h.

172{m_tree.newScalar<float>("gen_x0", 0.0)};

◆ m_out_gen_y0

MuonVal::ScalarBranch<float>& MuonValR4::MuonHoughTransformTester::m_out_gen_y0 {m_tree.newScalar<float>("gen_y0", 0.0)}
private

Truth - segment parameters.

Definition at line 169 of file MuonHoughTransformTester.h.

169{m_tree.newScalar<float>("gen_y0", 0.0)};

◆ m_out_hasTruth

MuonVal::ScalarBranch<char>& MuonValR4::MuonHoughTransformTester::m_out_hasTruth {m_tree.newScalar<char>("gen_exists",false)}
private

======= Truth block: Filled if we have a truth match. ============

existence of a truth match

Definition at line 159 of file MuonHoughTransformTester.h.

159{m_tree.newScalar<char>("gen_exists",false)};

◆ m_out_nPhiSpacePoints

MuonVal::ScalarBranch<unsigned char>& MuonValR4::MuonHoughTransformTester::m_out_nPhiSpacePoints {m_tree.newScalar<unsigned char>("bucket_nPhiMeass",0)}
private

Number of phi hits in the bucket.

Definition at line 147 of file MuonHoughTransformTester.h.

147{m_tree.newScalar<unsigned char>("bucket_nPhiMeass",0)};

◆ m_out_nPrecSpacePoints

MuonVal::ScalarBranch<unsigned char>& MuonValR4::MuonHoughTransformTester::m_out_nPrecSpacePoints {m_tree.newScalar<unsigned char>("bucket_nPrecMeas",0)}
private

Number of precision hits in the bucket.

Definition at line 145 of file MuonHoughTransformTester.h.

145{m_tree.newScalar<unsigned char>("bucket_nPrecMeas",0)};

◆ m_out_nSpacePoints

MuonVal::ScalarBranch<unsigned char>& MuonValR4::MuonHoughTransformTester::m_out_nSpacePoints {m_tree.newScalar<unsigned char>("bucket_nHits",0)}
private

Number of all space points in the bucket.

Definition at line 143 of file MuonHoughTransformTester.h.

143{m_tree.newScalar<unsigned char>("bucket_nHits",0)};

◆ m_out_nTruePhiSpacePoints

MuonVal::ScalarBranch<unsigned char>& MuonValR4::MuonHoughTransformTester::m_out_nTruePhiSpacePoints {m_tree.newScalar<unsigned char>("bucket_nTruePhiMeass",0)}
private

Number of phi hits in the bucket.

Definition at line 154 of file MuonHoughTransformTester.h.

154{m_tree.newScalar<unsigned char>("bucket_nTruePhiMeass",0)};

◆ m_out_nTruePrecSpacePoints

MuonVal::ScalarBranch<unsigned char>& MuonValR4::MuonHoughTransformTester::m_out_nTruePrecSpacePoints {m_tree.newScalar<unsigned char>("bucket_nTruePrecMeas",0)}
private

Number of precision hits in the bucket.

Definition at line 152 of file MuonHoughTransformTester.h.

152{m_tree.newScalar<unsigned char>("bucket_nTruePrecMeas",0)};

◆ m_out_nTrueSpacePoints

MuonVal::ScalarBranch<unsigned char>& MuonValR4::MuonHoughTransformTester::m_out_nTrueSpacePoints {m_tree.newScalar<unsigned char>("bucket_nTrueMeas",0)}
private

Number of all space points in the bucket.

Definition at line 150 of file MuonHoughTransformTester.h.

150{m_tree.newScalar<unsigned char>("bucket_nTrueMeas",0)};

◆ m_out_seed_hasPhiExtension

MuonVal::VectorBranch<unsigned short>& MuonValR4::MuonHoughTransformTester::m_out_seed_hasPhiExtension {m_tree.newVector<unsigned short>("seed_hasPhiExtension", false)}
private

Definition at line 204 of file MuonHoughTransformTester.h.

204{m_tree.newVector<unsigned short>("seed_hasPhiExtension", false)};

◆ m_out_seed_ledToSegment

MuonVal::VectorBranch<unsigned char>& MuonValR4::MuonHoughTransformTester::m_out_seed_ledToSegment {m_tree.newVector<unsigned char>("seed_becameSegment",false)}
private

Definition at line 237 of file MuonHoughTransformTester.h.

237{m_tree.newVector<unsigned char>("seed_becameSegment",false)};

◆ m_out_seed_maxYhit

MuonVal::VectorBranch<float>& MuonValR4::MuonHoughTransformTester::m_out_seed_maxYhit {m_tree.newVector<float>("seed_hitMaxY0", -1.0)}
private

Definition at line 213 of file MuonHoughTransformTester.h.

213{m_tree.newVector<float>("seed_hitMaxY0", -1.0)};

◆ m_out_seed_minYhit

MuonVal::VectorBranch<float>& MuonValR4::MuonHoughTransformTester::m_out_seed_minYhit {m_tree.newVector<float>("seed_hitMinY0", 1.0)}
private

Definition at line 212 of file MuonHoughTransformTester.h.

212{m_tree.newVector<float>("seed_hitMinY0", 1.0)};

◆ m_out_seed_n

MuonVal::ScalarBranch<unsigned>& MuonValR4::MuonHoughTransformTester::m_out_seed_n {m_tree.newScalar<unsigned>("nSeeds", 0)}
private

========== Seed block: Filled when we have one or multiple seeds ============= seed count

Definition at line 200 of file MuonHoughTransformTester.h.

200{m_tree.newScalar<unsigned>("nSeeds", 0)};

◆ m_out_seed_nEtaHits

MuonVal::VectorBranch<unsigned short>& MuonValR4::MuonHoughTransformTester::m_out_seed_nEtaHits {m_tree.newVector<unsigned short>("seed_nTrigEtaHits", 0)}
private

Definition at line 216 of file MuonHoughTransformTester.h.

216{m_tree.newVector<unsigned short>("seed_nTrigEtaHits", 0)};

◆ m_out_seed_nMmEtaHits

MuonVal::VectorBranch<unsigned short>& MuonValR4::MuonHoughTransformTester::m_out_seed_nMmEtaHits {m_tree.newVector<unsigned short>("seed_nMmEtaHits", 0)}
private

Definition at line 223 of file MuonHoughTransformTester.h.

223{m_tree.newVector<unsigned short>("seed_nMmEtaHits", 0)};

◆ m_out_seed_nMmStereoHits

MuonVal::VectorBranch<unsigned short>& MuonValR4::MuonHoughTransformTester::m_out_seed_nMmStereoHits {m_tree.newVector<unsigned short>("seed_nMmStereoHits", 0)}
private

Definition at line 224 of file MuonHoughTransformTester.h.

224{m_tree.newVector<unsigned short>("seed_nMmStereoHits", 0)};

◆ m_out_seed_nPhiHits

MuonVal::VectorBranch<unsigned short>& MuonValR4::MuonHoughTransformTester::m_out_seed_nPhiHits {m_tree.newVector<unsigned short>("seed_nTrigPhiHits", 0)}
private

Definition at line 217 of file MuonHoughTransformTester.h.

217{m_tree.newVector<unsigned short>("seed_nTrigPhiHits", 0)};

◆ m_out_seed_nPrecHits

MuonVal::VectorBranch<unsigned short>& MuonValR4::MuonHoughTransformTester::m_out_seed_nPrecHits {m_tree.newVector<unsigned short>("seed_nPrecHits", 0)}
private

Definition at line 215 of file MuonHoughTransformTester.h.

215{m_tree.newVector<unsigned short>("seed_nPrecHits", 0)};

◆ m_out_seed_nsTgcPadHits

MuonVal::VectorBranch<unsigned short>& MuonValR4::MuonHoughTransformTester::m_out_seed_nsTgcPadHits {m_tree.newVector<unsigned short>("seed_nStgcPadHits", 0)}
private

Definition at line 231 of file MuonHoughTransformTester.h.

231{m_tree.newVector<unsigned short>("seed_nStgcPadHits", 0)};

◆ m_out_seed_nsTgcStripHits

MuonVal::VectorBranch<unsigned short>& MuonValR4::MuonHoughTransformTester::m_out_seed_nsTgcStripHits {m_tree.newVector<unsigned short>("seed_nStgcStripHits", 0)}
private

Definition at line 229 of file MuonHoughTransformTester.h.

229{m_tree.newVector<unsigned short>("seed_nStgcStripHits", 0)};

◆ m_out_seed_nsTgcWireHits

MuonVal::VectorBranch<unsigned short>& MuonValR4::MuonHoughTransformTester::m_out_seed_nsTgcWireHits {m_tree.newVector<unsigned short>("seed_nStgcWireHits", 0)}
private

Definition at line 230 of file MuonHoughTransformTester.h.

230{m_tree.newVector<unsigned short>("seed_nStgcWireHits", 0)};

◆ m_out_seed_nTrueEtaHits

MuonVal::VectorBranch<unsigned short>& MuonValR4::MuonHoughTransformTester::m_out_seed_nTrueEtaHits {m_tree.newVector<unsigned short>("seed_nTrueTrigEtaHits", 0)}
private

Definition at line 220 of file MuonHoughTransformTester.h.

220{m_tree.newVector<unsigned short>("seed_nTrueTrigEtaHits", 0)};

◆ m_out_seed_nTrueMmEtaHits

MuonVal::VectorBranch<unsigned short>& MuonValR4::MuonHoughTransformTester::m_out_seed_nTrueMmEtaHits {m_tree.newVector<unsigned short>("seed_nMmTrueEtaHits", 0)}
private

Definition at line 226 of file MuonHoughTransformTester.h.

226{m_tree.newVector<unsigned short>("seed_nMmTrueEtaHits", 0)};

◆ m_out_seed_nTrueMmStereoHits

MuonVal::VectorBranch<unsigned short>& MuonValR4::MuonHoughTransformTester::m_out_seed_nTrueMmStereoHits {m_tree.newVector<unsigned short>("seed_nMmTrueStereoHits", 0)}
private

Definition at line 227 of file MuonHoughTransformTester.h.

227{m_tree.newVector<unsigned short>("seed_nMmTrueStereoHits", 0)};

◆ m_out_seed_nTruePhiHits

MuonVal::VectorBranch<unsigned short>& MuonValR4::MuonHoughTransformTester::m_out_seed_nTruePhiHits {m_tree.newVector<unsigned short>("seed_nTrueTrigPhiHits", 0)}
private

Definition at line 221 of file MuonHoughTransformTester.h.

221{m_tree.newVector<unsigned short>("seed_nTrueTrigPhiHits", 0)};

◆ m_out_seed_nTruePrecHits

MuonVal::VectorBranch<unsigned short>& MuonValR4::MuonHoughTransformTester::m_out_seed_nTruePrecHits {m_tree.newVector<unsigned short>("seed_nTruePrecHits", 0)}
private

Definition at line 219 of file MuonHoughTransformTester.h.

219{m_tree.newVector<unsigned short>("seed_nTruePrecHits", 0)};

◆ m_out_seed_nTruesTgcPadHits

MuonVal::VectorBranch<unsigned short>& MuonValR4::MuonHoughTransformTester::m_out_seed_nTruesTgcPadHits {m_tree.newVector<unsigned short>("seed_nStgcTruePadHits", 0)}
private

Definition at line 235 of file MuonHoughTransformTester.h.

235{m_tree.newVector<unsigned short>("seed_nStgcTruePadHits", 0)};

◆ m_out_seed_nTruesTgcStripHits

MuonVal::VectorBranch<unsigned short>& MuonValR4::MuonHoughTransformTester::m_out_seed_nTruesTgcStripHits {m_tree.newVector<unsigned short>("seed_nStgcTrueStripHits", 0)}
private

Definition at line 233 of file MuonHoughTransformTester.h.

233{m_tree.newVector<unsigned short>("seed_nStgcTrueStripHits", 0)};

◆ m_out_seed_nTruesTgcWireHits

MuonVal::VectorBranch<unsigned short>& MuonValR4::MuonHoughTransformTester::m_out_seed_nTruesTgcWireHits {m_tree.newVector<unsigned short>("seed_nStgcTrueWireHits", 0)}
private

Definition at line 234 of file MuonHoughTransformTester.h.

234{m_tree.newVector<unsigned short>("seed_nStgcTrueWireHits", 0)};

◆ m_out_seed_tanalpha

MuonVal::VectorBranch<float>& MuonValR4::MuonHoughTransformTester::m_out_seed_tanalpha {m_tree.newVector<float>("seed_tanAlpha", 0.0)}
private

Definition at line 209 of file MuonHoughTransformTester.h.

209{m_tree.newVector<float>("seed_tanAlpha", 0.0)};

◆ m_out_seed_tanbeta

MuonVal::VectorBranch<float>& MuonValR4::MuonHoughTransformTester::m_out_seed_tanbeta {m_tree.newVector<float>("seed_tanBeta", 0.0)}
private

Definition at line 208 of file MuonHoughTransformTester.h.

208{m_tree.newVector<float>("seed_tanBeta", 0.0)};

◆ m_out_seed_x0

MuonVal::VectorBranch<float>& MuonValR4::MuonHoughTransformTester::m_out_seed_x0 {m_tree.newVector<float>("seed_x0", 0.0)}
private

Definition at line 207 of file MuonHoughTransformTester.h.

207{m_tree.newVector<float>("seed_x0", 0.0)};

◆ m_out_seed_y0

MuonVal::VectorBranch<float>& MuonValR4::MuonHoughTransformTester::m_out_seed_y0 {m_tree.newVector<float>("seed_y0", 0.0)}
private

Definition at line 206 of file MuonHoughTransformTester.h.

206{m_tree.newVector<float>("seed_y0", 0.0)};

◆ m_out_segment_chi2

MuonVal::VectorBranch<float>& MuonValR4::MuonHoughTransformTester::m_out_segment_chi2 {m_tree.newVector<float>("segment_chi2", -1.)}
private

Definition at line 246 of file MuonHoughTransformTester.h.

246{m_tree.newVector<float>("segment_chi2", -1.)};

◆ m_out_segment_fitIter

MuonVal::VectorBranch<uint16_t>& MuonValR4::MuonHoughTransformTester::m_out_segment_fitIter {m_tree.newVector<uint16_t>("segment_nIter", 0)}
private

Definition at line 249 of file MuonHoughTransformTester.h.

249{m_tree.newVector<uint16_t>("segment_nIter", 0)};
xAOD::uint16_t
setWord1 uint16_t
Definition eFexEMRoI_v1.cxx:93

◆ m_out_segment_hasTimeFit

MuonVal::VectorBranch<char>& MuonValR4::MuonHoughTransformTester::m_out_segment_hasTimeFit {m_tree.newVector<char>("segment_hasTimeFit", false)}
private

Definition at line 248 of file MuonHoughTransformTester.h.

248{m_tree.newVector<char>("segment_hasTimeFit", false)};

◆ m_out_segment_maxTrueYhit

MuonVal::VectorBranch<float>& MuonValR4::MuonHoughTransformTester::m_out_segment_maxTrueYhit {m_tree.newVector<float>("segment_trueHitMaxY0", -1.0)}
private

Definition at line 311 of file MuonHoughTransformTester.h.

311{m_tree.newVector<float>("segment_trueHitMaxY0", -1.0)};

◆ m_out_segment_maxYhit

MuonVal::VectorBranch<float>& MuonValR4::MuonHoughTransformTester::m_out_segment_maxYhit {m_tree.newVector<float>("segment_hitMinY0", -1.0)}
private

Definition at line 309 of file MuonHoughTransformTester.h.

309{m_tree.newVector<float>("segment_hitMinY0", -1.0)};

◆ m_out_segment_minTrueYhit

MuonVal::VectorBranch<float>& MuonValR4::MuonHoughTransformTester::m_out_segment_minTrueYhit {m_tree.newVector<float>("segment_trueHitMinY0", 1.0)}
private

Definition at line 310 of file MuonHoughTransformTester.h.

310{m_tree.newVector<float>("segment_trueHitMinY0", 1.0)};

◆ m_out_segment_minYhit

MuonVal::VectorBranch<float>& MuonValR4::MuonHoughTransformTester::m_out_segment_minYhit {m_tree.newVector<float>("segment_hitMinY0", 1.0)}
private

Definition at line 308 of file MuonHoughTransformTester.h.

308{m_tree.newVector<float>("segment_hitMinY0", 1.0)};

◆ m_out_segment_n

MuonVal::ScalarBranch<unsigned>& MuonValR4::MuonHoughTransformTester::m_out_segment_n {m_tree.newScalar<unsigned>("nSegments", 0)}
private

========== Segment block: Filled when we have one or multiple segments =============

Definition at line 242 of file MuonHoughTransformTester.h.

242{m_tree.newScalar<unsigned>("nSegments", 0)};

◆ m_out_segment_nDoF

MuonVal::VectorBranch<uint16_t>& MuonValR4::MuonHoughTransformTester::m_out_segment_nDoF {m_tree.newVector<uint16_t>("segment_nDoF", 0)}
private

Definition at line 247 of file MuonHoughTransformTester.h.

247{m_tree.newVector<uint16_t>("segment_nDoF", 0)};

◆ m_out_segment_nMmEtaHits

MuonVal::VectorBranch<unsigned short>& MuonValR4::MuonHoughTransformTester::m_out_segment_nMmEtaHits {m_tree.newVector<unsigned short>("segment_nMmEtaHits", 0)}
private

NSW hit counters.

Definition at line 283 of file MuonHoughTransformTester.h.

283{m_tree.newVector<unsigned short>("segment_nMmEtaHits", 0)};

◆ m_out_segment_nMmEtaOutliers

MuonVal::VectorBranch<unsigned short>& MuonValR4::MuonHoughTransformTester::m_out_segment_nMmEtaOutliers {m_tree.newVector<unsigned short>("segment_nMmEtaOutliers", 0)}
private

Definition at line 295 of file MuonHoughTransformTester.h.

295{m_tree.newVector<unsigned short>("segment_nMmEtaOutliers", 0)};

◆ m_out_segment_nMmStereoHits

MuonVal::VectorBranch<unsigned short>& MuonValR4::MuonHoughTransformTester::m_out_segment_nMmStereoHits {m_tree.newVector<unsigned short>("segment_nMmStereoHits", 0)}
private

Definition at line 284 of file MuonHoughTransformTester.h.

284{m_tree.newVector<unsigned short>("segment_nMmStereoHits", 0)};

◆ m_out_segment_nMmStereoOutliers

MuonVal::VectorBranch<unsigned short>& MuonValR4::MuonHoughTransformTester::m_out_segment_nMmStereoOutliers {m_tree.newVector<unsigned short>("segment_nMmStereoOutliers", 0)}
private

Definition at line 296 of file MuonHoughTransformTester.h.

296{m_tree.newVector<unsigned short>("segment_nMmStereoOutliers", 0)};

◆ m_out_segment_nMmTrueEtaHits

MuonVal::VectorBranch<unsigned short>& MuonValR4::MuonHoughTransformTester::m_out_segment_nMmTrueEtaHits {m_tree.newVector<unsigned short>("segment_nMmTrueEtaHits", 0)}
private

Definition at line 289 of file MuonHoughTransformTester.h.

289{m_tree.newVector<unsigned short>("segment_nMmTrueEtaHits", 0)};

◆ m_out_segment_nMmTrueEtaOutliers

MuonVal::VectorBranch<unsigned short>& MuonValR4::MuonHoughTransformTester::m_out_segment_nMmTrueEtaOutliers {m_tree.newVector<unsigned short>("segment_nMmTrueEtaOutliers", 0)}
private

Definition at line 301 of file MuonHoughTransformTester.h.

301{m_tree.newVector<unsigned short>("segment_nMmTrueEtaOutliers", 0)};

◆ m_out_segment_nMmTrueStereoHits

MuonVal::VectorBranch<unsigned short>& MuonValR4::MuonHoughTransformTester::m_out_segment_nMmTrueStereoHits {m_tree.newVector<unsigned short>("segment_nMmTrueStereoHits", 0)}
private

Definition at line 290 of file MuonHoughTransformTester.h.

290{m_tree.newVector<unsigned short>("segment_nMmTrueStereoHits", 0)};

◆ m_out_segment_nMmTrueStereoOutliers

MuonVal::VectorBranch<unsigned short>& MuonValR4::MuonHoughTransformTester::m_out_segment_nMmTrueStereoOutliers {m_tree.newVector<unsigned short>("segment_nMmTrueStereoOutliers", 0)}
private

Definition at line 302 of file MuonHoughTransformTester.h.

302{m_tree.newVector<unsigned short>("segment_nMmTrueStereoOutliers", 0)};

◆ m_out_segment_nPrecHits

MuonVal::VectorBranch<unsigned short>& MuonValR4::MuonHoughTransformTester::m_out_segment_nPrecHits {m_tree.newVector<unsigned short>("segment_nPrecHits", 0)}
private

Hit counts on segment.

Definition at line 262 of file MuonHoughTransformTester.h.

262{m_tree.newVector<unsigned short>("segment_nPrecHits", 0)};

◆ m_out_segment_nPrecHoles

MuonVal::VectorBranch<unsigned short>& MuonValR4::MuonHoughTransformTester::m_out_segment_nPrecHoles {m_tree.newVector<unsigned short>("segment_nPrecHoles", 0)}
private

Definition at line 270 of file MuonHoughTransformTester.h.

270{m_tree.newVector<unsigned short>("segment_nPrecHoles", 0)};

◆ m_out_segment_nPrecOutliers

MuonVal::VectorBranch<unsigned short>& MuonValR4::MuonHoughTransformTester::m_out_segment_nPrecOutliers {m_tree.newVector<unsigned short>("segment_nPrecOutliers", 0)}
private

Definition at line 266 of file MuonHoughTransformTester.h.

266{m_tree.newVector<unsigned short>("segment_nPrecOutliers", 0)};

◆ m_out_segment_nSTgcPadHits

MuonVal::VectorBranch<unsigned short>& MuonValR4::MuonHoughTransformTester::m_out_segment_nSTgcPadHits {m_tree.newVector<unsigned short>("segment_nStgcPadHits", 0)}
private

Definition at line 287 of file MuonHoughTransformTester.h.

287{m_tree.newVector<unsigned short>("segment_nStgcPadHits", 0)};

◆ m_out_segment_nSTgcPadOutliers

MuonVal::VectorBranch<unsigned short>& MuonValR4::MuonHoughTransformTester::m_out_segment_nSTgcPadOutliers {m_tree.newVector<unsigned short>("segment_nStgcPadOutliers", 0)}
private

Definition at line 299 of file MuonHoughTransformTester.h.

299{m_tree.newVector<unsigned short>("segment_nStgcPadOutliers", 0)};

◆ m_out_segment_nSTgcStripHits

MuonVal::VectorBranch<unsigned short>& MuonValR4::MuonHoughTransformTester::m_out_segment_nSTgcStripHits {m_tree.newVector<unsigned short>("segment_nStgcStripHits", 0)}
private

Definition at line 285 of file MuonHoughTransformTester.h.

285{m_tree.newVector<unsigned short>("segment_nStgcStripHits", 0)};

◆ m_out_segment_nSTgcStripOutliers

MuonVal::VectorBranch<unsigned short>& MuonValR4::MuonHoughTransformTester::m_out_segment_nSTgcStripOutliers {m_tree.newVector<unsigned short>("segment_nStgcStripOutliers", 0)}
private

Definition at line 297 of file MuonHoughTransformTester.h.

297{m_tree.newVector<unsigned short>("segment_nStgcStripOutliers", 0)};

◆ m_out_segment_nSTgcTruePadHits

MuonVal::VectorBranch<unsigned short>& MuonValR4::MuonHoughTransformTester::m_out_segment_nSTgcTruePadHits {m_tree.newVector<unsigned short>("segment_nStgcTruePadHits", 0)}
private

Definition at line 293 of file MuonHoughTransformTester.h.

293{m_tree.newVector<unsigned short>("segment_nStgcTruePadHits", 0)};

◆ m_out_segment_nSTgcTruePadOutliers

MuonVal::VectorBranch<unsigned short>& MuonValR4::MuonHoughTransformTester::m_out_segment_nSTgcTruePadOutliers {m_tree.newVector<unsigned short>("segment_nStgcTruePadOutliers", 0)}
private

Definition at line 305 of file MuonHoughTransformTester.h.

305{m_tree.newVector<unsigned short>("segment_nStgcTruePadOutliers", 0)};

◆ m_out_segment_nSTgcTrueStripHits

MuonVal::VectorBranch<unsigned short>& MuonValR4::MuonHoughTransformTester::m_out_segment_nSTgcTrueStripHits {m_tree.newVector<unsigned short>("segment_nStgcTrueStripHits", 0)}
private

Definition at line 291 of file MuonHoughTransformTester.h.

291{m_tree.newVector<unsigned short>("segment_nStgcTrueStripHits", 0)};

◆ m_out_segment_nSTgcTrueStripOutliers

MuonVal::VectorBranch<unsigned short>& MuonValR4::MuonHoughTransformTester::m_out_segment_nSTgcTrueStripOutliers {m_tree.newVector<unsigned short>("segment_nStgcTrueStripOutliers", 0)}
private

Definition at line 303 of file MuonHoughTransformTester.h.

303{m_tree.newVector<unsigned short>("segment_nStgcTrueStripOutliers", 0)};

◆ m_out_segment_nSTgcTrueWireHits

MuonVal::VectorBranch<unsigned short>& MuonValR4::MuonHoughTransformTester::m_out_segment_nSTgcTrueWireHits {m_tree.newVector<unsigned short>("segment_nStgcTrueWireHits", 0)}
private

Definition at line 292 of file MuonHoughTransformTester.h.

292{m_tree.newVector<unsigned short>("segment_nStgcTrueWireHits", 0)};

◆ m_out_segment_nSTgcTrueWireOutliers

MuonVal::VectorBranch<unsigned short>& MuonValR4::MuonHoughTransformTester::m_out_segment_nSTgcTrueWireOutliers {m_tree.newVector<unsigned short>("segment_nStgcTrueWireOutliers", 0)}
private

Definition at line 304 of file MuonHoughTransformTester.h.

304{m_tree.newVector<unsigned short>("segment_nStgcTrueWireOutliers", 0)};

◆ m_out_segment_nSTgcWireHits

MuonVal::VectorBranch<unsigned short>& MuonValR4::MuonHoughTransformTester::m_out_segment_nSTgcWireHits {m_tree.newVector<unsigned short>("segment_nStgcWireHits", 0)}
private

Definition at line 286 of file MuonHoughTransformTester.h.

286{m_tree.newVector<unsigned short>("segment_nStgcWireHits", 0)};

◆ m_out_segment_nSTgcWireOutliers

MuonVal::VectorBranch<unsigned short>& MuonValR4::MuonHoughTransformTester::m_out_segment_nSTgcWireOutliers {m_tree.newVector<unsigned short>("segment_nStgcWireOutliers", 0)}
private

Definition at line 298 of file MuonHoughTransformTester.h.

298{m_tree.newVector<unsigned short>("segment_nStgcWireOutliers", 0)};

◆ m_out_segment_nTrigEtaHits

MuonVal::VectorBranch<unsigned short>& MuonValR4::MuonHoughTransformTester::m_out_segment_nTrigEtaHits {m_tree.newVector<unsigned short>("segment_nTrigEtaHits", 0)}
private

Definition at line 263 of file MuonHoughTransformTester.h.

263{m_tree.newVector<unsigned short>("segment_nTrigEtaHits", 0)};

◆ m_out_segment_nTrigEtaHoles

MuonVal::VectorBranch<unsigned short>& MuonValR4::MuonHoughTransformTester::m_out_segment_nTrigEtaHoles {m_tree.newVector<unsigned short>("segment_nTrigEtaHoles", 0)}
private

Definition at line 271 of file MuonHoughTransformTester.h.

271{m_tree.newVector<unsigned short>("segment_nTrigEtaHoles", 0)};

◆ m_out_segment_nTrigEtaOutliers

MuonVal::VectorBranch<unsigned short>& MuonValR4::MuonHoughTransformTester::m_out_segment_nTrigEtaOutliers {m_tree.newVector<unsigned short>("segment_nTrigEtaOutliers", 0)}
private

Definition at line 267 of file MuonHoughTransformTester.h.

267{m_tree.newVector<unsigned short>("segment_nTrigEtaOutliers", 0)};

◆ m_out_segment_nTrigPhiHits

MuonVal::VectorBranch<unsigned short>& MuonValR4::MuonHoughTransformTester::m_out_segment_nTrigPhiHits {m_tree.newVector<unsigned short>("segment_nTrigPhiHits", 0)}
private

Definition at line 264 of file MuonHoughTransformTester.h.

264{m_tree.newVector<unsigned short>("segment_nTrigPhiHits", 0)};

◆ m_out_segment_nTrigPhiHoles

MuonVal::VectorBranch<unsigned short>& MuonValR4::MuonHoughTransformTester::m_out_segment_nTrigPhiHoles {m_tree.newVector<unsigned short>("segment_nTrigPhiHoles", 0)}
private

Definition at line 272 of file MuonHoughTransformTester.h.

272{m_tree.newVector<unsigned short>("segment_nTrigPhiHoles", 0)};

◆ m_out_segment_nTrigPhiOutliers

MuonVal::VectorBranch<unsigned short>& MuonValR4::MuonHoughTransformTester::m_out_segment_nTrigPhiOutliers {m_tree.newVector<unsigned short>("segment_nTrigPhiOutliers", 0)}
private

Definition at line 268 of file MuonHoughTransformTester.h.

268{m_tree.newVector<unsigned short>("segment_nTrigPhiOutliers", 0)};

◆ m_out_segment_nTruePrecHits

MuonVal::VectorBranch<unsigned short>& MuonValR4::MuonHoughTransformTester::m_out_segment_nTruePrecHits {m_tree.newVector<unsigned short>("segment_nTruePrecHits", 0)}
private

True matched hit counters.

Definition at line 274 of file MuonHoughTransformTester.h.

274{m_tree.newVector<unsigned short>("segment_nTruePrecHits", 0)};

◆ m_out_segment_nTruePrecOutliers

MuonVal::VectorBranch<unsigned short>& MuonValR4::MuonHoughTransformTester::m_out_segment_nTruePrecOutliers {m_tree.newVector<unsigned short>("segment_nTruePrecOutliers", 0)}
private

Definition at line 278 of file MuonHoughTransformTester.h.

278{m_tree.newVector<unsigned short>("segment_nTruePrecOutliers", 0)};

◆ m_out_segment_nTrueTrigEtaHits

MuonVal::VectorBranch<unsigned short>& MuonValR4::MuonHoughTransformTester::m_out_segment_nTrueTrigEtaHits {m_tree.newVector<unsigned short>("segment_nTrueTrigEtaHits", 0)}
private

Definition at line 275 of file MuonHoughTransformTester.h.

275{m_tree.newVector<unsigned short>("segment_nTrueTrigEtaHits", 0)};

◆ m_out_segment_nTrueTrigEtaOutliers

MuonVal::VectorBranch<unsigned short>& MuonValR4::MuonHoughTransformTester::m_out_segment_nTrueTrigEtaOutliers {m_tree.newVector<unsigned short>("segment_nTrueTrigEtaOutliers", 0)}
private

Definition at line 279 of file MuonHoughTransformTester.h.

279{m_tree.newVector<unsigned short>("segment_nTrueTrigEtaOutliers", 0)};

◆ m_out_segment_nTrueTrigPhiHits

MuonVal::VectorBranch<unsigned short>& MuonValR4::MuonHoughTransformTester::m_out_segment_nTrueTrigPhiHits {m_tree.newVector<unsigned short>("segment_nTrueTrigPhiHits", 0)}
private

Definition at line 276 of file MuonHoughTransformTester.h.

276{m_tree.newVector<unsigned short>("segment_nTrueTrigPhiHits", 0)};

◆ m_out_segment_nTrueTrigPhiOutliers

MuonVal::VectorBranch<unsigned short>& MuonValR4::MuonHoughTransformTester::m_out_segment_nTrueTrigPhiOutliers {m_tree.newVector<unsigned short>("segment_nTrueTrigPhiOutliers", 0)}
private

Definition at line 280 of file MuonHoughTransformTester.h.

280{m_tree.newVector<unsigned short>("segment_nTrueTrigPhiOutliers", 0)};

◆ m_out_segment_phi

MuonVal::VectorBranch<float>& MuonValR4::MuonHoughTransformTester::m_out_segment_phi {m_tree.newVector<float>("segment_phi", 0.)}
private

Definition at line 255 of file MuonHoughTransformTester.h.

255{m_tree.newVector<float>("segment_phi", 0.)};

◆ m_out_segment_theta

MuonVal::VectorBranch<float>& MuonValR4::MuonHoughTransformTester::m_out_segment_theta {m_tree.newVector<float>("segment_theta", 0.)}
private

Definition at line 254 of file MuonHoughTransformTester.h.

254{m_tree.newVector<float>("segment_theta", 0.)};

◆ m_out_segment_time

MuonVal::VectorBranch<float>& MuonValR4::MuonHoughTransformTester::m_out_segment_time {m_tree.newVector<float>("segment_t0", 0.)}
private

Definition at line 256 of file MuonHoughTransformTester.h.

256{m_tree.newVector<float>("segment_t0", 0.)};

◆ m_out_segment_x0

MuonVal::VectorBranch<float>& MuonValR4::MuonHoughTransformTester::m_out_segment_x0 {m_tree.newVector<float>("segment_x0", 0.)}
private

Definition at line 253 of file MuonHoughTransformTester.h.

253{m_tree.newVector<float>("segment_x0", 0.)};

◆ m_out_segment_y0

MuonVal::VectorBranch<float>& MuonValR4::MuonHoughTransformTester::m_out_segment_y0 {m_tree.newVector<float>("segment_y0", 0.)}
private

Definition at line 252 of file MuonHoughTransformTester.h.

252{m_tree.newVector<float>("segment_y0", 0.)};

◆ m_out_stationPhi

MuonVal::ScalarBranch<int>& MuonValR4::MuonHoughTransformTester::m_out_stationPhi {m_tree.newScalar<int>("stationPhi")}
private

phi index of the station

Definition at line 129 of file MuonHoughTransformTester.h.

129{m_tree.newScalar<int>("stationPhi")};

◆ m_out_stationSide

MuonVal::ScalarBranch<short>& MuonValR4::MuonHoughTransformTester::m_out_stationSide {m_tree.newScalar<short>("stationSide")}
private

+1 for A-, -1 of C-side

Definition at line 127 of file MuonHoughTransformTester.h.

127{m_tree.newScalar<short>("stationSide")};

◆ m_patternSeedKeys

SG::ReadHandleKeyArray<MuonR4::SegmentSeedContainer> MuonValR4::MuonHoughTransformTester::m_patternSeedKeys {this, "SegmentSeedKeys", {"MuonHoughStationSegmentSeeds"}}
private

List of the two segment seed containers from which the segments are buiit (Complets the pattern finding step).

Definition at line 108 of file MuonHoughTransformTester.h.

108{this, "SegmentSeedKeys", {"MuonHoughStationSegmentSeeds"}};

◆ m_prefix

std::string AthHistogramAlgorithm::m_prefix
privateinherited

Name of the ROOT output stream (file).

Definition at line 88 of file AthHistogramAlgorithm.h.

◆ m_recoSegKey

SG::ReadHandleKey<xAOD::MuonSegmentContainer> MuonValR4::MuonHoughTransformTester::m_recoSegKey {this, "SegmentKey", "MsSegments"}
private

Key to the xAOD::MuonSegment container.

Definition at line 104 of file MuonHoughTransformTester.h.

104{this, "SegmentKey", "MsSegments"};

◆ m_recoSegLinks

Gaudi::Property<std::vector<std::string> > MuonValR4::MuonHoughTransformTester::m_recoSegLinks {this, "RecoSegLinks", {"truthSegmentLink", "truthParticleLink"}}
private

name of the truth link decorations for the reco segment container

Definition at line 106 of file MuonHoughTransformTester.h.

106{this, "RecoSegLinks", {"truthSegmentLink", "truthParticleLink"}};

◆ m_rootDir

std::string AthHistogramAlgorithm::m_rootDir
privateinherited

Name of the ROOT directory.

Definition at line 91 of file AthHistogramAlgorithm.h.

◆ m_segmentCov

std::array<FloatVecBrPtr_t, Acts::sumUpToN(Acts::toUnderlying(MuonR4::SegmentFit::ParamDefs::nPars))> MuonValR4::MuonHoughTransformTester::m_segmentCov {}
private

Definition at line 259 of file MuonHoughTransformTester.h.

259{};

◆ m_spKeys

SG::ReadHandleKeyArray<MuonR4::SpacePointContainer> MuonValR4::MuonHoughTransformTester::m_spKeys {this, "SpacePointKeys", {"MuonSpacePoints"}}
private

List of the space point containers in the event legacy + NSW containers.

Definition at line 110 of file MuonHoughTransformTester.h.

110{this, "SpacePointKeys", {"MuonSpacePoints"}};

◆ m_spMatchedToPattern

MuonVal::MatrixBranch<unsigned char>& MuonValR4::MuonHoughTransformTester::m_spMatchedToPattern {m_tree.newMatrix<unsigned char>("seed_matchedSpacPoins")}
private

Branch indicating which space points in the tree are associated to the i-th pattern.

Definition at line 138 of file MuonHoughTransformTester.h.

138{m_tree.newMatrix<unsigned char>("seed_matchedSpacPoins")};

◆ m_spMatchedToSegment

MuonVal::MatrixBranch<unsigned char>& MuonValR4::MuonHoughTransformTester::m_spMatchedToSegment {m_tree.newMatrix<unsigned char>("segment_matchedSpacePoints")}
private

Branch indicating which space points in the tree are associated to the i-th segment.

Definition at line 140 of file MuonHoughTransformTester.h.

140{m_tree.newMatrix<unsigned char>("segment_matchedSpacePoints")};

◆ m_spTester

std::shared_ptr<SpacePointTesterModule> MuonValR4::MuonHoughTransformTester::m_spTester {}
private

Branch dumping all the space points from the difference buckets.

Definition at line 136 of file MuonHoughTransformTester.h.

136{};

◆ m_streamName

std::string AthHistogramming::m_streamName
privateinherited

Name of the ROOT output stream (file).

Definition at line 220 of file AthHistogramming.h.

◆ m_tree

MuonVal::MuonTesterTree MuonValR4::MuonHoughTransformTester::m_tree {"MuonEtaHoughTest","MuonEtaHoughTransformTest"}
private

Definition at line 95 of file MuonHoughTransformTester.h.

95{"MuonEtaHoughTest","MuonEtaHoughTransformTest"};

◆ m_treeMap

TreeMap_t AthHistogramming::m_treeMap
privateinherited

The map of TTree names to their pointers.

Definition at line 209 of file AthHistogramming.h.

◆ m_truthLinks

Gaudi::Property<std::vector<std::string> > MuonValR4::MuonHoughTransformTester::m_truthLinks {this, "TruthSegLinks", {"simHitLinks", "truthParticleLink"}}
private

Name of the decorations for the truth segment.

Definition at line 102 of file MuonHoughTransformTester.h.

102{this, "TruthSegLinks", {"simHitLinks", "truthParticleLink"}};

◆ m_truthSegLinkKeys

SG::ReadDecorHandleKeyArray<xAOD::MuonSegmentContainer> MuonValR4::MuonHoughTransformTester::m_truthSegLinkKeys {this, "TruthSegLinkKeys", {}}
private

Declare the dependencies on the decorations.

Definition at line 100 of file MuonHoughTransformTester.h.

100{this, "TruthSegLinkKeys", {}};

◆ m_truthSegmentKey

SG::ReadHandleKey<xAOD::MuonSegmentContainer> MuonValR4::MuonHoughTransformTester::m_truthSegmentKey {this, "TruthSegmentKey","MuonTruthSegments", "truth segment container"}
private

Key to the truth segment.

Definition at line 98 of file MuonHoughTransformTester.h.

98{this, "TruthSegmentKey","MuonTruthSegments", "truth segment container"};

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_varHandleArraysDeclared
privateinherited

Definition at line 387 of file AthCommonDataStore.h.

◆ m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_vhka
privateinherited

Definition at line 386 of file AthCommonDataStore.h.

◆ m_visionTool

ToolHandle<MuonValR4::IPatternVisualizationTool> MuonValR4::MuonHoughTransformTester::m_visionTool {this, "VisualizationTool", ""}
private

Pattern visualization tool.

Definition at line 314 of file MuonHoughTransformTester.h.

314{this, "VisualizationTool", ""};

◆ m_writeSpacePoints

Gaudi::Property<bool> MuonValR4::MuonHoughTransformTester::m_writeSpacePoints
private
Initial value:
{this, "writeSpacePoints", false,
"Toggle whether the particular space poitns shall be written"}

Definition at line 119 of file MuonHoughTransformTester.h.

119 {this, "writeSpacePoints", false,
120 "Toggle whether the particular space poitns shall be written"};
The documentation for this class was generated from the following files:
Generated on for ATLAS Offline Software by doxygen 1.17.0