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 by the derived classes to fill the internal configuration.
TH1 * bookGetPointer (const TH1 &hist, const std::string &tDir="", const std::string &stream="")
 Simplify the booking and registering (into THistSvc) of histograms.
TH1 * bookGetPointer (TH1 *hist, const std::string &tDir="", const std::string &stream="")
 Simplify the booking and registering (into THistSvc) of histograms.
TH1 * bookGetPointer (TH1 &histRef, std::string tDir="", std::string stream="")
 Simplify the booking and registering (into THistSvc) of histograms.
TTree * bookGetPointer (const TTree &treeRef, std::string tDir="", std::string stream="")
 Simplify the booking and registering (into THistSvc) of TTrees.
TGraph * bookGetPointer (const TGraph &graphRef, std::string tDir="", std::string stream="")
 Simplify the booking and registering (into THistSvc) of TGraphs.
TEfficiency * bookGetPointer (const TEfficiency &eff, const std::string &tDir="", const std::string &stream="")
 Simplify the booking and registering (into THistSvc) of TEfficiency.
TEfficiency * bookGetPointer (TEfficiency *eff, const std::string &tDir="", const std::string &stream="")
 Simplify the booking and registering (into THistSvc) of TEfficiency.
TEfficiency * bookGetPointer (TEfficiency &effRef, std::string tDir="", std::string stream="")
 Simplify the booking and registering (into THistSvc) of TEfficiency.
StatusCode book (const TH1 &hist, const std::string &tDir="", const std::string &stream="")
 Simplify the booking and registering (into THistSvc) of histograms.
StatusCode book (TH1 *hist, const std::string &tDir="", const std::string &stream="")
 Simplify the booking and registering (into THistSvc) of histograms.
StatusCode book (TH1 &histRef, const std::string &tDir="", const std::string &stream="")
 Simplify the booking and registering (into THistSvc) of histograms.
StatusCode book (const TTree &treeRef, const std::string &tDir="", const std::string &stream="")
 Simplify the booking and registering (into THistSvc) of TTrees.
StatusCode book (const TGraph &graphRef, const std::string &tDir="", const std::string &stream="")
 Simplify the booking and registering (into THistSvc) of TGraphs.
StatusCode book (const TEfficiency &eff, const std::string &tDir="", const std::string &stream="")
 Simplify the booking and registering (into THistSvc) of TEfficiency.
StatusCode book (TEfficiency *eff, const std::string &tDir="", const std::string &stream="")
 Simplify the booking and registering (into THistSvc) of TEfficiency.
StatusCode book (TEfficiency &effRef, const std::string &tDir="", const std::string &stream="")
 Simplify the booking and registering (into THistSvc) of TEfficiency.
TH1 * hist (const std::string &histName, const std::string &tDir="", const std::string &stream="")
 Simplify the retrieval of registered histograms of any type.
TH2 * hist2d (const std::string &histName, const std::string &tDir="", const std::string &stream="")
 Simplify the retrieval of registered 2-d histograms.
TH3 * hist3d (const std::string &histName, const std::string &tDir="", const std::string &stream="")
 Simplify the retrieval of registered 3-d histograms.
TTree * tree (const std::string &treeName, const std::string &tDir="", const std::string &stream="")
 Simplify the retrieval of registered TTrees.
TGraph * graph (const std::string &graphName, const std::string &tDir="", const std::string &stream="")
 Simplify the retrieval of registered TGraphs.
TEfficiency * efficiency (const std::string &effName, const std::string &tDir="", const std::string &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>
void buildBookingString (std::string &bookingString, std::string &histName, std::string &tDir, std::string &stream, bool usePrefixPostfix=false)
 Method to build individual booking string.
void myReplace (std::string &str, const std::string &oldStr, const std::string &newStr)
 Helper method to replace sub-string.
hash_t hash (const std::string &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", "MuonSegmentsFromR4"}
 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_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)}
MuonVal::ScalarBranch< int > & m_out_gen_truthType {m_tree.newScalar<int>("gen_type", -1)}
MuonVal::ScalarBranch< float > & m_out_gen_truthBeta {m_tree.newScalar<float>("gen_beta", -1)}
MuonVal::ScalarBranch< int > & m_out_gen_truthPdgId {m_tree.newScalar<int>("gen_pdgId", 0)}
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 207 of file AthHistogramming.h.

◆ FloatVecBrPtr_t

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

Definition at line 251 of file MuonHoughTransformTester.h.

◆ GraphMap_t

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

Typedef for convenience.

Definition at line 221 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 200 of file AthHistogramming.h.

◆ StoreGateSvc_t

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

Definition at line 388 of file AthCommonDataStore.h.

◆ TreeMap_t

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

Typedef for convenience.

Definition at line 214 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:26

◆ book() [1/8]

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

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

Definition at line 337 of file AthHistogramming.h.

338{
339 // We need to create a non-const clone
340 TEfficiency* effClone = dynamic_cast< TEfficiency* >( eff.Clone() );
341 if ( !effClone ) {
342 m_msg << MSG::ERROR << "Couldn't create a TEfficiency clone" << endmsg;
343 return StatusCode::FAILURE;
344 }
345 return this->book( *effClone, tDir, stream );
346}
endmsg
#define endmsg
Definition AnalysisConfig_Ntuple.cxx:63
AthHistogramming::book
StatusCode book(const TH1 &hist, const std::string &tDir="", const std::string &stream="")
Simplify the booking and registering (into THistSvc) of histograms.
Definition AthHistogramming.h:305
AthHistogramming::m_msg
MsgStream m_msg
Cached Message Stream.
Definition AthHistogramming.h:250
dqt_zlumi_alleff_HIST.eff
int eff
Definition dqt_zlumi_alleff_HIST.py:113

◆ book() [2/8]

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

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

◆ book() [3/8]

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

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

Definition at line 305 of file AthHistogramming.h.

306{
307 // We need to create a non-const clone
308 TH1* histClone = dynamic_cast< TH1* >( hist.Clone() );
309 if ( !histClone ) {
310 m_msg << MSG::ERROR << "Couldn't create a TH1 clone" << endmsg;
311 return StatusCode::FAILURE;
312 }
313 return this->book( *histClone, tDir, stream );
314}
AthHistogramming::hist
TH1 * hist(const std::string &histName, const std::string &tDir="", const std::string &stream="")
Simplify the retrieval of registered histograms of any type.
Definition AthHistogramming.cxx:164

◆ book() [4/8]

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

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

Definition at line 405 of file AthHistogramming.h.

406{
407 // Call the other Book method and see if it returns a valid pointer
408 TTree* treePointer = this->bookGetPointer( treeRef, tDir, stream );
409 if ( treePointer )
410 {
411 return StatusCode::SUCCESS;
412 }
413 else
414 {
415 return StatusCode::FAILURE;
416 }
417}
AthHistogramming::bookGetPointer
TH1 * bookGetPointer(const TH1 &hist, const std::string &tDir="", const std::string &stream="")
Simplify the booking and registering (into THistSvc) of histograms.
Definition AthHistogramming.h:262

◆ book() [5/8]

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

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

Definition at line 358 of file AthHistogramming.h.

359{
360 // Call the other Book method and see if it returns a valid pointer
361 TEfficiency* effPointer = this->bookGetPointer( effRef, tDir, stream );
362 if ( !effPointer ) {
363 m_msg << MSG::ERROR << "Couldn't book a TEfficiency" << endmsg;
364 return StatusCode::FAILURE;
365 }
366 return StatusCode::SUCCESS;
367}

◆ book() [6/8]

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

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

Definition at line 348 of file AthHistogramming.h.

349{
350 if ( !eff ) {
351 m_msg << MSG::ERROR << "Got a zero pointer to a TEfficiency" << endmsg;
352 return StatusCode::FAILURE;
353 }
354 return this->book( *eff, tDir, stream );
355}

◆ book() [7/8]

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

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

Definition at line 326 of file AthHistogramming.h.

327{
328 // Call the other Book method and see if it returns a valid pointer
329 TH1* histPointer = this->bookGetPointer( histRef, tDir, stream );
330 if ( !histPointer ) {
331 m_msg << MSG::ERROR << "Couldn't book a TH1" << endmsg;
332 return StatusCode::FAILURE;
333 }
334 return StatusCode::SUCCESS;
335}

◆ book() [8/8]

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

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

Definition at line 316 of file AthHistogramming.h.

317{
318 if ( !hist ) {
319 m_msg << MSG::ERROR << "Got a zero pointer to a TH1" << endmsg;
320 return StatusCode::FAILURE;
321 }
322 return this->book( *hist, tDir, stream );
323}

◆ bookGetPointer() [1/8]

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

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

Definition at line 283 of file AthHistogramming.h.

284{
285 // We need to create a non-const clone
286 TEfficiency* histClone = dynamic_cast< TEfficiency* >( hist.Clone() );
287 if ( !histClone ) {
288 m_msg << MSG::ERROR << "Couldn't create a TEfficiency clone in bookGetPointer" << endmsg;
289 return 0;
290 }
291 return this->bookGetPointer( *histClone, tDir, stream );
292
293}

◆ bookGetPointer() [2/8]

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

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

Definition at line 388 of file AthHistogramming.cxx.

389{
390 // Get a pointer
391 const TGraph* graphPointer = &graphRef;
392
393 // Check that we got a valid pointer
394 if ( !graphPointer )
395 {
396 m_msg << MSG::WARNING
397 << "We got an invalid TGraph pointer in the BookGetPointer(TGraph*) method of the class" << m_name
398 << "!" << endmsg;
399 return NULL;
400 }
401
402 // Modify the name and title according to the prefixes of this classes instance
403 std::string graphName = graphPointer->GetName();
404 const std::string graphTitle = graphPointer->GetTitle();
405
406 // Check if the hash for this graphName already exists, i.e., if we have a hash collision
407 const hash_t graphHash = this->hash(graphName);
408 GraphMap_t::const_iterator it = m_graphMap.find( graphHash );
409 if ( it != m_graphMap.end() ) // It does exist!
410 {
411 m_msg << MSG::WARNING
412 << "Detected a hash collision. The hash for the TGraph with name=" << graphName
413 << " already exists and points to a TGraph with name=" << it->second->GetName()
414 << " NOT going to book the new histogram and returning a NULL pointer!" << endmsg;
415 return NULL;
416 }
417
418 // Create a clone that has the new name
419 TGraph* graphClone = dynamic_cast< TGraph* >( graphPointer->Clone((m_histNamePrefix+graphName+m_histNamePostfix).c_str()) );
420 if( !graphClone )
421 {
422 m_msg << MSG::WARNING
423 << "We couldn't clone the TGraph in the BookGetPointer(TGraph&) method of the class" << m_name
424 << "!" << endmsg;
425 return NULL;
426 }
427 graphClone->SetTitle ((m_histTitlePrefix+graphTitle+m_histTitlePostfix).c_str());
428
429 // Massage the final string to book things
430 std::string bookingString("");
431 this->buildBookingString( bookingString, graphName, tDir, stream );
432
433 // Register the TGraph into the THistSvc
434 if ( !((histSvc()->regGraph(bookingString, graphClone)).isSuccess()) )
435 {
436 m_msg << MSG::WARNING
437 << "Problem registering TGraph with name " << graphName
438 << ", title " << graphTitle
439 << " in " << m_name << "!" << endmsg;
440 return NULL;
441 }
442
443 // Also register it in the local map of string to pointer
444 m_graphMap.insert( m_graphMap.end(), std::pair< const hash_t, TGraph* >( graphHash, graphClone ) );
445
446 return graphClone;
447}
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:423
AthHistogramming::m_histNamePostfix
std::string m_histNamePostfix
The postfix for the histogram THx name.
Definition AthHistogramming.h:237
AthHistogramming::hash
hash_t hash(const std::string &histName) const
Method to calculate a 32-bit hash from a string.
Definition AthHistogramming.h:430
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:243
AthHistogramming::m_histTitlePrefix
std::string m_histTitlePrefix
The prefix for the histogram THx title.
Definition AthHistogramming.h:240
AthHistogramming::m_name
std::string m_name
Instance name.
Definition AthHistogramming.h:247
AthHistogramming::buildBookingString
void buildBookingString(std::string &bookingString, std::string &histName, std::string &tDir, std::string &stream, bool usePrefixPostfix=false)
Method to build individual booking string.
Definition AthHistogramming.cxx:521
AthHistogramming::m_histNamePrefix
std::string m_histNamePrefix
The prefix for the histogram THx name.
Definition AthHistogramming.h:234
AthHistogramming::m_graphMap
GraphMap_t m_graphMap
The map of TGraph names to their pointers.
Definition AthHistogramming.h:224

◆ bookGetPointer() [3/8]

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

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

Definition at line 262 of file AthHistogramming.h.

263{
264 // We need to create a non-const clone
265 TH1* histClone = dynamic_cast< TH1* >( hist.Clone() );
266 if ( !histClone ) {
267 m_msg << MSG::ERROR << "Couldn't create a TH1 clone in bookGetPointer" << endmsg;
268 return 0;
269 }
270 return this->bookGetPointer( *histClone, tDir, stream );
271
272}

◆ bookGetPointer() [4/8]

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

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

Definition at line 273 of file AthHistogramming.cxx.

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

◆ bookGetPointer() [5/8]

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

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

Definition at line 123 of file AthHistogramming.cxx.

124{
125 std::string effName(effRef.GetName());
126 const std::string effTitle(effRef.GetTitle());
127 std::string bookingString;
128 this->buildBookingString(bookingString, effName, tDir, stream);
129 const std::string finalEffName = m_histNamePrefix + effName + m_histNamePostfix;
130 effRef.SetTitle((m_histTitlePrefix + effTitle + m_histTitlePostfix).c_str());
131 effRef.SetName(finalEffName.c_str());
132
133 const hash_t effHash = this->hash(effName);
134 EffMap_t::const_iterator it = m_effMap.find(effHash);
135 if (it != m_effMap.end()) {
136 m_msg << MSG::WARNING
137 << "Detected a hash collision. The hash for the TEfficiency with name=" << effName
138 << " already exists and points to a TEfficiency with name=" << it->second->GetName()
139 << " NOT going to book the new TEfficiency and returning a NULL pointer!" << endmsg;
140 return nullptr;
141 }
142
143 if (!histSvc()->regEfficiency(bookingString, &effRef).isSuccess()) {
144 m_msg << MSG::WARNING
145 << "Problem registering TEfficiency with name " << effName
146 << ", name prefix " << m_histNamePrefix
147 << ", title " << effTitle
148 << ", title prefix " << m_histTitlePrefix
149 << ", and title postfix " << m_histTitlePostfix
150 << " in " << m_name << "!" << endmsg;
151 return nullptr;
152 }
153
154 m_effMap.insert(m_effMap.end(), std::pair<const hash_t, TEfficiency*>(effHash, &effRef));
155
156 return &effRef;
157}
AthHistogramming::m_effMap
EffMap_t m_effMap
The map of histogram names to their pointers.
Definition AthHistogramming.h:210

◆ bookGetPointer() [6/8]

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

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

Definition at line 295 of file AthHistogramming.h.

296{
297 if ( !hist ) {
298 m_msg << MSG::ERROR << "Got a zero pointer to a TEfficiency in bookGetPointer" << endmsg;
299 return 0;
300 }
301 return this->bookGetPointer( *hist, tDir, stream );
302}

◆ bookGetPointer() [7/8]

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

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

Definition at line 83 of file AthHistogramming.cxx.

84{
85 std::string histName(histRef.GetName());
86 const std::string histTitle(histRef.GetTitle());
87 std::string bookingString;
88
89 this->buildBookingString(bookingString, histName, tDir, stream);
90
91 const std::string finalHistName = m_histNamePrefix + histName + m_histNamePostfix;
92
93 histRef.SetTitle((m_histTitlePrefix + histTitle + m_histTitlePostfix).c_str());
94 histRef.SetName(finalHistName.c_str());
95
96 const hash_t histHash = this->hash(histName);
97 HistMap_t::const_iterator it = m_histMap.find(histHash);
98 if (it != m_histMap.end()) {
99 m_msg << MSG::WARNING
100 << "Detected a hash collision. The hash for the histogram with name=" << histName
101 << " already exists and points to a histogram with name=" << it->second->GetName()
102 << " NOT going to book the new histogram and returning a NULL pointer!" << endmsg;
103 return nullptr;
104 }
105
106 if (!histSvc()->regHist(bookingString, &histRef).isSuccess()) {
107 m_msg << MSG::WARNING
108 << "Problem registering histogram with name " << histName
109 << ", name prefix " << m_histNamePrefix
110 << ", title " << histTitle
111 << ", title prefix " << m_histTitlePrefix
112 << ", and title postfix " << m_histTitlePostfix
113 << " in " << m_name << "!" << endmsg;
114 return nullptr;
115 }
116
117 m_histMap.insert(m_histMap.end(), std::pair<const hash_t, TH1*>(histHash, &histRef));
118
119 return &histRef;
120}
AthHistogramming::m_histMap
HistMap_t m_histMap
The map of histogram names to their pointers.
Definition AthHistogramming.h:203

◆ bookGetPointer() [8/8]

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

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

Definition at line 274 of file AthHistogramming.h.

275{
276 if ( !hist ) {
277 m_msg << MSG::ERROR << "Got a zero pointer to a TH1 in bookGetPointer" << endmsg;
278 return 0;
279 }
280 return this->bookGetPointer( *hist, tDir, stream );
281}

◆ buildBookingString()

void AthHistogramming::buildBookingString ( std::string & bookingString,
std::string & histName,
std::string & tDir,
std::string & stream,
bool usePrefixPostfix = false )
privateinherited

Method to build individual booking string.

Definition at line 521 of file AthHistogramming.cxx.

526{
527 // Massage the final string to book things
528 if(tDir.empty()) tDir = m_rootDir;
529 size_t pos = histName.rfind('/');
530 if(pos != std::string::npos){
531 tDir+='/';
532 tDir.append(histName, 0,pos);
533 histName.erase(0,pos+1);
534 };
535 if(stream.empty()) stream = m_streamName;
536
537 if(usePrefixPostfix){
538 bookingString = "/"+stream+"/"+tDir+"/"+m_histNamePrefix+histName+m_histNamePostfix;
539 } else {
540 bookingString = "/"+stream+"/"+tDir+"/"+histName;
541 }
542 while(bookingString.find("//") != std::string::npos){
543 this->myReplace(bookingString,"//","/");
544 }
545
546 return;
547}
AthHistogramming::m_rootDir
std::string m_rootDir
Name of the ROOT directory.
Definition AthHistogramming.h:231
AthHistogramming::m_streamName
std::string m_streamName
Name of the ROOT output stream (file).
Definition AthHistogramming.h:228
AthHistogramming::myReplace
void myReplace(std::string &str, const std::string &oldStr, const std::string &newStr)
Helper method to replace sub-string.
Definition AthHistogramming.cxx:551

◆ 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 by the derived classes to fill the internal configuration.

Definition at line 51 of file AthHistogramming.cxx.

55{
56 m_histSvc = histSvc;
57 m_streamName = prefix;
58 m_rootDir = rootDir;
59 m_histNamePrefix = histNamePrefix;
60 m_histNamePostfix = histNamePostfix;
61 m_histTitlePrefix = histTitlePrefix;
62 m_histTitlePostfix = histTitlePostfix;
63
64 return StatusCode::SUCCESS;
65}
AthHistogramming::m_histSvc
ServiceHandle< ITHistSvc > m_histSvc
Pointer to the THistSvc (event store by default).
Definition AthHistogramming.h:196

◆ 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 107 of file MuonHoughTransformTester.cxx.

108 {
109 unsigned int same{0};
110 using namespace SegmentFit;
111 const MuonR4::Segment* detailSeg = detailedSegment(recoSeg);
112 const auto[truePos, trueDir] = makeLine(localSegmentPars(truthSeg));
113 const auto[recoPos, recoDir] = makeLine(localSegmentPars(recoSeg));
114 const std::vector<int> truthSigns = SeedingAux::strawSigns(truePos, trueDir, detailSeg->measurements());
115 const std::vector<int> recoSigns = SeedingAux::strawSigns(recoPos, recoDir, detailSeg->measurements());
116 for (unsigned int s = 0 ; s < truthSigns.size(); ++s) {
117 same += (truthSigns[s] != 0) && truthSigns[s] == recoSigns[s];
118 }
119 return same;
120 }
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:29

◆ 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 ( const std::string & effName,
const std::string & tDir = "",
const std::string & stream = "" )
protectedinherited

Simplify the retrieval of registered TEfficiency.

Definition at line 211 of file AthHistogramming.cxx.

212{
213 // Build a 32 bit hash out of the name
214 const hash_t effHash = this->hash(effName);
215
216 // See if this entry exists in the map
217 EffMap_t::const_iterator it = m_effMap.find( effHash );
218 if ( it == m_effMap.end() ) // It doesn't exist!
219 { // Let's see into the THistSvc if somebody else has registered the TEfficiency...
220
221 // Need to copy the strings as we will massage them from here on
222 std::string effNameCopy = effName;
223 std::string tDirCopy = tDir;
224 std::string streamCopy = stream;
225
226 // Massage the final string to book things
227 std::string bookingString("");
228 this->buildBookingString( bookingString, effNameCopy, tDirCopy, streamCopy ,false);
229
230 TEfficiency* effPointer(NULL);
231 if ( !((histSvc()->getEfficiency(bookingString, effPointer)).isSuccess()) )
232 {
233 // Massage the final string to book things
234 std::string bookingString("");
235 this->buildBookingString( bookingString, effNameCopy, tDirCopy, streamCopy, true );
236
237 if ( !((histSvc()->getEfficiency(bookingString, effPointer)).isSuccess()) )
238 {
239 m_msg << MSG::WARNING
240 << "Problem retrieving the TEfficiency with name (including pre- and post-fixes) "
241 << m_histNamePrefix + effNameCopy + m_histNamePostfix
242 << " or with name " << effNameCopy
243 << " in " << m_name << "... it doesn't exist, neither in the cached map nor in the THistSvc!"
244 << " Will return an NULL pointer... you have to handle it correctly!" << endmsg;
245 return NULL;
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 // If we get to here, we actually found the TEfficiency in the THistSvc.
253 // So let's add it to the local cache map and return its pointer
254 m_effMap.insert( m_effMap.end(), std::pair< const hash_t, TEfficiency* >( effHash, effPointer ) );
255 return effPointer;
256 }
257
258 // Return the pointer to the TEfficiency that we got from the local cache map
259 return it->second;
260}
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 243 of file MuonHoughTransformTester.cxx.

243 {
244
245 const ActsTrk::GeometryContext* gctxPtr{nullptr};
246 ATH_CHECK(SG::get(gctxPtr, m_geoCtxKey, ctx));
247 const ActsTrk::GeometryContext& gctx{*gctxPtr};
248
249 ConstDataVector<MuonR4::SegmentSeedContainer> segmentSeeds{SG::VIEW_ELEMENTS};
250 for (const SG::ReadHandleKey<SegmentSeedContainer>& key : m_patternSeedKeys) {
251 const SegmentSeedContainer* readSegmentSeeds{nullptr};
252 ATH_CHECK(SG::get(readSegmentSeeds, key, ctx));
253 segmentSeeds.insert(segmentSeeds.end(), readSegmentSeeds->begin(), readSegmentSeeds->end());
254 }
255
256 const xAOD::MuonSegmentContainer* truthSegments{nullptr};
257 ATH_CHECK(SG::get(truthSegments, m_truthSegmentKey, ctx));
258
259 const xAOD::MuonSegmentContainer* recoSegments{nullptr};
260 ATH_CHECK(SG::get(recoSegments, m_recoSegKey, ctx));
261
262 ATH_MSG_DEBUG("Succesfully retrieved input collections. Seeds: "<<segmentSeeds.size()
263 <<", segments: "<<recoSegments->size()
264 <<", truth segments: "<<(truthSegments? truthSegments->size() : -1)
265 <<".");
266 std::vector<ObjectMatching> objects = matchWithTruth(*segmentSeeds.asDataVector(),
267 *recoSegments, truthSegments);
268 for (const ObjectMatching& obj : objects) {
269 fillChamberInfo(obj.chamber);
270 fillSeedInfo(obj);
271 fillSegmentInfo(obj);
272 if(m_isMC) fillTruthInfo(gctx, obj.truthSegment);
273 ATH_CHECK(m_tree.fill(ctx));
274 }
275 return StatusCode::SUCCESS;
276 }
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:29
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:282
MuonValR4::MuonHoughTransformTester::matchWithTruth
std::vector< ObjectMatching > matchWithTruth(const MuonR4::SegmentSeedContainer &seedContainer, const xAOD::MuonSegmentContainer &segmentContainer, const xAOD::MuonSegmentContainer *truthSegments) const
Definition MuonHoughTransformTester.cxx:122
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:532
MuonValR4::MuonHoughTransformTester::fillChamberInfo
void fillChamberInfo(const MuonGMR4::SpectrometerSector *chamber)
Fill the current chamber info into the output.
Definition MuonHoughTransformTester.cxx:277
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:401
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:282
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 351 of file MuonHoughTransformTester.cxx.

351 {
352 m_out_bucketEnd = bucket.coveredMax();
353 m_out_bucketStart = bucket.coveredMin();
354 m_out_nSpacePoints = bucket.size();
355
356 ATH_MSG_DEBUG("Filling bucket with "<<bucket.size()<<" space points between "<< bucket.coveredMin() <<" and "<< bucket.coveredMax() );
357
358 // 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
359 std::vector<const MuonR4::SpacePoint*> etaHits{};
360 etaHits.reserve(bucket.size());
361 for (const auto& sp : bucket) {
362 if (sp->measuresEta()) {
363 etaHits.push_back(sp.get());
364 }
365 }
366 std::ranges::sort(etaHits, [](const MuonR4::SpacePoint* a,
367 const MuonR4::SpacePoint* b) {
368 return a->localPosition().y() < b->localPosition().y();
369 });
370
371
372 double maxEtaHitGap{-1.f};
373 for (std::size_t i = 1; i < etaHits.size(); ++i) {
374 maxEtaHitGap = std::max(maxEtaHitGap,
375 std::abs(etaHits[i]->localPosition().y()
376 - etaHits[i - 1]->localPosition().y()));
377 }
378
379 m_out_bucketEtaHitGap = maxEtaHitGap;
380
381
382 m_out_nPrecSpacePoints = std::ranges::count_if(bucket, [](const SpacePointBucket::value_type& sp){
383 return isPrecision(*sp);
384 });
385 m_out_nPhiSpacePoints = std::ranges::count_if(bucket, [](const SpacePointBucket::value_type& sp){
386 return sp->measuresPhi();
387 });
388 if (!m_visionTool.isEnabled()){
389 return;
390 }
391 m_out_nTrueSpacePoints = std::ranges::count_if(bucket,[this](const SpacePointBucket::value_type& sp){
392 return m_visionTool->isLabeled(*sp);
393 });
394 m_out_nTruePrecSpacePoints = std::ranges::count_if(bucket,[this](const SpacePointBucket::value_type& sp){
395 return isPrecision(*sp) && m_visionTool->isLabeled(*sp);
396 });
397 m_out_nTruePhiSpacePoints = std::ranges::count_if(bucket,[this](const SpacePointBucket::value_type& sp){
398 return sp->measuresPhi() && m_visionTool->isLabeled(*sp);
399 });
400 }
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:307
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 277 of file MuonHoughTransformTester.cxx.

277 {
278 m_out_chamberIndex = Acts::toUnderlying(msSector->chamberIndex());
279 m_out_stationSide = msSector->side();
280 m_out_stationPhi = msSector->stationPhi();
281 }
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 401 of file MuonHoughTransformTester.cxx.

401 {
402
403 m_out_seed_n = obj.matchedSeeds.size();
404 for (const auto [iseed, seed] : Acts::enumerate(obj.matchedSeeds)){
405 if (iseed ==0) {
406 fillBucketInfo(*seed->parentBucket());
407 }
408 double minYhit = m_out_bucketEnd.getVariable();
409 double maxYhit = m_out_bucketStart.getVariable();
410 for (const SpacePoint* hit : seed->getHitsInMax()){
411 minYhit = std::min(hit->localPosition().y(),minYhit);
412 maxYhit = std::max(hit->localPosition().y(),maxYhit);
413 }
414 m_out_seed_minYhit.push_back(minYhit);
415 m_out_seed_maxYhit.push_back(maxYhit);
416
417 m_out_seed_hasPhiExtension.push_back(seed->hasPhiExtension());
418 m_out_seed_y0.push_back(seed->interceptY());
419 m_out_seed_tanbeta.push_back(seed->tanBeta());
420 if (seed->hasPhiExtension()){
421 m_out_seed_x0.push_back(seed->interceptX());
422 m_out_seed_tanalpha.push_back(seed->tanAlpha());
423 } else{
424 m_out_seed_x0.push_back(-999);
425 m_out_seed_tanalpha.push_back(-999);
426 }
427 m_out_seed_ledToSegment.push_back(obj.matchedSeedFoundSegment.at(iseed));
428
429
432 auto hitCounter = [seed](auto lambda) {
433 return std::count_if(seed->getHitsInMax().begin(),
434 seed->getHitsInMax().end(), lambda);
435 };
436
437 m_out_seed_nPrecHits += hitCounter([](const SpacePoint* sp) {
438 return isPrecision(*sp);
439 });
440 m_out_seed_nEtaHits += hitCounter([](const SpacePoint* sp) {
441 return !isPrecision(*sp) && sp->measuresEta();
442 });
443 m_out_seed_nPhiHits += hitCounter([](const SpacePoint* sp) {
444 return sp->measuresPhi();
445 });
446
447 m_out_seed_nTruePrecHits += hitCounter([this](const SpacePoint* sp) {
448 return isPrecision(*sp) &&
449 (!m_visionTool.isEnabled() || m_visionTool->isLabeled(*sp));
450 });
451 m_out_seed_nTrueEtaHits += hitCounter([this](const SpacePoint* sp) {
452 return !isPrecision(*sp) && sp->measuresEta() &&
453 (!m_visionTool.isEnabled() || m_visionTool->isLabeled(*sp));
454 });
455 m_out_seed_nTruePhiHits += hitCounter([this](const SpacePoint* sp) {
456 return sp->measuresPhi() &&
457 (!m_visionTool.isEnabled() || m_visionTool->isLabeled(*sp));
458 });
459
460 /***
461 * Split hit counts for the NSW!
462 */
463 m_out_seed_nMmEtaHits += hitCounter([this](const SpacePoint* sp){
464 return sp->type() == xAOD::UncalibMeasType::MMClusterType &&
465 !m_idHelperSvc->mmIdHelper().isStereo(sp->identify());
466 });
467 m_out_seed_nMmStereoHits += hitCounter([this](const SpacePoint* sp){
468 return sp->type() == xAOD::UncalibMeasType::MMClusterType &&
469 m_idHelperSvc->mmIdHelper().isStereo(sp->identify());
470 });
471
472 m_out_seed_nsTgcStripHits+=hitCounter([](const SpacePoint* sp){
473 return sp->type() == xAOD::UncalibMeasType::sTgcStripType &&
474 isPrecision(*sp);
475 });
476 m_out_seed_nsTgcWireHits+=hitCounter([this](const SpacePoint* sp) {
477 return sp->type() == xAOD::UncalibMeasType::sTgcStripType &&
478 sp->measuresPhi() &&
479 m_idHelperSvc->stgcIdHelper().channelType(sp->identify()) !=
480 sTgcIdHelper::sTgcChannelTypes::Pad;
481 });
482 m_out_seed_nsTgcPadHits.push_back(hitCounter([this](const SpacePoint* sp){
483 return sp->type() == xAOD::UncalibMeasType::sTgcStripType &&
484 m_idHelperSvc->stgcIdHelper().channelType(sp->identify()) ==
485 sTgcIdHelper::sTgcChannelTypes::Pad;
486 }));
487
489 m_out_seed_nTrueMmEtaHits += hitCounter([this](const SpacePoint* sp){
490 return sp->type() == xAOD::UncalibMeasType::MMClusterType &&
491 (!m_visionTool.isEnabled() || m_visionTool->isLabeled(*sp)) &&
492 !m_idHelperSvc->mmIdHelper().isStereo(sp->identify());
493 });
494 m_out_seed_nTrueMmStereoHits += hitCounter([this](const SpacePoint* sp){
495 return sp->type() == xAOD::UncalibMeasType::MMClusterType &&
496 (!m_visionTool.isEnabled() || m_visionTool->isLabeled(*sp)) &&
497 m_idHelperSvc->mmIdHelper().isStereo(sp->identify());
498 });
499
500 m_out_seed_nTruesTgcStripHits+=hitCounter([this](const SpacePoint* sp){
501 return sp->type() == xAOD::UncalibMeasType::sTgcStripType &&
502 (!m_visionTool.isEnabled() || m_visionTool->isLabeled(*sp)) &&
503 isPrecision(*sp);
504 });
505 m_out_seed_nTruesTgcWireHits+=hitCounter([this](const SpacePoint* sp) {
506 return sp->type() == xAOD::UncalibMeasType::sTgcStripType &&
507 (!m_visionTool.isEnabled() || m_visionTool->isLabeled(*sp)) &&
508 sp->measuresPhi() &&
509 m_idHelperSvc->stgcIdHelper().channelType(sp->identify()) !=
510 sTgcIdHelper::sTgcChannelTypes::Pad;
511 });
512 m_out_seed_nTruesTgcPadHits.push_back(hitCounter([this](const SpacePoint* sp){
513 return sp->type() == xAOD::UncalibMeasType::sTgcStripType &&
514 (!m_visionTool.isEnabled() || m_visionTool->isLabeled(*sp)) &&
515 m_idHelperSvc->stgcIdHelper().channelType(sp->identify()) ==
516 sTgcIdHelper::sTgcChannelTypes::Pad;
517 }));
518
519 if (m_writeSpacePoints) {
520 std::vector<unsigned char> treeIdxs{};
521 for (const HoughHitType & houghSP: seed->getHitsInMax()){
522 if (m_writeSpacePoints){
523 unsigned treeIdx = m_spTester->push_back(*houghSP);
524 treeIdxs.push_back(treeIdx);
525 }
526 }
527 m_spMatchedToPattern[iseed] = std::move(treeIdxs);
528 }
529 }
530 }
MuonValR4::MuonHoughTransformTester::m_out_seed_maxYhit
MuonVal::VectorBranch< float > & m_out_seed_maxYhit
Definition MuonHoughTransformTester.h:206
MuonValR4::MuonHoughTransformTester::m_out_seed_ledToSegment
MuonVal::VectorBranch< unsigned char > & m_out_seed_ledToSegment
Definition MuonHoughTransformTester.h:230
MuonValR4::MuonHoughTransformTester::m_out_seed_nTrueEtaHits
MuonVal::VectorBranch< unsigned short > & m_out_seed_nTrueEtaHits
Definition MuonHoughTransformTester.h:213
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:220
MuonValR4::MuonHoughTransformTester::m_out_seed_nMmEtaHits
MuonVal::VectorBranch< unsigned short > & m_out_seed_nMmEtaHits
Definition MuonHoughTransformTester.h:216
MuonValR4::MuonHoughTransformTester::m_out_seed_x0
MuonVal::VectorBranch< float > & m_out_seed_x0
Definition MuonHoughTransformTester.h:200
MuonValR4::MuonHoughTransformTester::m_out_seed_nTruePrecHits
MuonVal::VectorBranch< unsigned short > & m_out_seed_nTruePrecHits
Definition MuonHoughTransformTester.h:212
MuonValR4::MuonHoughTransformTester::m_out_seed_y0
MuonVal::VectorBranch< float > & m_out_seed_y0
Definition MuonHoughTransformTester.h:199
MuonValR4::MuonHoughTransformTester::m_out_seed_hasPhiExtension
MuonVal::VectorBranch< unsigned short > & m_out_seed_hasPhiExtension
Definition MuonHoughTransformTester.h:197
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:222
MuonValR4::MuonHoughTransformTester::m_out_seed_nEtaHits
MuonVal::VectorBranch< unsigned short > & m_out_seed_nEtaHits
Definition MuonHoughTransformTester.h:209
MuonValR4::MuonHoughTransformTester::fillBucketInfo
void fillBucketInfo(const MuonR4::SpacePointBucket &bucket)
Fill the hit summary info of the associated bucket.
Definition MuonHoughTransformTester.cxx:351
MuonValR4::MuonHoughTransformTester::m_out_seed_nTruesTgcPadHits
MuonVal::VectorBranch< unsigned short > & m_out_seed_nTruesTgcPadHits
Definition MuonHoughTransformTester.h:228
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:193
MuonValR4::MuonHoughTransformTester::m_out_seed_nTruePhiHits
MuonVal::VectorBranch< unsigned short > & m_out_seed_nTruePhiHits
Definition MuonHoughTransformTester.h:214
MuonValR4::MuonHoughTransformTester::m_out_seed_nMmStereoHits
MuonVal::VectorBranch< unsigned short > & m_out_seed_nMmStereoHits
Definition MuonHoughTransformTester.h:217
MuonValR4::MuonHoughTransformTester::m_out_seed_nsTgcWireHits
MuonVal::VectorBranch< unsigned short > & m_out_seed_nsTgcWireHits
Definition MuonHoughTransformTester.h:223
MuonValR4::MuonHoughTransformTester::m_out_seed_minYhit
MuonVal::VectorBranch< float > & m_out_seed_minYhit
Definition MuonHoughTransformTester.h:205
MuonValR4::MuonHoughTransformTester::m_out_seed_nTrueMmEtaHits
MuonVal::VectorBranch< unsigned short > & m_out_seed_nTrueMmEtaHits
Definition MuonHoughTransformTester.h:219
MuonValR4::MuonHoughTransformTester::m_out_seed_tanbeta
MuonVal::VectorBranch< float > & m_out_seed_tanbeta
Definition MuonHoughTransformTester.h:201
MuonValR4::MuonHoughTransformTester::m_out_seed_nPrecHits
MuonVal::VectorBranch< unsigned short > & m_out_seed_nPrecHits
Definition MuonHoughTransformTester.h:208
MuonValR4::MuonHoughTransformTester::m_out_seed_tanalpha
MuonVal::VectorBranch< float > & m_out_seed_tanalpha
Definition MuonHoughTransformTester.h:202
MuonValR4::MuonHoughTransformTester::m_out_seed_nsTgcPadHits
MuonVal::VectorBranch< unsigned short > & m_out_seed_nsTgcPadHits
Definition MuonHoughTransformTester.h:224
MuonValR4::MuonHoughTransformTester::m_out_seed_nPhiHits
MuonVal::VectorBranch< unsigned short > & m_out_seed_nPhiHits
Definition MuonHoughTransformTester.h:210
MuonValR4::MuonHoughTransformTester::m_out_seed_nTruesTgcWireHits
MuonVal::VectorBranch< unsigned short > & m_out_seed_nTruesTgcWireHits
Definition MuonHoughTransformTester.h:227
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:226
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 532 of file MuonHoughTransformTester.cxx.

532 {
533 using namespace SegmentFit;
534
535 m_out_segment_n = obj.matchedSegments.size();
536 for (const xAOD::MuonSegment* segment : obj.matchedSegments) {
537
539 const auto pars = localSegmentPars(*segment);
540 const auto cov = localSegmentCov(*segment);
541
542 m_out_segment_theta.push_back(pars[Acts::toUnderlying(ParamDefs::theta)]);
543 m_out_segment_phi.push_back(pars[Acts::toUnderlying(ParamDefs::phi)]);
544 m_out_segment_y0.push_back(pars[Acts::toUnderlying(ParamDefs::y0)]);
545 m_out_segment_x0.push_back(pars[Acts::toUnderlying(ParamDefs::x0)]);
546 m_out_segment_time.push_back(pars[Acts::toUnderlying(ParamDefs::t0)] +
547 segment->position().mag() * c_inv);
548
549 for (std::size_t i =0; i < Acts::toUnderlying(ParamDefs::nPars); ++i) {
550 for (std::size_t j = 0; j <=i; ++j) {
551 const std::size_t vecIdx = Acts::vecIdxFromSymMat<Acts::toUnderlying(ParamDefs::nPars)>(i,j);
552 m_segmentCov[vecIdx]->push_back((*cov)(i,j));
553 }
554 }
555
557 const MuonR4::Segment* detailSeg = detailedSegment(*segment);
558 m_out_segment_fitIter.push_back(detailSeg->nFitIterations());
559 m_out_segment_chi2.push_back(segment->chiSquared());
560 m_out_segment_nDoF.push_back(segment->numberDoF());
561 m_out_segment_hasTimeFit.push_back(detailSeg->hasTimeFit());
564 auto hitCounter = [detailSeg](auto lambda) {
565 return std::count_if(detailSeg->measurements().begin(),
566 detailSeg->measurements().end(), lambda);
567 };
568 const unsigned nAuxilliary = hitCounter([](const auto& m){
569 return m->type() == xAOD::UncalibMeasType::Other;
570 });
571 m_out_segment_nPrecHits += segment->nPrecisionHits();
572 m_out_segment_nTrigEtaHits += segment->nTrigEtaLayers() - nAuxilliary;
573 m_out_segment_nTrigPhiHits += segment->nPhiLayers() - nAuxilliary;
574
575 m_out_segment_nPrecOutliers += segment->nPrecisionOutliers();
576 m_out_segment_nTrigEtaOutliers += segment->nTriggerEtaOutliers();
577 m_out_segment_nTrigPhiOutliers += segment->nTriggerPhiOutliers();
578
579 m_out_segment_nPrecHoles += segment->nPrecisionHoles();
580 m_out_segment_nTrigEtaHoles += segment->nTriggerEtaHoles();
581 m_out_segment_nTrigPhiHoles += segment->nTriggerPhiHoles();
583 m_out_segment_nTruePrecHits += hitCounter([this](const auto& meas) {
584 return meas->fitState() == CalibratedSpacePoint::State::Valid &&
585 isPrecision(*meas) && (!m_visionTool.isEnabled() ||
586 m_visionTool->isLabeled(*meas->spacePoint()));
587 });
589 m_out_segment_nTrueTrigEtaHits += hitCounter([this](const auto& meas) {
590 return meas->fitState() == CalibratedSpacePoint::State::Valid &&
591 !isPrecision(*meas) && meas->measuresEta() &&
592 meas->spacePoint() &&
593 (!m_visionTool.isEnabled() || m_visionTool->isLabeled(*meas->spacePoint()));
594 });
596 m_out_segment_nTrueTrigPhiHits += hitCounter([this](const auto& meas) {
597 return meas->fitState() == CalibratedSpacePoint::State::Valid &&
598 !isPrecision(*meas) && meas->measuresPhi() &&
599 meas->spacePoint() &&
600 (!m_visionTool.isEnabled() || m_visionTool->isLabeled(*meas->spacePoint()));
601 });
603 m_out_segment_nTruePrecOutliers += hitCounter([this](const auto& meas) {
604 return meas->fitState() != CalibratedSpacePoint::State::Valid &&
605 isPrecision(*meas) && (!m_visionTool.isEnabled() ||
606 m_visionTool->isLabeled(*meas->spacePoint()));
607 });
609 m_out_segment_nTrueTrigEtaOutliers += hitCounter([this](const auto& meas) {
610 return meas->fitState() != CalibratedSpacePoint::State::Valid &&
611 !isPrecision(*meas) && meas->measuresEta() &&
612 meas->spacePoint() &&
613 (!m_visionTool.isEnabled() || m_visionTool->isLabeled(*meas->spacePoint()));
614 });
616 m_out_segment_nTrueTrigPhiOutliers += hitCounter([this](const auto& meas) {
617 return meas->fitState() != CalibratedSpacePoint::State::Valid &&
618 !isPrecision(*meas) && meas->measuresPhi() &&
619 meas->spacePoint() &&
620 (!m_visionTool.isEnabled() || m_visionTool->isLabeled(*meas->spacePoint()));
621 });
622
623 /***
624 * Split hit counts for the NSW!
625 */
626 m_out_segment_nMmEtaHits.push_back(hitCounter([this](const auto& meas){
627 return meas->fitState() == CalibratedSpacePoint::State::Valid &&
628 meas->type() == xAOD::UncalibMeasType::MMClusterType &&
629 !m_idHelperSvc->mmIdHelper().isStereo(meas->spacePoint()->identify());
630 }));
631 m_out_segment_nMmStereoHits.push_back(hitCounter([this](const auto& meas){
632 return meas->fitState() == CalibratedSpacePoint::State::Valid &&
633 meas->type() == xAOD::UncalibMeasType::MMClusterType &&
634 m_idHelperSvc->mmIdHelper().isStereo(meas->spacePoint()->identify());
635 }));
636 m_out_segment_nMmEtaOutliers.push_back(hitCounter([this](const auto& meas){
637 return meas->fitState() != CalibratedSpacePoint::State::Valid &&
638 meas->type() == xAOD::UncalibMeasType::MMClusterType &&
639 !m_idHelperSvc->mmIdHelper().isStereo(meas->spacePoint()->identify());
640 }));
641 m_out_segment_nMmStereoOutliers.push_back(hitCounter([this](const auto& meas){
642 return meas->fitState() != CalibratedSpacePoint::State::Valid &&
643 meas->type() == xAOD::UncalibMeasType::MMClusterType &&
644 m_idHelperSvc->mmIdHelper().isStereo(meas->spacePoint()->identify());
645 }));
646
647 m_out_segment_nSTgcStripHits.push_back(hitCounter([](const auto& meas){
648 return meas->fitState() == CalibratedSpacePoint::State::Valid &&
649 meas->type() == xAOD::UncalibMeasType::sTgcStripType &&
650 isPrecision(*meas);
651 }));
652 m_out_segment_nSTgcWireHits.push_back(hitCounter([this](const auto& meas){
653 return meas->fitState() == CalibratedSpacePoint::State::Valid &&
654 meas->type() == xAOD::UncalibMeasType::sTgcStripType &&
655 meas->measuresPhi() &&
656 m_idHelperSvc->stgcIdHelper().channelType(meas->spacePoint()->identify()) !=
657 sTgcIdHelper::sTgcChannelTypes::Pad;
658 }));
659 m_out_segment_nSTgcPadHits.push_back(hitCounter([this](const auto& meas){
660 return meas->fitState() == CalibratedSpacePoint::State::Valid &&
661 meas->type() == xAOD::UncalibMeasType::sTgcStripType &&
662 m_idHelperSvc->stgcIdHelper().channelType(meas->spacePoint()->identify()) ==
663 sTgcIdHelper::sTgcChannelTypes::Pad;
664 }));
665 m_out_segment_nSTgcStripOutliers.push_back(hitCounter([](const auto& meas){
666 return meas->fitState() != CalibratedSpacePoint::State::Valid &&
667 meas->type() == xAOD::UncalibMeasType::sTgcStripType &&
668 isPrecision(*meas);
669 }));
670 m_out_segment_nSTgcWireOutliers.push_back(hitCounter([this](const auto& meas){
671 return meas->fitState() != CalibratedSpacePoint::State::Valid &&
672 meas->type() == xAOD::UncalibMeasType::sTgcStripType &&
673 meas->measuresPhi() &&
674 m_idHelperSvc->stgcIdHelper().channelType(meas->spacePoint()->identify()) !=
675 sTgcIdHelper::sTgcChannelTypes::Pad;
676 }));
677 m_out_segment_nSTgcPadOutliers.push_back(hitCounter([this](const auto& meas){
678 return meas->fitState() != CalibratedSpacePoint::State::Valid &&
679 meas->type() == xAOD::UncalibMeasType::sTgcStripType &&
680 m_idHelperSvc->stgcIdHelper().channelType(meas->spacePoint()->identify()) ==
681 sTgcIdHelper::sTgcChannelTypes::Pad;
682 }));
684 m_out_segment_nMmTrueEtaHits.push_back(hitCounter([this](const auto& meas){
685 return meas->fitState() == CalibratedSpacePoint::State::Valid &&
686 meas->type() == xAOD::UncalibMeasType::MMClusterType &&
687 (!m_visionTool.isEnabled() || m_visionTool->isLabeled(*meas->spacePoint())) &&
688 !m_idHelperSvc->mmIdHelper().isStereo(meas->spacePoint()->identify());
689 }));
690 m_out_segment_nMmTrueStereoHits.push_back(hitCounter([this](const auto& meas){
691 return meas->fitState() == CalibratedSpacePoint::State::Valid &&
692 meas->type() == xAOD::UncalibMeasType::MMClusterType &&
693 (!m_visionTool.isEnabled() || m_visionTool->isLabeled(*meas->spacePoint())) &&
694 m_idHelperSvc->mmIdHelper().isStereo(meas->spacePoint()->identify());
695 }));
696 m_out_segment_nMmTrueEtaOutliers.push_back(hitCounter([this](const auto& meas){
697 return meas->fitState() != CalibratedSpacePoint::State::Valid &&
698 meas->type() == xAOD::UncalibMeasType::MMClusterType &&
699 (!m_visionTool.isEnabled() || m_visionTool->isLabeled(*meas->spacePoint())) &&
700 !m_idHelperSvc->mmIdHelper().isStereo(meas->spacePoint()->identify());
701 }));
702 m_out_segment_nMmTrueStereoOutliers.push_back(hitCounter([this](const auto& meas){
703 return meas->fitState() != CalibratedSpacePoint::State::Valid &&
704 meas->type() == xAOD::UncalibMeasType::MMClusterType &&
705 (!m_visionTool.isEnabled() || m_visionTool->isLabeled(*meas->spacePoint())) &&
706 m_idHelperSvc->mmIdHelper().isStereo(meas->spacePoint()->identify());
707 }));
708 m_out_segment_nSTgcTrueStripHits.push_back(hitCounter([this](const auto& meas){
709 return meas->fitState() == CalibratedSpacePoint::State::Valid &&
710 meas->type() == xAOD::UncalibMeasType::sTgcStripType &&
711 (!m_visionTool.isEnabled() || m_visionTool->isLabeled(*meas->spacePoint())) &&
712 isPrecision(*meas);
713 }));
714 m_out_segment_nSTgcTrueWireHits.push_back(hitCounter([this](const auto& meas){
715 return meas->fitState() == CalibratedSpacePoint::State::Valid &&
716 meas->type() == xAOD::UncalibMeasType::sTgcStripType &&
717 (!m_visionTool.isEnabled() || m_visionTool->isLabeled(*meas->spacePoint())) &&
718 meas->measuresPhi() &&
719 m_idHelperSvc->stgcIdHelper().channelType(meas->spacePoint()->identify()) !=
720 sTgcIdHelper::sTgcChannelTypes::Pad;
721 }));
722 m_out_segment_nSTgcTruePadHits.push_back(hitCounter([this](const auto& meas){
723 return meas->fitState() == CalibratedSpacePoint::State::Valid &&
724 meas->type() == xAOD::UncalibMeasType::sTgcStripType &&
725 (!m_visionTool.isEnabled() || m_visionTool->isLabeled(*meas->spacePoint())) &&
726 m_idHelperSvc->stgcIdHelper().channelType(meas->spacePoint()->identify()) ==
727 sTgcIdHelper::sTgcChannelTypes::Pad;
728 }));
729 m_out_segment_nSTgcTrueStripOutliers.push_back(hitCounter([this](const auto& meas){
730 return meas->fitState() != CalibratedSpacePoint::State::Valid &&
731 meas->type() == xAOD::UncalibMeasType::sTgcStripType &&
732 (!m_visionTool.isEnabled() || m_visionTool->isLabeled(*meas->spacePoint())) &&
733 isPrecision(*meas);
734 }));
735 m_out_segment_nSTgcTrueWireOutliers.push_back(hitCounter([this](const auto& meas){
736 return meas->fitState() != CalibratedSpacePoint::State::Valid &&
737 meas->type() == xAOD::UncalibMeasType::sTgcStripType &&
738 (!m_visionTool.isEnabled() || m_visionTool->isLabeled(*meas->spacePoint())) &&
739 meas->measuresPhi() &&
740 m_idHelperSvc->stgcIdHelper().channelType(meas->spacePoint()->identify()) !=
741 sTgcIdHelper::sTgcChannelTypes::Pad;
742 }));
743 m_out_segment_nSTgcTruePadOutliers.push_back(hitCounter([this](const auto& meas){
744 return meas->fitState() != CalibratedSpacePoint::State::Valid &&
745 meas->type() == xAOD::UncalibMeasType::sTgcStripType &&
746 (!m_visionTool.isEnabled() || m_visionTool->isLabeled(*meas->spacePoint())) &&
747 m_idHelperSvc->stgcIdHelper().channelType(meas->spacePoint()->identify()) ==
748 sTgcIdHelper::sTgcChannelTypes::Pad;
749 }));
750
751 double minYhit = 1._km;
752 double maxYhit = -1._km;
753 double minYTruehit = 1._km;
754 double maxYTruehit = -1._km;
755
756 std::vector<unsigned char> matched{};
757 for (const auto & meas : detailSeg->measurements()){
758 // skip dummy measurement from beam spot constraint
759 ATH_MSG_VERBOSE(__func__<<"() - "<<__LINE__<<" Dump "<<(*meas));
760 if (meas->type() == xAOD::UncalibMeasType::Other) {
761 continue;
762 }
763 minYhit = std::min(meas->localPosition().y(),minYhit);
764 maxYhit = std::max(meas->localPosition().y(),maxYhit);
765 if (!m_visionTool.isEnabled() || m_visionTool->isLabeled(*meas->spacePoint())) {
766 minYTruehit = std::min(meas->localPosition().y(), minYTruehit);
767 maxYTruehit = std::max(meas->localPosition().y(), maxYTruehit);
768 }
769 if (m_writeSpacePoints) {
770 unsigned treeIdx = m_spTester->push_back(*meas->spacePoint());
771 if (treeIdx >= matched.size()){
772 matched.resize(treeIdx +1);
773 }
774 matched[treeIdx] = true;
775 }
776 }
777
778 m_out_segment_minYhit += minYhit;
779 m_out_segment_maxYhit += maxYhit;
780 m_out_segment_minTrueYhit += minYTruehit;
781 m_out_segment_maxTrueYhit += maxYTruehit;
782 if (m_writeSpacePoints) {
783 m_spMatchedToSegment.push_back(std::move(matched));
784 }
785 }
786 }
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition AthMsgStreamMacros.h:28
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:277
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:235
MuonValR4::MuonHoughTransformTester::m_out_segment_nTrigPhiOutliers
MuonVal::VectorBranch< unsigned short > & m_out_segment_nTrigPhiOutliers
Definition MuonHoughTransformTester.h:261
MuonValR4::MuonHoughTransformTester::m_out_segment_hasTimeFit
MuonVal::VectorBranch< char > & m_out_segment_hasTimeFit
Definition MuonHoughTransformTester.h:241
MuonValR4::MuonHoughTransformTester::m_segmentCov
std::array< FloatVecBrPtr_t, Acts::sumUpToN(Acts::toUnderlying(MuonR4::SegmentFit::ParamDefs::nPars))> m_segmentCov
Definition MuonHoughTransformTester.h:252
MuonValR4::MuonHoughTransformTester::m_out_segment_nTrigPhiHits
MuonVal::VectorBranch< unsigned short > & m_out_segment_nTrigPhiHits
Definition MuonHoughTransformTester.h:257
MuonValR4::MuonHoughTransformTester::m_out_segment_nSTgcTruePadHits
MuonVal::VectorBranch< unsigned short > & m_out_segment_nSTgcTruePadHits
Definition MuonHoughTransformTester.h:286
MuonValR4::MuonHoughTransformTester::m_out_segment_nTruePrecOutliers
MuonVal::VectorBranch< unsigned short > & m_out_segment_nTruePrecOutliers
Definition MuonHoughTransformTester.h:271
MuonValR4::MuonHoughTransformTester::m_out_segment_nSTgcPadOutliers
MuonVal::VectorBranch< unsigned short > & m_out_segment_nSTgcPadOutliers
Definition MuonHoughTransformTester.h:292
MuonValR4::MuonHoughTransformTester::m_out_segment_maxTrueYhit
MuonVal::VectorBranch< float > & m_out_segment_maxTrueYhit
Definition MuonHoughTransformTester.h:304
MuonValR4::MuonHoughTransformTester::m_out_segment_nSTgcTrueStripHits
MuonVal::VectorBranch< unsigned short > & m_out_segment_nSTgcTrueStripHits
Definition MuonHoughTransformTester.h:284
MuonValR4::MuonHoughTransformTester::m_out_segment_nSTgcTruePadOutliers
MuonVal::VectorBranch< unsigned short > & m_out_segment_nSTgcTruePadOutliers
Definition MuonHoughTransformTester.h:298
MuonValR4::MuonHoughTransformTester::m_out_segment_nTruePrecHits
MuonVal::VectorBranch< unsigned short > & m_out_segment_nTruePrecHits
True matched hit counters.
Definition MuonHoughTransformTester.h:267
MuonValR4::MuonHoughTransformTester::m_out_segment_nSTgcTrueWireHits
MuonVal::VectorBranch< unsigned short > & m_out_segment_nSTgcTrueWireHits
Definition MuonHoughTransformTester.h:285
MuonValR4::MuonHoughTransformTester::m_out_segment_nTrigPhiHoles
MuonVal::VectorBranch< unsigned short > & m_out_segment_nTrigPhiHoles
Definition MuonHoughTransformTester.h:265
MuonValR4::MuonHoughTransformTester::m_out_segment_time
MuonVal::VectorBranch< float > & m_out_segment_time
Definition MuonHoughTransformTester.h:249
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:296
MuonValR4::MuonHoughTransformTester::m_out_segment_nPrecOutliers
MuonVal::VectorBranch< unsigned short > & m_out_segment_nPrecOutliers
Definition MuonHoughTransformTester.h:259
MuonValR4::MuonHoughTransformTester::m_out_segment_nMmStereoOutliers
MuonVal::VectorBranch< unsigned short > & m_out_segment_nMmStereoOutliers
Definition MuonHoughTransformTester.h:289
MuonValR4::MuonHoughTransformTester::m_out_segment_nTrigEtaHits
MuonVal::VectorBranch< unsigned short > & m_out_segment_nTrigEtaHits
Definition MuonHoughTransformTester.h:256
MuonValR4::MuonHoughTransformTester::m_out_segment_nSTgcStripOutliers
MuonVal::VectorBranch< unsigned short > & m_out_segment_nSTgcStripOutliers
Definition MuonHoughTransformTester.h:290
MuonValR4::MuonHoughTransformTester::m_out_segment_nTrigEtaHoles
MuonVal::VectorBranch< unsigned short > & m_out_segment_nTrigEtaHoles
Definition MuonHoughTransformTester.h:264
MuonValR4::MuonHoughTransformTester::m_out_segment_nSTgcWireOutliers
MuonVal::VectorBranch< unsigned short > & m_out_segment_nSTgcWireOutliers
Definition MuonHoughTransformTester.h:291
MuonValR4::MuonHoughTransformTester::m_out_segment_chi2
MuonVal::VectorBranch< float > & m_out_segment_chi2
Definition MuonHoughTransformTester.h:239
MuonValR4::MuonHoughTransformTester::m_out_segment_nMmTrueEtaOutliers
MuonVal::VectorBranch< unsigned short > & m_out_segment_nMmTrueEtaOutliers
Definition MuonHoughTransformTester.h:294
MuonValR4::MuonHoughTransformTester::m_out_segment_nTrueTrigEtaHits
MuonVal::VectorBranch< unsigned short > & m_out_segment_nTrueTrigEtaHits
Definition MuonHoughTransformTester.h:268
MuonValR4::MuonHoughTransformTester::m_out_segment_phi
MuonVal::VectorBranch< float > & m_out_segment_phi
Definition MuonHoughTransformTester.h:248
MuonValR4::MuonHoughTransformTester::m_out_segment_nTrueTrigPhiOutliers
MuonVal::VectorBranch< unsigned short > & m_out_segment_nTrueTrigPhiOutliers
Definition MuonHoughTransformTester.h:273
MuonValR4::MuonHoughTransformTester::m_out_segment_theta
MuonVal::VectorBranch< float > & m_out_segment_theta
Definition MuonHoughTransformTester.h:247
MuonValR4::MuonHoughTransformTester::m_out_segment_nMmTrueStereoHits
MuonVal::VectorBranch< unsigned short > & m_out_segment_nMmTrueStereoHits
Definition MuonHoughTransformTester.h:283
MuonValR4::MuonHoughTransformTester::m_out_segment_nTrigEtaOutliers
MuonVal::VectorBranch< unsigned short > & m_out_segment_nTrigEtaOutliers
Definition MuonHoughTransformTester.h:260
MuonValR4::MuonHoughTransformTester::m_out_segment_minYhit
MuonVal::VectorBranch< float > & m_out_segment_minYhit
Definition MuonHoughTransformTester.h:301
MuonValR4::MuonHoughTransformTester::m_out_segment_nMmEtaOutliers
MuonVal::VectorBranch< unsigned short > & m_out_segment_nMmEtaOutliers
Definition MuonHoughTransformTester.h:288
MuonValR4::MuonHoughTransformTester::m_out_segment_nMmTrueStereoOutliers
MuonVal::VectorBranch< unsigned short > & m_out_segment_nMmTrueStereoOutliers
Definition MuonHoughTransformTester.h:295
MuonValR4::MuonHoughTransformTester::m_out_segment_x0
MuonVal::VectorBranch< float > & m_out_segment_x0
Definition MuonHoughTransformTester.h:246
MuonValR4::MuonHoughTransformTester::m_out_segment_nSTgcPadHits
MuonVal::VectorBranch< unsigned short > & m_out_segment_nSTgcPadHits
Definition MuonHoughTransformTester.h:280
MuonValR4::MuonHoughTransformTester::m_out_segment_nMmEtaHits
MuonVal::VectorBranch< unsigned short > & m_out_segment_nMmEtaHits
NSW hit counters.
Definition MuonHoughTransformTester.h:276
MuonValR4::MuonHoughTransformTester::m_out_segment_nTrueTrigPhiHits
MuonVal::VectorBranch< unsigned short > & m_out_segment_nTrueTrigPhiHits
Definition MuonHoughTransformTester.h:269
MuonValR4::MuonHoughTransformTester::m_out_segment_maxYhit
MuonVal::VectorBranch< float > & m_out_segment_maxYhit
Definition MuonHoughTransformTester.h:302
MuonValR4::MuonHoughTransformTester::m_out_segment_nSTgcTrueWireOutliers
MuonVal::VectorBranch< unsigned short > & m_out_segment_nSTgcTrueWireOutliers
Definition MuonHoughTransformTester.h:297
MuonValR4::MuonHoughTransformTester::m_out_segment_minTrueYhit
MuonVal::VectorBranch< float > & m_out_segment_minTrueYhit
Definition MuonHoughTransformTester.h:303
MuonValR4::MuonHoughTransformTester::m_out_segment_nSTgcWireHits
MuonVal::VectorBranch< unsigned short > & m_out_segment_nSTgcWireHits
Definition MuonHoughTransformTester.h:279
MuonValR4::MuonHoughTransformTester::m_out_segment_nPrecHits
MuonVal::VectorBranch< unsigned short > & m_out_segment_nPrecHits
Hit counts on segment.
Definition MuonHoughTransformTester.h:255
MuonValR4::MuonHoughTransformTester::m_out_segment_nMmTrueEtaHits
MuonVal::VectorBranch< unsigned short > & m_out_segment_nMmTrueEtaHits
Definition MuonHoughTransformTester.h:282
MuonValR4::MuonHoughTransformTester::m_out_segment_nDoF
MuonVal::VectorBranch< uint16_t > & m_out_segment_nDoF
Definition MuonHoughTransformTester.h:240
MuonValR4::MuonHoughTransformTester::m_out_segment_fitIter
MuonVal::VectorBranch< uint16_t > & m_out_segment_fitIter
Definition MuonHoughTransformTester.h:242
MuonValR4::MuonHoughTransformTester::m_out_segment_y0
MuonVal::VectorBranch< float > & m_out_segment_y0
Definition MuonHoughTransformTester.h:245
MuonValR4::MuonHoughTransformTester::m_out_segment_nTrueTrigEtaOutliers
MuonVal::VectorBranch< unsigned short > & m_out_segment_nTrueTrigEtaOutliers
Definition MuonHoughTransformTester.h:272
MuonValR4::MuonHoughTransformTester::m_out_segment_nPrecHoles
MuonVal::VectorBranch< unsigned short > & m_out_segment_nPrecHoles
Definition MuonHoughTransformTester.h:263
MuonValR4::MuonHoughTransformTester::m_out_segment_nSTgcStripHits
MuonVal::VectorBranch< unsigned short > & m_out_segment_nSTgcStripHits
Definition MuonHoughTransformTester.h:278
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
make_hlt_rep.pars
pars
Definition make_hlt_rep.py:90
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 282 of file MuonHoughTransformTester.cxx.

283 {
284 if (!segment) {
285 return;
286 }
287 m_out_hasTruth = true;
288
289 const Amg::Vector3D segDir{segment->direction()};
290 static const SG::ConstAccessor<float> acc_pt{"pt"};
291 static const SG::ConstAccessor<float> acc_charge{"charge"};
292 // eta is interpreted as the eta-location
293 m_out_gen_Eta = segDir.eta();
294 m_out_gen_Phi = segDir.phi();
295 m_out_gen_Pt = acc_pt(*segment);
296 m_out_gen_Q = acc_charge(*segment);
297
298 const auto [chamberPos, chamberDir] = SegmentFit::makeLine(SegmentFit::localSegmentPars(*segment));
299
300 ATH_MSG_DEBUG("Number of precision Hits in the truth segment is "<<segment->nPrecisionHits()<<" and number of phi layers is "
301 <<segment->nPhiLayers()<<" and number of trigger eta layers is "<<segment->nTrigEtaLayers());
302 m_out_gen_nPrecHits = segment->nPrecisionHits();
303 m_out_gen_nTrigEtaHits = segment->nTrigEtaLayers();
304 m_out_gen_nTrigPhiHits = segment->nPhiLayers();
305 unsigned nMmEtaHits{0}, nMmStereoHits{0}, nStgcHits{0};
306 for (const xAOD::MuonSimHit* simHit : getMatchingSimHits(*segment)) {
307 if (!m_out_gen_truthBeta.isUpdated()) {
308 m_out_gen_truthBeta = simHit->beta();
309 m_out_gen_truthPdgId = simHit->pdgId();
310 }
311 nStgcHits += m_idHelperSvc->technologyIndex(simHit->identify()) == TechnologyIndex::STGC;
312 if(m_idHelperSvc->technologyIndex(simHit->identify()) != TechnologyIndex::MM) {
313 continue;
314 }
315 const bool isStereo = m_idHelperSvc->mmIdHelper().isStereo(simHit->identify());
316 nMmEtaHits += (!isStereo);
317 nMmStereoHits += isStereo;
318 }
319 m_out_gen_nMmEtaHits = nMmEtaHits;
320 m_out_gen_nMmStereoHits = nMmStereoHits;
321 m_out_gen_nStgcHits = nStgcHits;
322
323 m_out_gen_tanbeta = houghTanBeta(chamberDir);
324 m_out_gen_tanalpha = houghTanAlpha(chamberDir);
325 m_out_gen_y0 = chamberPos.y();
326 m_out_gen_x0 = chamberPos.x();
327 m_out_gen_time = segment->t0();
328
329 double minYhit = std::numeric_limits<double>::max();
330 double maxYhit = -1 * std::numeric_limits<double>::max();
331 for (const xAOD::MuonSimHit* hit : getMatchingSimHits(*segment)){
332 const Identifier hitId = hit->identify();
333 const MuonGMR4::MuonReadoutElement* RE = m_detMgr->getReadoutElement(hitId);
334 const IdentifierHash hash{m_idHelperSvc->isMdt(hitId) ? RE->measurementHash(hitId)
335 : RE->layerHash(hitId) };
336 const Amg::Transform3D localToChamber = RE->msSector()->globalToLocalTransform(gctx) * RE->localToGlobalTransform(gctx, hash);
337 const Amg::Vector3D chamberPos = localToChamber * xAOD::toEigen(hit->localPosition());
338 minYhit = std::min(chamberPos.y(), minYhit);
339 maxYhit = std::max(chamberPos.y(), maxYhit);
340 }
341 m_out_gen_minYhit = minYhit;
342 m_out_gen_maxYhit = maxYhit;
343
344 const xAOD::TruthParticle* truthMuon = getTruthMatchedParticle(*segment);
345 if (truthMuon) {
346 using namespace xAOD::TruthHelpers;
347 m_out_gen_truthType = getParticleTruthType(*truthMuon);
348 m_out_gen_truthOrigin = getParticleTruthOrigin(*truthMuon);
349 }
350 }
MuonGMR4::MuonReadoutElement::msSector
const SpectrometerSector * msSector() const
Returns the pointer to the envelope volume enclosing all chambers in the sector.
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::localToGlobalTransform
const Amg::Transform3D & 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::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
Amg::Transform3D globalToLocalTransform(const ActsTrk::GeometryContext &gctx) const
Returns the global -> local transformation from the ATLAS global.
Definition SpectrometerSector.cxx:76
MuonValR4::MuonHoughTransformTester::m_out_gen_tanalpha
MuonVal::ScalarBranch< float > & m_out_gen_tanalpha
Definition MuonHoughTransformTester.h:169
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:175
MuonValR4::MuonHoughTransformTester::m_detMgr
const MuonGMR4::MuonDetectorManager * m_detMgr
Definition MuonHoughTransformTester.h:309
MuonValR4::MuonHoughTransformTester::m_out_gen_nStgcHits
MuonVal::ScalarBranch< unsigned short > & m_out_gen_nStgcHits
Definition MuonHoughTransformTester.h:184
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_nMmEtaHits
MuonVal::ScalarBranch< unsigned short > & m_out_gen_nMmEtaHits
Definition MuonHoughTransformTester.h:182
MuonValR4::MuonHoughTransformTester::m_out_gen_truthType
MuonVal::ScalarBranch< int > & m_out_gen_truthType
Definition MuonHoughTransformTester.h:174
MuonValR4::MuonHoughTransformTester::m_out_gen_truthPdgId
MuonVal::ScalarBranch< int > & m_out_gen_truthPdgId
Definition MuonHoughTransformTester.h:176
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:167
MuonValR4::MuonHoughTransformTester::m_out_gen_nMmStereoHits
MuonVal::ScalarBranch< unsigned short > & m_out_gen_nMmStereoHits
Definition MuonHoughTransformTester.h:183
MuonValR4::MuonHoughTransformTester::m_out_gen_Phi
MuonVal::ScalarBranch< float > & m_out_gen_Phi
Definition MuonHoughTransformTester.h:163
MuonValR4::MuonHoughTransformTester::m_out_gen_truthOrigin
MuonVal::ScalarBranch< int > & m_out_gen_truthOrigin
Definition MuonHoughTransformTester.h:173
MuonValR4::MuonHoughTransformTester::m_out_gen_maxYhit
MuonVal::ScalarBranch< float > & m_out_gen_maxYhit
Definition MuonHoughTransformTester.h:189
MuonValR4::MuonHoughTransformTester::m_out_gen_minYhit
MuonVal::ScalarBranch< float > & m_out_gen_minYhit
Definition MuonHoughTransformTester.h:188
MuonValR4::MuonHoughTransformTester::m_out_gen_nPrecHits
MuonVal::ScalarBranch< unsigned short > & m_out_gen_nPrecHits
Truth - hit count summary.
Definition MuonHoughTransformTester.h:179
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:171
MuonValR4::MuonHoughTransformTester::m_out_gen_x0
MuonVal::ScalarBranch< float > & m_out_gen_x0
Definition MuonHoughTransformTester.h:170
MuonValR4::MuonHoughTransformTester::m_out_gen_nTrigEtaHits
MuonVal::ScalarBranch< unsigned short > & m_out_gen_nTrigEtaHits
Definition MuonHoughTransformTester.h:180
MuonValR4::MuonHoughTransformTester::m_out_gen_tanbeta
MuonVal::ScalarBranch< float > & m_out_gen_tanbeta
Definition MuonHoughTransformTester.h:168
MuonValR4::MuonHoughTransformTester::m_out_gen_nTrigPhiHits
MuonVal::ScalarBranch< unsigned short > & m_out_gen_nTrigPhiHits
Definition MuonHoughTransformTester.h:181
Amg::Transform3D
Eigen::Affine3d Transform3D
Definition GeoPrimitives.h:46
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition GeoPrimitives.h:47
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

◆ 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 239 of file MuonHoughTransformTester.cxx.

239 {
240 ATH_CHECK(m_tree.write());
241 return StatusCode::SUCCESS;
242 }

◆ graph()

TGraph * AthHistogramming::graph ( const std::string & graphName,
const std::string & tDir = "",
const std::string & stream = "" )
protectedinherited

Simplify the retrieval of registered TGraphs.

Definition at line 453 of file AthHistogramming.cxx.

454{
455 // Build a 32 bit hash out of the name
456 const hash_t graphHash = this->hash(graphName);
457
458 // See if this entry exists in the map
459 GraphMap_t::const_iterator it = m_graphMap.find( graphHash );
460 if ( it == m_graphMap.end() ) // It doesn't exist!
461 { // Let's see into the THistSvc if somebody else has registered the TGraph...
462
463 // Need to copy the strings as we will massage them from here on
464 std::string graphNameCopy = graphName;
465 std::string tDirCopy = tDir;
466 std::string streamCopy = stream;
467
468 // Massage the final string to book things
469 std::string bookingString("");
470 this->buildBookingString( bookingString, graphNameCopy, tDirCopy, streamCopy, false);
471
472 TGraph* graphPointer(nullptr);
473 if ( !((histSvc()->getGraph(bookingString, graphPointer)).isSuccess()) )
474 {
475 // Massage the final string to book things
476 std::string bookingString("");
477 this->buildBookingString( bookingString, graphNameCopy, tDirCopy, streamCopy, true );
478
479 if ( !((histSvc()->getGraph(bookingString, graphPointer)).isSuccess()) )
480 {
481 m_msg << MSG::WARNING
482 << "Problem retrieving the TGraph with name (including pre- and post-fixes) "
483 << m_histNamePrefix + graphNameCopy + m_histNamePostfix
484 << " or with name " << graphNameCopy
485 << " in " << m_name << "... it doesn't exist, neither in the cached map nor in the THistSvc!"
486 << " Will return an NULL pointer... you have to handle it correctly!" << endmsg;
487 return nullptr;
488 }
489 // If we get to here, we actually found the TGraph in the THistSvc.
490 // So let's add it to the local cache map and return its pointer
491 m_graphMap.insert( m_graphMap.end(), std::pair< const hash_t, TGraph* >( graphHash, graphPointer ) );
492 return graphPointer;
493 }
494 // If we get to here, we actually found the TGraph in the THistSvc.
495 // So let's add it to the local cache map and return its pointer
496 m_graphMap.insert( m_graphMap.end(), std::pair< const hash_t, TGraph* >( graphHash, graphPointer ) );
497 return graphPointer;
498 }
499
500
501 // Return the pointer to the TGraph that we got from the local cache map
502 return it->second;
503}
AthenaInternal::getGraph
std::pair< StatusCode, TGraph * > getGraph(ITHistSvc &svc, const std::string &name)
Definition AthenaPythonDict.h:51

◆ hash()

AthHistogramming::hash_t AthHistogramming::hash ( const std::string & histName) const
inlineprivateinherited

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

Definition at line 430 of file AthHistogramming.h.

431{
432 const uint64_t hash64 = CxxUtils::crc64( histName );
433 return (hash_t)(hash64 & 0xFFFFFFFF);
434}
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:696
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 ( const std::string & histName,
const std::string & tDir = "",
const std::string & stream = "" )
protectedinherited

Simplify the retrieval of registered histograms of any type.

Definition at line 164 of file AthHistogramming.cxx.

167{
168 std::string histNameCopy = histName;
169 std::string tDirCopy = tDir;
170 std::string streamCopy = stream;
171
172 std::string bookingString;
173 this->buildBookingString(bookingString, histNameCopy, tDirCopy, streamCopy, false);
174
175 const hash_t histHash = this->hash(histNameCopy);
176
177 HistMap_t::const_iterator it = m_histMap.find(histHash);
178 if (it == m_histMap.end()) {
179 TH1* histPointer(nullptr);
180
181 if (!histSvc()->getHist(bookingString, histPointer).isSuccess()) {
182 std::string prefixedHistNameCopy = histName;
183 std::string prefixedTDirCopy = tDir;
184 std::string prefixedStreamCopy = stream;
185
186 std::string prefixedBookingString;
187 this->buildBookingString(prefixedBookingString,
188 prefixedHistNameCopy,
189 prefixedTDirCopy,
190 prefixedStreamCopy,
191 true);
192
193 if (!histSvc()->getHist(prefixedBookingString, histPointer).isSuccess()) {
194 m_msg << MSG::WARNING
195 << "Problem retrieving the histogram with name (including pre- and post-fixes) "
196 << m_histNamePrefix + histNameCopy + m_histNamePostfix
197 << " or with name " << histNameCopy
198 << " in " << m_name << "... it doesn't exist, neither in the cached map nor in the THistSvc!"
199 << " Will return an NULL pointer... you have to handle it correctly!" << endmsg;
200 return nullptr;
201 }
202 }
203
204 m_histMap.insert(m_histMap.end(), std::pair<const hash_t, TH1*>(histHash, histPointer));
205 return histPointer;
206 }
207
208 return it->second;
209}
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 ( const std::string & histName,
const std::string & tDir = "",
const std::string & stream = "" )
inlineprotectedinherited

Simplify the retrieval of registered 2-d histograms.

Definition at line 371 of file AthHistogramming.h.

372{
373 // Get the TH1 pointer
374 TH1* th1Pointer = this->hist(histName, tDir, stream);
375 if ( !th1Pointer )
376 {
377 m_msg << MSG::ERROR
378 << "Cannot get a 2-d histogram with name " << histName
379 << "... will probably seg-fault!" << endmsg;
380 return NULL;
381 }
382 // If the TH1 pointer is valid, simply return the dynamic_cast
383 return dynamic_cast<TH2*>( th1Pointer );
384}

◆ hist3d()

TH3 * AthHistogramming::hist3d ( const std::string & histName,
const std::string & tDir = "",
const std::string & stream = "" )
inlineprotectedinherited

Simplify the retrieval of registered 3-d histograms.

Definition at line 388 of file AthHistogramming.h.

389{
390 // Get the TH1 pointer
391 TH1* th1Pointer = this->hist(histName, tDir, stream);
392 if ( !th1Pointer )
393 {
394 m_msg << MSG::ERROR
395 << "Cannot get a 3-d histogram with name " << histName
396 << "... will probably seg-fault!" << endmsg;
397 return NULL;
398 }
399 // If the TH1 pointer is valid, simply return the dynamic_cast
400 return dynamic_cast<TH3*>( th1Pointer );
401}

◆ 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 56 of file MuonHoughTransformTester.cxx.

56 {
57 ATH_CHECK(m_geoCtxKey.initialize());
58
59 {
60 int infoOpts = 0;
61 if (m_isMC) infoOpts = EventInfoBranch::isMC;
62 m_tree.addBranch(std::make_unique<EventInfoBranch>(m_tree, infoOpts));
63 }
64
65 ATH_CHECK(m_recoSegKey.initialize());
66 for (const std::string& recoLink : m_recoSegLinks) {
67 m_truthSegLinkKeys.emplace_back(m_recoSegKey, recoLink);
68 }
69 ATH_CHECK(m_truthSegmentKey.initialize(!m_truthSegmentKey.empty()));
70 for (const std::string& link: m_truthLinks) {
71 m_truthSegLinkKeys.emplace_back(m_truthSegmentKey, link);
72 }
73 ATH_CHECK(m_truthSegLinkKeys.initialize(!m_truthSegmentKey.empty()));
74
76 ATH_CHECK(m_patternSeedKeys.initialize());
77 ATH_CHECK(m_spKeys.initialize(m_writeSpacePoints));
78 if (m_writeSpacePoints) {
79 m_spTester = std::make_unique<SpacePointTesterModule>(m_tree, m_spKeys.front().key(), msgLevel());
80 m_tree.addBranch(m_spTester);
81 } else {
82 m_tree.disableBranch(m_spMatchedToPattern.name());
83 m_tree.disableBranch(m_spMatchedToSegment.name());
84 }
85
86 for (std::size_t cov = 0 ; cov < m_segmentCov.size(); ++cov){
87 using namespace MuonR4::SegmentFit;
88 const auto [i, j] = Acts::symMatIndices<Acts::toUnderlying(ParamDefs::nPars)>(cov);
89 ParamDefs pI{static_cast<std::uint8_t>(i)},
90 pJ{static_cast<std::uint8_t>(j)};
91 std::string brName = (pI!= pJ) ? std::format("segment_cov_{:}_{:}", pI, pJ)
92 : std::format("segment_cov_{:}", pI);
93 m_segmentCov[cov] = std::make_shared<MuonVal::VectorBranch<float>>(m_tree, brName);
94 m_tree.addBranch(m_segmentCov[cov]);
95 }
96
97 ATH_CHECK(m_tree.init(this));
98 ATH_CHECK(m_idHelperSvc.retrieve());
99 ATH_CHECK(detStore()->retrieve(m_detMgr));
100
101 ATH_CHECK(m_visionTool.retrieve(EnableTool{!m_visionTool.empty()}));
102
103 return StatusCode::SUCCESS;
104 }
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 122 of file MuonHoughTransformTester.cxx.

124 {
125 std::vector<ObjectMatching> allAssociations{};
126 std::unordered_set<const SegmentSeed*> usedSeeds{};
129 for (const xAOD::MuonSegment* recoSeg : segmentContainer) {
130 const MuonR4::Segment* segment = detailedSegment(*recoSeg);
131 assert(segment != nullptr);
132 std::vector<ObjectMatching>::iterator assoc_itr = allAssociations.end();
133 const xAOD::MuonSegment* truthSeg = getMatchedTruthSegment(*recoSeg);
135 if (truthSeg) {
136 assoc_itr = std::ranges::find_if(allAssociations, [truthSeg](const ObjectMatching& obj){
137 return obj.truthSegment == truthSeg;
138 });
139 }
141 if (assoc_itr == allAssociations.end()) {
142 ObjectMatching& newObj = allAssociations.emplace_back();
143 newObj.chamber = m_detMgr->getSectorEnvelope(recoSeg->chamberIndex(),
144 recoSeg->sector(),
145 recoSeg->etaIndex());
146 newObj.truthSegment = truthSeg;
147 assoc_itr = allAssociations.end() -1;
148 }
149 ObjectMatching& assocObj{*assoc_itr};
150 assocObj.matchedSegments.push_back(recoSeg);
151 assocObj.matchedSeeds.push_back(segment->parent());
152 assocObj.matchedSeedFoundSegment.push_back(1);
153 usedSeeds.insert(segment->parent());
154 }
155
156 if (truthSegments) {
158 for (ObjectMatching& assocObj : allAssociations) {
159 if (!assocObj.truthSegment) {
160 continue;
161 }
162 std::ranges::sort(assocObj.matchedSegments,
163 [&](const xAOD::MuonSegment* a,
164 const xAOD::MuonSegment* b){
165 return countOnSameSide(*assocObj.truthSegment, *a) >
166 countOnSameSide(*assocObj.truthSegment, *b);
167 });
168 }
169 }
171 for (const SegmentSeed* seed : seedContainer) {
173 if (usedSeeds.count(seed)) {
174 continue;
175 }
177 std::vector<std::pair<const xAOD::MuonSegment*, std::size_t>> segCounts{};
178 std::unordered_set<const xAOD::MuonSimHit* > matchedHits = getMatchingSimHits(*seed);
179 for (const xAOD::MuonSimHit* hit : matchedHits) {
180 const xAOD::MuonSegment* truthSeg = getMatchedTruthSegment(*hit);
181 if (!truthSeg) {
182 continue;
183 }
184 auto count_itr = std::ranges::find_if(segCounts, [truthSeg](const auto& segCounter){
185 return segCounter.first == truthSeg;
186 });
187 if (count_itr != segCounts.end()) {
188 ++(count_itr->second);
189 } else {
190 segCounts.emplace_back(std::make_pair(truthSeg, 1ul));
191 }
192 }
194 std::ranges::sort(segCounts, [](const auto& a, const auto& b){
195 return a.second > b.second;
196 });
197 // Add a criterion on the number of counts?
198 const xAOD::MuonSegment* truthSeg = segCounts.size()
199 ? segCounts.front().first : nullptr;
200 if (truthSeg) {
201 auto assoc_itr = std::ranges::find_if(allAssociations,
202 [truthSeg](const ObjectMatching& obj){
203 return obj.truthSegment == truthSeg;
204 });
205 if (assoc_itr == allAssociations.end()) {
206 ObjectMatching & newObj = allAssociations.emplace_back();
207 newObj.chamber = seed->msSector();
208 newObj.truthSegment = truthSeg;
209 assoc_itr = allAssociations.end() -1;
210 }
211 assoc_itr->matchedSeeds.push_back(seed);
212 assoc_itr->matchedSeedFoundSegment.push_back(0);
213 } else {
214 ObjectMatching & newObj = allAssociations.emplace_back();
215 newObj.chamber = seed->msSector();
216 newObj.matchedSeeds.push_back(seed);
217 newObj.matchedSeedFoundSegment.push_back(0);
218 }
219 }
221 if (truthSegments) {
222 for (const xAOD::MuonSegment* truthSeg : *truthSegments) {
224 if (std::ranges::any_of(allAssociations, [truthSeg](const auto& assocObj){
225 return assocObj.truthSegment == truthSeg;
226 })) {
227 continue;
228 }
229 ObjectMatching & newObj = allAssociations.emplace_back();
230 newObj.chamber = m_detMgr->getSectorEnvelope(truthSeg->chamberIndex(),
231 truthSeg->sector(),
232 truthSeg->etaIndex());
233 newObj.truthSegment = truthSeg;
234 }
235 }
236 return allAssociations;
237 }
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

◆ 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 }

◆ myReplace()

void AthHistogramming::myReplace ( std::string & str,
const std::string & oldStr,
const std::string & newStr )
privateinherited

Helper method to replace sub-string.

Definition at line 551 of file AthHistogramming.cxx.

554{
555 size_t pos = 0;
556 while((pos = str.find(oldStr, pos)) != std::string::npos)
557 {
558 str.replace(pos, oldStr.length(), newStr);
559 pos += newStr.length();
560 }
561}

◆ 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 380 of file AthCommonDataStore.h.

381 {
382 h.renounce();
383 PBASE::renounce (h);
384 }
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:380

◆ renounceArray()

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

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

364 {
365 handlesArray.renounce();
366 }

◆ setFilterPassed()

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

Set filter decision:

Reimplemented in AthFilterAlgorithm.

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 by the derived classes to fill the internal configuration.
Definition AthHistogramming.cxx:51

◆ 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 ( const std::string & treeName,
const std::string & tDir = "",
const std::string & stream = "" )
protectedinherited

Simplify the retrieval of registered TTrees.

Definition at line 339 of file AthHistogramming.cxx.

340{
341 // Build a 32 bit hash out of the name
342 const hash_t treeHash = this->hash(treeName);
343
344 // See if this entry exists in the map
345 TreeMap_t::const_iterator it = m_treeMap.find( treeHash );
346 if ( it == m_treeMap.end() ) // It doesn't exist!
347 { // Let's see into the THistSvc if somebody else has registered the TTree...
348
349 // Need to copy the strings as we will massage them from here on
350 std::string treeNameCopy = treeName;
351 std::string tDirCopy = tDir;
352 std::string streamCopy = stream;
353
354 // Massage the final string to book things
355 std::string bookingString("");
356 this->buildBookingString( bookingString, treeNameCopy, tDirCopy, streamCopy );
357
358 TTree* treePointer(NULL);
359 if ( !((histSvc()->getTree(bookingString, treePointer)).isSuccess()) )
360 {
361 m_msg << MSG::WARNING
362 << "Problem retrieving the TTree with name " << treeNameCopy
363 << " in " << m_name << "... it doesn't exist, neither in the cached map nor in the THistSvc!"
364 << " Will return an NULL pointer... you have to handle it correctly!" << endmsg;
365 return NULL;
366 }
367 // If we get to here, we actually found the TTree in the THistSvc.
368 // So let's add it to the local cache map and return its pointer
369 m_treeMap.insert( m_treeMap.end(), std::pair< const hash_t, TTree* >( treeHash, treePointer ) );
370 return treePointer;
371 }
372
373 // Return the pointer to the TTree that we got from the local cache map
374 return it->second;
375}
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 308 of file AthCommonDataStore.h.

308 {
309 // debug() << "updateVHKA for property " << p.name() << " " << p.toString()
310 // << " size: " << m_vhka.size() << endmsg;
311 for (auto &a : m_vhka) {
312 std::vector<SG::VarHandleKey*> keys = a->keys();
313 for (auto k : keys) {
314 k->setOwner(this);
315 }
316 }
317 }

Member Data Documentation

◆ m_detMgr

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

Definition at line 309 of file MuonHoughTransformTester.h.

309{nullptr};

◆ m_detStore

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

Pointer to StoreGate (detector store by default).

Definition at line 393 of file AthCommonDataStore.h.

◆ m_effMap

EffMap_t AthHistogramming::m_effMap
privateinherited

The map of histogram names to their pointers.

Definition at line 210 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 390 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 224 of file AthHistogramming.h.

◆ m_histMap

HistMap_t AthHistogramming::m_histMap
privateinherited

The map of histogram names to their pointers.

Definition at line 203 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 250 of file AthHistogramming.h.

◆ m_name

std::string AthHistogramming::m_name
privateinherited

Instance name.

Definition at line 247 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_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 189 of file MuonHoughTransformTester.h.

189{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 188 of file MuonHoughTransformTester.h.

188{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 182 of file MuonHoughTransformTester.h.

182{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 183 of file MuonHoughTransformTester.h.

183{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 179 of file MuonHoughTransformTester.h.

179{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 184 of file MuonHoughTransformTester.h.

184{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 180 of file MuonHoughTransformTester.h.

180{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 181 of file MuonHoughTransformTester.h.

181{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 169 of file MuonHoughTransformTester.h.

169{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 168 of file MuonHoughTransformTester.h.

168{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 171 of file MuonHoughTransformTester.h.

171{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 175 of file MuonHoughTransformTester.h.

175{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

Definition at line 173 of file MuonHoughTransformTester.h.

173{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 176 of file MuonHoughTransformTester.h.

176{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 174 of file MuonHoughTransformTester.h.

174{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 170 of file MuonHoughTransformTester.h.

170{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 167 of file MuonHoughTransformTester.h.

167{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 197 of file MuonHoughTransformTester.h.

197{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 230 of file MuonHoughTransformTester.h.

230{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 206 of file MuonHoughTransformTester.h.

206{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 205 of file MuonHoughTransformTester.h.

205{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 193 of file MuonHoughTransformTester.h.

193{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 209 of file MuonHoughTransformTester.h.

209{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 216 of file MuonHoughTransformTester.h.

216{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 217 of file MuonHoughTransformTester.h.

217{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 210 of file MuonHoughTransformTester.h.

210{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 208 of file MuonHoughTransformTester.h.

208{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 224 of file MuonHoughTransformTester.h.

224{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 222 of file MuonHoughTransformTester.h.

222{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 223 of file MuonHoughTransformTester.h.

223{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 213 of file MuonHoughTransformTester.h.

213{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 219 of file MuonHoughTransformTester.h.

219{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 220 of file MuonHoughTransformTester.h.

220{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 214 of file MuonHoughTransformTester.h.

214{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 212 of file MuonHoughTransformTester.h.

212{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 228 of file MuonHoughTransformTester.h.

228{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 226 of file MuonHoughTransformTester.h.

226{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 227 of file MuonHoughTransformTester.h.

227{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 202 of file MuonHoughTransformTester.h.

202{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 201 of file MuonHoughTransformTester.h.

201{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 200 of file MuonHoughTransformTester.h.

200{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 199 of file MuonHoughTransformTester.h.

199{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 239 of file MuonHoughTransformTester.h.

239{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 242 of file MuonHoughTransformTester.h.

242{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 241 of file MuonHoughTransformTester.h.

241{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 304 of file MuonHoughTransformTester.h.

304{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 302 of file MuonHoughTransformTester.h.

302{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 303 of file MuonHoughTransformTester.h.

303{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 301 of file MuonHoughTransformTester.h.

301{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 235 of file MuonHoughTransformTester.h.

235{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 240 of file MuonHoughTransformTester.h.

240{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 276 of file MuonHoughTransformTester.h.

276{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 288 of file MuonHoughTransformTester.h.

288{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 277 of file MuonHoughTransformTester.h.

277{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 289 of file MuonHoughTransformTester.h.

289{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 282 of file MuonHoughTransformTester.h.

282{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 294 of file MuonHoughTransformTester.h.

294{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 283 of file MuonHoughTransformTester.h.

283{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 295 of file MuonHoughTransformTester.h.

295{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 255 of file MuonHoughTransformTester.h.

255{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 263 of file MuonHoughTransformTester.h.

263{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 259 of file MuonHoughTransformTester.h.

259{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 280 of file MuonHoughTransformTester.h.

280{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 292 of file MuonHoughTransformTester.h.

292{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 278 of file MuonHoughTransformTester.h.

278{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 290 of file MuonHoughTransformTester.h.

290{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 286 of file MuonHoughTransformTester.h.

286{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 298 of file MuonHoughTransformTester.h.

298{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 284 of file MuonHoughTransformTester.h.

284{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 296 of file MuonHoughTransformTester.h.

296{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 285 of file MuonHoughTransformTester.h.

285{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 297 of file MuonHoughTransformTester.h.

297{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 279 of file MuonHoughTransformTester.h.

279{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 291 of file MuonHoughTransformTester.h.

291{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 256 of file MuonHoughTransformTester.h.

256{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 264 of file MuonHoughTransformTester.h.

264{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 260 of file MuonHoughTransformTester.h.

260{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 257 of file MuonHoughTransformTester.h.

257{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 265 of file MuonHoughTransformTester.h.

265{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 261 of file MuonHoughTransformTester.h.

261{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 267 of file MuonHoughTransformTester.h.

267{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 271 of file MuonHoughTransformTester.h.

271{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 268 of file MuonHoughTransformTester.h.

268{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 272 of file MuonHoughTransformTester.h.

272{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 269 of file MuonHoughTransformTester.h.

269{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 273 of file MuonHoughTransformTester.h.

273{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 248 of file MuonHoughTransformTester.h.

248{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 247 of file MuonHoughTransformTester.h.

247{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 249 of file MuonHoughTransformTester.h.

249{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 246 of file MuonHoughTransformTester.h.

246{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 245 of file MuonHoughTransformTester.h.

245{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", "MuonSegmentsFromR4"}
private

Key to the xAOD::MuonSegment container.

Definition at line 104 of file MuonHoughTransformTester.h.

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

◆ 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 252 of file MuonHoughTransformTester.h.

252{};

◆ 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 228 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 217 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 399 of file AthCommonDataStore.h.

◆ m_vhka

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

Definition at line 398 of file AthCommonDataStore.h.

◆ m_visionTool

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

Pattern visualization tool.

Definition at line 307 of file MuonHoughTransformTester.h.

307{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.16.1