MuonR4::PhiHoughTransformAlg Class Reference

Algorithm to handle the phi hough transform. More...

#include <PhiHoughTransformAlg.h>

Inheritance diagram for MuonR4::PhiHoughTransformAlg:

Collaboration diagram for MuonR4::PhiHoughTransformAlg:

Public Member Functions
virtual	~PhiHoughTransformAlg ()=default
virtual StatusCode	initialize () override
virtual StatusCode	execute (const EventContext &ctx) const override
virtual StatusCode	sysInitialize () override
	Override sysInitialize.
virtual bool	isClonable () const override
	Specify if the algorithm is clonable.
virtual unsigned int	cardinality () const override
	Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant.
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
virtual void	setFilterPassed (bool state, const EventContext &ctx) const
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
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.

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
void	prepareHoughPlane (HoughEventData &data) const
	prepare the hough plane once per event.
void	preProcessMaximum (const ActsTrk::GeometryContext &gctx, const MuonR4::HoughMaximum &maximum, HoughEventData &data) const
	pre-processing for a given input eta-maximum Counts potential phi-hits and defines the search space
std::unique_ptr< SegmentSeed >	recoverSinglePhiMax (HoughEventData &data, const MuonR4::HoughMaximum &maximum) const
	extend an eta maximum with just a single attached phi measurement.
std::vector< MuonR4::ActsPeakFinderForMuon::Maximum >	findRankedSegmentSeeds (const EventContext &ctx, HoughEventData &data, const MuonR4::HoughMaximum &maximum) const
	perform a hough search for the most promising phi extension of an eta-maximum Performs a local hough transform using the phi-measurements on the maximum and returns the maxima ranked by their compatibility with the eta-measurements on the maximum.
int	countIncompatibleEtaHits (const MuonR4::ActsPeakFinderForMuon::Maximum &phiMaximum, const MuonR4::HoughMaximum &etaMaximum) const
	helper to count the number of eta measurements that would be discarded for a given phi extension candidate.
std::unique_ptr< SegmentSeed >	buildSegmentSeed (const HoughMaximum &etaMax, const MuonR4::ActsPeakFinderForMuon::Maximum &phiMax) const
	constructs a segment seed from an eta maximum and a phi-extension.
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
ServiceHandle< Muon::IMuonIdHelperSvc >	m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}
	Handle to the IdHelperSvc.
SG::ReadHandleKey< EtaHoughMaxContainer >	m_maxima {this, "ReadKey", "MuonHoughStationMaxima"}
SG::WriteHandleKey< SegmentSeedContainer >	m_segmentSeeds {this, "WriteKey", "MuonHoughStationSegmentSeeds"}
SG::ReadHandleKey< ActsTrk::GeometryContext >	m_geoCtxKey {this, "AlignmentKey", "ActsAlignment", "cond handle key"}
ToolHandle< MuonValR4::IPatternVisualizationTool >	m_visionTool {this, "VisualizationTool", ""}
	Pattern visualization tool.
DoubleProperty	m_targetResoTanPhi {this, "ResolutionTargetTanAngle", 0.04}
DoubleProperty	m_targetResoIntercept {this, "ResolutionTargetIntercept", 30.}
DoubleProperty	m_minSigmasSearchTanPhi {this, "minSigmasSearchTanPhi", 1.}
DoubleProperty	m_minSigmasSearchIntercept {this, "minSigmasSearchIntercept", 1.}
IntegerProperty	m_nBinsTanPhi {this, "nBinsTanAngle", 5}
IntegerProperty	m_nBinsIntercept {this, "nBinsIntercept", 10}
IntegerProperty	m_maxEtaHolesOnMax {this, "maxEtaHoles", 1}
BooleanProperty	m_recoverSinglePhiWithBS {this, "recoverSinglePhiHitsWithBS", true}
BooleanProperty	m_downWeightMultiplePrd {this, "downWeightPrdMultiplicity", false}
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

Detailed Description

Algorithm to handle the phi hough transform.

This algorithm is responsible for extending existing hough maxima found in a previous eta-transform. It will try to form a phi extension from the phi-sensitive measurements attached to the maximum and remove incompatible ones. It will write MuonSegmentSeeds into the event store for downstream use.

Definition at line 33 of file PhiHoughTransformAlg.h.

Member Typedef Documentation

StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

~PhiHoughTransformAlg()

virtual MuonR4::PhiHoughTransformAlg::~PhiHoughTransformAlg ( )

virtualdefault

Member Function Documentation

buildSegmentSeed()

std::unique_ptr< SegmentSeed > MuonR4::PhiHoughTransformAlg::buildSegmentSeed ( const HoughMaximum & etaMax, const MuonR4::ActsPeakFinderForMuon::Maximum & phiMax ) const

private

constructs a segment seed from an eta maximum and a phi-extension.

Will keep all pure eta-measurements on the original maximum and add those eta-phi or pure phi measurements compatible with the extension.

Parameters

etaMax	the eta-maximum
phiMax	the phi-transform maximum

Returns

a SegmentSeed representing the updated candidate

Definition at line 66 of file PhiHoughTransformAlg.cxx.

                                                                                              {
        // book a new hit list
        std::vector<HoughHitType> hitsOnMax{}; 
        // copy the pure eta hits onto the hit list 
        std::ranges::copy_if(etaMax.getHitsInMax(), 
                             std::back_inserter(hitsOnMax), [](const HoughHitType &hit){
            return (hit->measuresEta() && !hit->measuresPhi()); 
        }); 
        // and then add all hits (2D and pure phi) from the phi-extension to it 
        hitsOnMax.insert(hitsOnMax.end(), phiMax.hitIdentifiers.begin(), phiMax.hitIdentifiers.end()); 
        // use this to construct the segment seed
        SpacePointPerLayerSorter sorter{};
        std::ranges::stable_sort(hitsOnMax, sorter);
        return std::make_unique<SegmentSeed>(etaMax.tanBeta(), etaMax.interceptY(), phiMax.x, phiMax.y, hitsOnMax.size(), std::move(hitsOnMax), etaMax.parentBucket());         
}

cardinality()

unsigned int AthCommonReentrantAlgorithm< Gaudi::Algorithm >::cardinality ( ) const

overridevirtualinherited

Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant.

Override this to return 0 for reentrant algorithms.

Definition at line 75 of file AthCommonReentrantAlgorithm.cxx.

{
  return 0;
}

countIncompatibleEtaHits()

int MuonR4::PhiHoughTransformAlg::countIncompatibleEtaHits ( const MuonR4::ActsPeakFinderForMuon::Maximum & phiMaximum, const MuonR4::HoughMaximum & etaMaximum ) const

private

helper to count the number of eta measurements that would be discarded for a given phi extension candidate.

Correct extensions should have a very small or zero number.

Parameters

phiMaximum	Phi-maximum to evaluate
etaMaximum	Eta-maximum the candidate was obtained from

Definition at line 46 of file PhiHoughTransformAlg.cxx.

                                                                                         {
    std::unordered_map<const xAOD::UncalibratedMeasurement*, bool> foundEtas;
    // loop over the original eta maximum and check all hits measuring the eta-coordinate 
    for (auto& hit : etaMaximum.getHitsInMax()) {
        if (hit->measuresEta() && hit->measuresPhi()) {
            auto [iter, added] = foundEtas.emplace(hit->primaryMeasurement(), false);
            // test if the PRD for the eta-measurement appears on at least 
            // one space point of this phi extension.
            // This will be done for all space points containing the eta-PRD
            iter->second |= phiMaximum.hitIdentifiers.count(hit);
        }
    }
    // count the number of eta PRD not compatible with this extension.
    return std::ranges::count_if(foundEtas,
                         [](const std::pair<const xAOD::UncalibratedMeasurement*, bool>& p) {
                             return !p.second;
                         });
}

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.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

declareProperty()

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

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                     {
    typedef typename SG::HandleClassifier<T>::type htype;
    return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
  }

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.

{ return m_detStore; }

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.

{ return m_evtStore; }

execute()

StatusCode MuonR4::PhiHoughTransformAlg::execute ( const EventContext & ctx ) const

overridevirtual

Definition at line 191 of file PhiHoughTransformAlg.cxx.

                                                                      {
   
    // read the inputs
    const EtaHoughMaxContainer* maxima{nullptr};
    ATH_CHECK(SG::get(maxima, m_maxima, ctx));
 
    const ActsTrk::GeometryContext* gctx{nullptr};
    ATH_CHECK(SG::get(gctx, m_geoCtxKey, ctx));
 
    // book the event data object
    HoughEventData eventData{};
 
    // prepare the accumulator
    prepareHoughPlane(eventData);
 
    // prepare our output collection
    SG::WriteHandle writeMaxima{m_segmentSeeds, ctx};
    ATH_CHECK(writeMaxima.record(std::make_unique<SegmentSeedContainer>()));
 
    // loop over the previously found eta-maxima for each station
    for (const HoughMaximum* max : *maxima) {
        // for each maximum, pre-process 
        ATH_MSG_VERBOSE("Search extra phi hits on maximum "<<max->msSector()->identString()<<", tanBeta: "<<max->tanBeta()
                     <<", y0: "<<max->interceptY());
        if (m_visionTool.isEnabled() && msgLvl(MSG::VERBOSE)) {
            for (const auto& truth : m_visionTool->getLabeledSegments(max->getHitsInMax())) {
                const Parameters truthPars = localSegmentPars(*truth);
                ATH_MSG_VERBOSE("Truth parameters "<<toString(truthPars)<<", tanAlpha: "
                            <<houghTanAlpha(Amg::dirFromAngles(truthPars[Acts::toUnderlying(ParamDefs::phi)],
                                                             truthPars[Acts::toUnderlying(ParamDefs::theta)])));
            }
        }
        preProcessMaximum(*gctx, *max, eventData); 
        bool foundSolution=false; 
        // if we have enough hits, run a phi transform 
        if (eventData.phiHitsOnMax > 1){        
            std::vector<ActsPeakFinderForMuon::Maximum> rankedSeeds = findRankedSegmentSeeds(ctx, eventData, *max); 
            for (auto & phiSolution : rankedSeeds){
                foundSolution = true; 
                const SegmentSeed* seed {writeMaxima->push_back(buildSegmentSeed(*max, phiSolution))};
                if (m_visionTool.isEnabled()) {
                    m_visionTool->visualizeSeed(ctx, *seed, "#phi pattern seed");
                }  
            }
        }
        ATH_MSG_VERBOSE("Solution found: "<<foundSolution);
        // if we do not have at least two phi-hits for a proper transform: 
        if (!foundSolution){
            // if we have a single phi hit, we can approximate the phi 
            // solution using the beam spot (as the IP is far). 
            // This is steered by a flag, and not appropriate for splashes
            // or cosmics. 
            if (m_recoverSinglePhiWithBS && eventData.phiHitsOnMax == 1){                
               const SegmentSeed* singleMax{writeMaxima->push_back(recoverSinglePhiMax(eventData,*max))};
               if (m_visionTool.isEnabled()) {
                    m_visionTool->visualizeSeed(ctx, *singleMax, "Single #phi hit recovery");
               } 
            }
            // otherwise we have no phi-solution, and we fall back to writing a 1D eta-maximum 
            else{ 
                writeMaxima->push_back(std::make_unique<SegmentSeed>(*max)); 
            }
        }   
    }
    // add the maxima for this station to the output
 
    return StatusCode::SUCCESS;
}

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 & AthCommonReentrantAlgorithm< 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 94 of file AthCommonReentrantAlgorithm.cxx.

{
  // If we didn't find any symlinks to add, just return the collection
  // from the base class.  Otherwise, return the extended collection.
  if (!m_extendedExtraObjects.empty()) {
    return m_extendedExtraObjects;
  }
  return BaseAlg::extraOutputDeps();
}

filterPassed()

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

inlinevirtualinherited

Definition at line 96 of file AthCommonReentrantAlgorithm.h.

                                                           {
    return execState( ctx ).filterPassed();
  }

findRankedSegmentSeeds()

std::vector< ActsPeakFinderForMuon::Maximum > MuonR4::PhiHoughTransformAlg::findRankedSegmentSeeds ( const EventContext & ctx, HoughEventData & data, const MuonR4::HoughMaximum & maximum ) const

private

perform a hough search for the most promising phi extension of an eta-maximum Performs a local hough transform using the phi-measurements on the maximum and returns the maxima ranked by their compatibility with the eta-measurements on the maximum.

Parameters

ctx	EventContext to access StoreGate
data	event data object
maximum	eta maximum to extend

Returns

: The best maxima found by the extension (lowest number of eta measurements that would need to be discarded)

Definition at line 133 of file PhiHoughTransformAlg.cxx.

                                                                                                                {
    std::unordered_map<int, std::vector<ActsPeakFinderForMuon::Maximum>>  rankedSeeds;  
    using namespace std::placeholders; 
    // reset the accumulator
    eventData.houghPlane->reset();
    // fill the accumulator with the phi measurements   
    for (auto hit : maximum.getHitsInMax()){
        if (!hit->measuresPhi()) {
            ATH_MSG_VERBOSE("Hit "<<m_idHelperSvc->toString(hit->identify())<<" does not have a phi measurement");
            continue;
        }
        ATH_MSG_VERBOSE("Fill hit "<<m_idHelperSvc->toString(hit->identify())<<", "<<Amg::toString(hit->localPosition()));
        eventData.houghPlane->fill<HoughHitType>(
            hit, eventData.currAxisRanges,
            HoughHelpers::Phi::houghParamStrip,
            std::bind(HoughHelpers::Phi::houghWidthStrip, _1, _2, m_targetResoIntercept), hit, 0, 
            // up-weigh 2D spacepoints w.r.t 1D phi hits to prevent 
            // discarding measurements known to be compatible in eta 
            (hit->measuresEta() ? 2.0 : 1.0) / (m_downWeightMultiplePrd? hit->nPhiInstanceCounts() : 1)
            );
    }
    // run the peak finder 
    auto foundMaxPhi = eventData.peakFinder->findPeaks(*eventData.houghPlane, eventData.currAxisRanges);
    if (m_visionTool.isEnabled()) {
        m_visionTool->visualizeAccumulator(ctx,*eventData.houghPlane, eventData.currAxisRanges, foundMaxPhi,
                                           "#phi accumulator");
    }
    // now rank the found peaks by the number of eta-compatible PRDs they would discard. 
    for (const auto& solution : foundMaxPhi) {
        // for each solution, count how many eta PRDs would not be compatible with this phi extension. 
        // rank by the lowest number of such "holes". 
        rankedSeeds[countIncompatibleEtaHits(solution, maximum)].push_back(solution); 
    }
    // return only the best solution(s) 
    auto best = rankedSeeds.begin(); 
    // and apply the maximum hole cut. 
    if (best != rankedSeeds.end() && best->first <= m_maxEtaHolesOnMax){
        return best->second; 
    } 
    return {}; 
}            

initialize()

StatusCode MuonR4::PhiHoughTransformAlg::initialize ( )

overridevirtual

Definition at line 24 of file PhiHoughTransformAlg.cxx.

                                            {
    ATH_CHECK(m_geoCtxKey.initialize());
    ATH_CHECK(m_maxima.initialize());
    ATH_CHECK(m_segmentSeeds.initialize());
    ATH_CHECK(m_visionTool.retrieve(EnableTool{!m_visionTool.empty()}));
    ATH_CHECK(m_idHelperSvc.retrieve());
    return StatusCode::SUCCESS;
}

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()

bool AthCommonReentrantAlgorithm< Gaudi::Algorithm >::isClonable ( ) const

overridevirtualinherited

Specify if the algorithm is clonable.

Reentrant algorithms are clonable.

Reimplemented in InDet::GNNSeedingTrackMaker, InDet::SCT_Clusterization, InDet::SiSPGNNTrackMaker, InDet::SiSPSeededTrackFinder, InDet::SiTrackerSpacePointFinder, ITkPixelCablingAlg, ITkStripCablingAlg, RoIBResultToxAOD, SCT_ByteStreamErrorsTestAlg, SCT_CablingCondAlgFromCoraCool, SCT_CablingCondAlgFromText, SCT_ConditionsParameterTestAlg, SCT_ConditionsSummaryTestAlg, SCT_ConfigurationConditionsTestAlg, 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, and Simulation::BeamEffectsAlg.

Definition at line 68 of file AthCommonReentrantAlgorithm.cxx.

{
  // Reentrant algorithms are clonable.
  return true;
}

msg()

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

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

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

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.

prepareHoughPlane()

void MuonR4::PhiHoughTransformAlg::prepareHoughPlane ( HoughEventData & data ) const

private

prepare the hough plane once per event.

Books the accumulator and attaches it to the event data

Parameters

data	Event data object

Returns

a status code

Definition at line 32 of file PhiHoughTransformAlg.cxx.

                                                                       {
    HoughPlaneConfig cfg;
    cfg.nBinsX = m_nBinsTanPhi;
    cfg.nBinsY = m_nBinsIntercept;
    // configure the peak finder for the phi-extension. 
    // Expect "shallow" maxima with 2-3 hits. 
    ActsPeakFinderForMuonCfg peakFinderCfg;
    peakFinderCfg.fractionCutoff = 0.4;
    peakFinderCfg.threshold = 2;    // 2D spacepoints receive a weight of 2
    peakFinderCfg.minSpacingBetweenPeaks = {0., 30.};
    data.houghPlane = std::make_unique<HoughPlane>(cfg);
    data.peakFinder = std::make_unique<ActsPeakFinderForMuon>(peakFinderCfg);
}

preProcessMaximum()

void MuonR4::PhiHoughTransformAlg::preProcessMaximum ( const ActsTrk::GeometryContext & gctx, const MuonR4::HoughMaximum & maximum, HoughEventData & data ) const

private

pre-processing for a given input eta-maximum Counts potential phi-hits and defines the search space

Parameters

gctx	The geometry context to fetch the global positions
maximum	An (eta) maximum
data	Event data object

Returns

a status code

Definition at line 83 of file PhiHoughTransformAlg.cxx.

                                                                             {
    // reset the event data 
    eventData.phiHitsOnMax = 0; 
    eventData.searchSpaceTanAngle = std::make_pair(resetVal, -resetVal); 
    eventData.searchSpaceIntercept = std::make_pair(resetVal, -resetVal); 
    // loop over the measurements on the maximum
    for (auto hit : maximum.getHitsInMax()) {
        // reject the pure eta measurements - not relevant here
        if (!hit->measuresPhi()) {
            continue;
        }
        // find the direction of the IP viewed from the sector frame 
        const Amg::Vector3D extrapDir = (hit->localPosition() - hit->msSector()->globalToLocalTrans(gctx).translation()).unit();
        ATH_MSG_VERBOSE("Direction "<<Amg::toString(extrapDir));
        // express the x location of our phi hits on the chamber plane (z = 0) when projecting from the beam spot
        std::optional<double> dummyIntercept = Amg::intersect<3>(hit->localPosition(), extrapDir, Amg::Vector3D::UnitZ(),0); 
        double x0 = (hit->localPosition() + dummyIntercept.value_or(0) * extrapDir).x(); 
        // now we can obtain the most likely tan(phi) via the pointing vector from the origin to our hit
        double tanAlpha = houghTanAlpha(extrapDir); 
        // update our search space with this info 
        eventData.updateSearchWindow(eventData.searchSpaceTanAngle, tanAlpha);
        eventData.updateSearchWindow(eventData.searchSpaceIntercept, x0);
        // and increment the hit counter
        ++eventData.phiHitsOnMax; 
    }
    // now use the results from the individual hits to define an axis range adapted to the binning we desire 
    double chamberCenter = (eventData.searchSpaceIntercept.second + eventData.searchSpaceIntercept.first) * 0.5; 
    double searchStart = chamberCenter - 0.5 * eventData.houghPlane->nBinsY() * m_targetResoIntercept; 
    double searchEnd = chamberCenter + 0.5 * eventData.houghPlane->nBinsY()  * m_targetResoIntercept; 
    // Protection for very wide buckets - if the search space does not cover all of the bucket, widen the bin size 
    // so that we cover everything  
    searchStart = std::min(searchStart, eventData.searchSpaceIntercept.first- m_minSigmasSearchIntercept * m_targetResoIntercept); 
    searchEnd = std::max(searchEnd, eventData.searchSpaceIntercept.second + m_minSigmasSearchIntercept * m_targetResoIntercept); 
    // also treat tan(phi) 
    double tanPhiMean = 0.5 * (eventData.searchSpaceTanAngle.first + eventData.searchSpaceTanAngle.second); 
    double searchStartTanPhi = tanPhiMean - 0.5 *  eventData.houghPlane->nBinsX() * m_targetResoTanPhi; 
    double searchEndTanPhi = tanPhiMean + 0.5* eventData.houghPlane->nBinsX() * m_targetResoTanPhi; 
    searchStartTanPhi = std::min(searchStartTanPhi, eventData.searchSpaceTanAngle.first- m_minSigmasSearchTanPhi * m_targetResoTanPhi); 
    searchEndTanPhi = std::max(searchEndTanPhi, eventData.searchSpaceTanAngle.second + m_minSigmasSearchTanPhi * m_targetResoTanPhi); 
 
    // and update the axis ranges for the search space according to our results
    eventData.currAxisRanges =
    Acts::HoughTransformUtils::HoughAxisRanges{searchStartTanPhi, searchEndTanPhi, searchStart, searchEnd};
    ATH_MSG_VERBOSE("Accumulator search window: tanAlpha: ["<<searchStartTanPhi<<";"<<searchEndTanPhi<<"], x0: ["
                <<searchStart<<";"<<searchEnd<<"]");
}

recoverSinglePhiMax()

std::unique_ptr< SegmentSeed > MuonR4::PhiHoughTransformAlg::recoverSinglePhiMax ( HoughEventData & data, const MuonR4::HoughMaximum & maximum ) const

private

extend an eta maximum with just a single attached phi measurement.

Uses the beam spot direction to guess an approximate phi-intercept and direction.

Parameters

data	event data object
maximum	eta-maximum to extend

Returns

a SegmentSeed extended using the pointing assumption

Definition at line 176 of file PhiHoughTransformAlg.cxx.

                                                                                                      {
    // recovers cases of a single phi hit assuming a straight 
    // line extrapolation from the beam line to the phi measurement
    std::vector<HoughHitType> hits{maximum.getHitsInMax()};
    SpacePointPerLayerSorter sorter{};
    std::ranges::stable_sort(hits, sorter);
    return std::make_unique<SegmentSeed>(maximum.tanBeta(), maximum.interceptY(), 
                        data.searchSpaceTanAngle.first, 
                        data.searchSpaceIntercept.first, 
                        maximum.getCounts(), 
                        std::move(hits), maximum.parentBucket()); 
 
} 

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.

  {
    h.renounce();
    PBASE::renounce (h);
  }

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.

                                                          {
    handlesArray.renounce();
  }

setFilterPassed()

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

inlinevirtualinherited

Definition at line 100 of file AthCommonReentrantAlgorithm.h.

                                                                            {
    execState( ctx ).setFilterPassed( state );
  }

sysExecute()

StatusCode AthCommonReentrantAlgorithm< 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.

Definition at line 85 of file AthCommonReentrantAlgorithm.cxx.

{
  return BaseAlg::sysExecute (ctx);
}

sysInitialize()

StatusCode AthCommonReentrantAlgorithm< Gaudi::Algorithm >::sysInitialize ( )

overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

Loop through all output handles, and if they're WriteCondHandles, automatically register them and this Algorithm with the CondSvc

Scan through all outputHandles, and if they're WriteCondHandles, register them with the CondSvc

Reimplemented from AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >.

Reimplemented in HypoBase, and InputMakerBase.

Definition at line 61 of file AthCommonReentrantAlgorithm.cxx.

                                                               {
  StatusCode sc=AthCommonDataStore<AthCommonMsg<BaseAlg>>::sysInitialize();
 
  if (sc.isFailure()) {
    return sc;
  }
  
  ServiceHandle<ICondSvc> cs("CondSvc",name());
  for (auto h : outputHandles()) {
    if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
      // do this inside the loop so we don't create the CondSvc until needed
      if ( cs.retrieve().isFailure() ) {
        ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
        return StatusCode::SUCCESS;
      }      
      if (cs->regHandle(this,*h).isFailure()) {
        sc = StatusCode::FAILURE;
        ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
                      << " with CondSvc");
      }
    }
  }
  return sc;  
}

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.

updateVHKA()

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

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

Member Data Documentation

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_downWeightMultiplePrd

BooleanProperty MuonR4::PhiHoughTransformAlg::m_downWeightMultiplePrd {this, "downWeightPrdMultiplicity", false}

private

Definition at line 125 of file PhiHoughTransformAlg.h.

{this, "downWeightPrdMultiplicity", false};

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 AthCommonReentrantAlgorithm< Gaudi::Algorithm >::m_extendedExtraObjects

privateinherited

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

Empty if no symlinks were found.

Definition at line 114 of file AthCommonReentrantAlgorithm.h.

m_geoCtxKey

SG::ReadHandleKey<ActsTrk::GeometryContext> MuonR4::PhiHoughTransformAlg::m_geoCtxKey {this, "AlignmentKey", "ActsAlignment", "cond handle key"}

private

Definition at line 98 of file PhiHoughTransformAlg.h.

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

m_idHelperSvc

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

private

Handle to the IdHelperSvc.

Definition at line 91 of file PhiHoughTransformAlg.h.

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

m_maxEtaHolesOnMax

IntegerProperty MuonR4::PhiHoughTransformAlg::m_maxEtaHolesOnMax {this, "maxEtaHoles", 1}

private

Definition at line 119 of file PhiHoughTransformAlg.h.

{this, "maxEtaHoles", 1};

m_maxima

SG::ReadHandleKey<EtaHoughMaxContainer> MuonR4::PhiHoughTransformAlg::m_maxima {this, "ReadKey", "MuonHoughStationMaxima"}

private

Definition at line 94 of file PhiHoughTransformAlg.h.

{this, "ReadKey", "MuonHoughStationMaxima"};

m_minSigmasSearchIntercept

DoubleProperty MuonR4::PhiHoughTransformAlg::m_minSigmasSearchIntercept {this, "minSigmasSearchIntercept", 1.}

private

Definition at line 110 of file PhiHoughTransformAlg.h.

{this, "minSigmasSearchIntercept", 1.};

m_minSigmasSearchTanPhi

DoubleProperty MuonR4::PhiHoughTransformAlg::m_minSigmasSearchTanPhi {this, "minSigmasSearchTanPhi", 1.}

private

Definition at line 107 of file PhiHoughTransformAlg.h.

{this, "minSigmasSearchTanPhi", 1.};

m_nBinsIntercept

IntegerProperty MuonR4::PhiHoughTransformAlg::m_nBinsIntercept {this, "nBinsIntercept", 10}

private

Definition at line 116 of file PhiHoughTransformAlg.h.

{this, "nBinsIntercept", 10};

m_nBinsTanPhi

IntegerProperty MuonR4::PhiHoughTransformAlg::m_nBinsTanPhi {this, "nBinsTanAngle", 5}

private

Definition at line 114 of file PhiHoughTransformAlg.h.

{this, "nBinsTanAngle", 5};

m_recoverSinglePhiWithBS

BooleanProperty MuonR4::PhiHoughTransformAlg::m_recoverSinglePhiWithBS {this, "recoverSinglePhiHitsWithBS", true}

private

Definition at line 122 of file PhiHoughTransformAlg.h.

{this, "recoverSinglePhiHitsWithBS", true};

m_segmentSeeds

SG::WriteHandleKey<SegmentSeedContainer> MuonR4::PhiHoughTransformAlg::m_segmentSeeds {this, "WriteKey", "MuonHoughStationSegmentSeeds"}

private

Definition at line 96 of file PhiHoughTransformAlg.h.

{this, "WriteKey", "MuonHoughStationSegmentSeeds"};

m_targetResoIntercept

DoubleProperty MuonR4::PhiHoughTransformAlg::m_targetResoIntercept {this, "ResolutionTargetIntercept", 30.}

private

Definition at line 104 of file PhiHoughTransformAlg.h.

{this, "ResolutionTargetIntercept", 30.};

m_targetResoTanPhi

DoubleProperty MuonR4::PhiHoughTransformAlg::m_targetResoTanPhi {this, "ResolutionTargetTanAngle", 0.04}

private

Definition at line 102 of file PhiHoughTransformAlg.h.

{this, "ResolutionTargetTanAngle", 0.04};

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> MuonR4::PhiHoughTransformAlg::m_visionTool {this, "VisualizationTool", ""}

private

Pattern visualization tool.

Definition at line 100 of file PhiHoughTransformAlg.h.

{this, "VisualizationTool", ""};

---

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

• PhiHoughTransformAlg.h
• PhiHoughTransformAlg.cxx