Muon::MuonLayerSegmentFinderTool Class Reference

#include <MuonLayerSegmentFinderTool.h>

Inheritance diagram for Muon::MuonLayerSegmentFinderTool:

Collaboration diagram for Muon::MuonLayerSegmentFinderTool:

Public Member Functions
	MuonLayerSegmentFinderTool (const std::string &type, const std::string &name, const IInterface *parent)
	Default AlgTool functions. More...
virtual	~MuonLayerSegmentFinderTool ()=default
StatusCode	initialize () override
void	find (const EventContext &ctx, const MuonSystemExtension::Intersection &intersection, const MuonLayerPrepRawData &layerPrepRawData, std::vector< std::shared_ptr< const Muon::MuonSegment > > &segments) const override
	IMuonLayerSegmentFinderTool interface: find. More...
void	findMdtSegmentsFromHough (const EventContext &ctx, const MuonSystemExtension::Intersection &intersection, std::vector< std::shared_ptr< const Muon::MuonSegment > > &segments) const override
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
const ServiceHandle< StoreGateSvc > &	evtStore () const
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm. More...
virtual StatusCode	sysStart () override
	Handle START transition. More...
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles. More...
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles. More...
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T > &t)
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc="none")
	Declare a new Gaudi property. More...
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
MsgStream &	msg (const MSG::Level lvl) const
bool	msgLvl (const MSG::Level lvl) const

Static Public Member Functions
static const InterfaceID &	interfaceID ()
	IAlgTool interface. More...

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution More...
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. More...

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
void	findClusterSegments (const EventContext &ctx, const MuonSystemExtension::Intersection &intersection, const MuonLayerPrepRawData &layerPrepRawData, std::vector< std::shared_ptr< const Muon::MuonSegment > > &segments) const
	find segments from PRD clusters More...
void	findCscSegments (const EventContext &ctx, const MuonLayerPrepRawData &layerPrepRawData, std::vector< std::shared_ptr< const Muon::MuonSegment > > &segments) const
	find csc segments More...
void	findMdtSegments (const MuonSystemExtension::Intersection &intersection, const MuonLayerPrepRawData &layerPrepRawData, std::vector< std::shared_ptr< const Muon::MuonSegment > > &segments) const
	find mdt segments from hits in the layer More...
void	findMdtSegments (const MuonSystemExtension::Intersection &intersection, const std::vector< const MdtDriftCircleOnTrack * > &mdts, const std::vector< const MuonClusterOnTrack * > &clusters, std::vector< std::shared_ptr< const Muon::MuonSegment > > &segments) const
	find mdt segments main routine More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
	specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
	specialization for handling Gaudi::Property<SG::VarHandleBase> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
	specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...

Private Attributes
ServiceHandle< Muon::IMuonIdHelperSvc >	m_idHelperSvc
PublicToolHandle< MuonEDMPrinterTool >	m_printer
ToolHandle< IMuonPRDSelectionTool >	m_muonPRDSelectionTool
ToolHandle< IMuonSegmentMaker >	m_segmentMaker
ToolHandle< ICscSegmentFinder >	m_csc2dSegmentFinder
ToolHandle< ICscSegmentFinder >	m_csc4dSegmentFinder
ToolHandle< IMuonNSWSegmentFinderTool >	m_clusterSegMakerNSW
ToolHandle< Muon::IMuonLayerSegmentMatchingTool >	m_segmentMatchingTool
SG::ReadHandleKey< Muon::HoughDataPerSectorVec >	m_houghDataPerSectorVecKey
	Use the hough data to find sectors in the speectrometer traversed by a muon. More...
SG::ReadHandleKey< Trk::SegmentCollection >	m_patternSegs {this,"InSegmentContainer","TrackMuonSegments"}
	Do not rebuild the segments if the segment is already built upstream. More...
const Muon::MuonSectorMapping	m_muonSectorMapping {}
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default) More...
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default) More...
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

Definition at line 34 of file MuonLayerSegmentFinderTool.h.

Member Typedef Documentation

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< AlgTool > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

MuonLayerSegmentFinderTool()

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

Default AlgTool functions.

Definition at line 22 of file MuonLayerSegmentFinderTool.cxx.

                                                                                                                                 :
        AthAlgTool(type, name, parent) {
        declareInterface<IMuonLayerSegmentFinderTool>(this);
    }

~MuonLayerSegmentFinderTool()

virtual Muon::MuonLayerSegmentFinderTool::~MuonLayerSegmentFinderTool ( )

virtualdefault

Member Function Documentation

declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl, const SG::VarHandleKeyArrayType &    )

inlineprivateinherited

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

Definition at line 170 of file AthCommonDataStore.h.

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

declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  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());
 
  }

declareGaudiProperty() [3/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl, const SG::VarHandleType &    )

inlineprivateinherited

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

Definition at line 184 of file AthCommonDataStore.h.

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

declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  t, const SG::NotHandleType &    )

inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

  {
    return PBASE::declareProperty(t);
  }

declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name, SG::VarHandleBase &  hndl, const std::string &  doc, const SG::VarHandleType &    )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

  {
    this->declare(hndl.vhKey());
    hndl.vhKey().setOwner(this);
 
    return PBASE::declareProperty(name,hndl,doc);
  }

declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name, SG::VarHandleKey &  hndl, const std::string &  doc, const SG::VarHandleKeyType &    )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

  {
    this->declare(hndl);
    hndl.setOwner(this);
 
    return PBASE::declareProperty(name,hndl,doc);
  }

declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name, SG::VarHandleKeyArray &  hndArr, const std::string &  doc, const SG::VarHandleKeyArrayType &    )

inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

  {
 
    // std::ostringstream ost;
    // ost << Algorithm::name() << " VHKA declareProp: " << name 
    //     << " size: " << hndArr.keys().size() 
    //     << " mode: " << hndArr.mode() 
    //     << "  vhka size: " << m_vhka.size()
    //     << "\n";
    // debug() << ost.str() << endmsg;
 
    hndArr.setOwner(this);
    m_vhka.push_back(&hndArr);
 
    Gaudi::Details::PropertyBase* p =  PBASE::declareProperty(name, hndArr, doc);
    if (p != 0) {
      p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
    } else {
      ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray " 
                    << name);
    }
 
    return p;
 
  }

declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name, T &  property, const std::string &  doc, const SG::NotHandleType &    )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

  {
    return PBASE::declareProperty(name, property, doc);
  }

declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name, T &  property, const std::string &  doc = "none"  )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

  {
    typedef typename SG::HandleClassifier<T>::type htype;
    return declareProperty (name, property, doc, htype());
  }

declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T > &  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< AlgTool > >::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() [1/2]

ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::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; }

evtStore() [2/2]

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( ) const

inlineinherited

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

Definition at line 90 of file AthCommonDataStore.h.

{ return m_evtStore; }

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::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

find()

void Muon::MuonLayerSegmentFinderTool::find ( const EventContext &  ctx, const MuonSystemExtension::Intersection &  intersection, const MuonLayerPrepRawData &  layerPrepRawData, std::vector< std::shared_ptr< const Muon::MuonSegment > > &  segments  ) const

overridevirtual

IMuonLayerSegmentFinderTool interface: find.

Implements Muon::IMuonLayerSegmentFinderTool.

Definition at line 42 of file MuonLayerSegmentFinderTool.cxx.

                                                                                                                                                          {
        ATH_MSG_VERBOSE(
            " Running segment finding in sector "
            << intersection.layerSurface.sector << " region " << MuonStationIndex::regionName(intersection.layerSurface.regionIndex)
            << " layer " << MuonStationIndex::layerName(intersection.layerSurface.layerIndex) << " intersection position: r "
            << intersection.trackParameters->position().perp() << " z " << intersection.trackParameters->position().z() << " locX "
            << intersection.trackParameters->parameters()[Trk::locX] << " locY " << intersection.trackParameters->parameters()[Trk::locY]
            << " phi " << intersection.trackParameters->position().phi());
 
        // run cluster hit based segment finding on PRDs
        findClusterSegments(ctx, intersection, layerPrepRawData, segments);
        ATH_MSG_VERBOSE(" findClusterSegments " << segments.size());
 
        // run standard MDT/Trigger hit segment finding either from Hough or hits
        findMdtSegments(intersection, layerPrepRawData, segments);
    }

findClusterSegments()

void Muon::MuonLayerSegmentFinderTool::findClusterSegments ( const EventContext &  ctx, const MuonSystemExtension::Intersection &  intersection, const MuonLayerPrepRawData &  layerPrepRawData, std::vector< std::shared_ptr< const Muon::MuonSegment > > &  segments  ) const

private

find segments from PRD clusters

Find whether the segment has some hits that are needed

Nope

Segment is compatible

If no NSW was reconstructed thus far there's no hope that we'll do it later as well. Give up Lasst, die Ihr eintretet, alle Hoffnung fahren!

Definition at line 97 of file MuonLayerSegmentFinderTool.cxx.

                                                                                                                          {
        // if there are CSC hits run CSC segment finding
        if (!layerPrepRawData.cscs.empty()) findCscSegments(ctx, layerPrepRawData, segments);
 
        // No need to call the NSW segment finding
        if (layerPrepRawData.mms.empty() && layerPrepRawData.stgcs.empty()) return;
 
        // NSW segment finding
        MuonLayerROTs layerROTs;
        if (!m_muonPRDSelectionTool->calibrateAndSelect(intersection, layerPrepRawData, layerROTs)) {
            ATH_MSG_WARNING("Failed to calibrate and select layer data");
            return;
        }
 
        ATH_MSG_DEBUG(" MM prds " << layerPrepRawData.mms.size() << " STGC prds " << layerPrepRawData.stgcs.size());
 
        // get STGC and MM clusters
        const std::vector<const MuonClusterOnTrack*>& clustersSTGC = layerROTs.getClusters(MuonStationIndex::STGC);
        const std::vector<const MuonClusterOnTrack*>& clustersMM = layerROTs.getClusters(MuonStationIndex::MM);
 
        using NSWSegmentCache = Muon::IMuonNSWSegmentFinderTool::SegmentMakingCache;
        NSWSegmentCache cache{};
 
       
        if (!clustersSTGC.empty()) {
            ATH_MSG_DEBUG(" STGC clusters " << clustersSTGC.size());
            std::transform(clustersSTGC.begin(), clustersSTGC.end(), std::back_inserter(cache.inputClust), 
                            [](const Muon::MuonClusterOnTrack* cl){ return std::unique_ptr<Muon::MuonClusterOnTrack>{cl->clone()};});
           
        }
        if (!clustersMM.empty()) {
            ATH_MSG_DEBUG(" MM clusters " << clustersMM.size());
            std::transform(clustersMM.begin(), clustersMM.end(), std::back_inserter(cache.inputClust), 
                            [](const Muon::MuonClusterOnTrack* cl){ return  std::unique_ptr<Muon::MuonClusterOnTrack>{cl->clone()};});            
        }
        if (cache.inputClust.empty()) return;
        
        
        if (!m_patternSegs.empty()) {
            std::set<Identifier> needed_rios{};        
            for (std::unique_ptr<const MuonClusterOnTrack>& clus : cache.inputClust) {
                needed_rios.insert(clus->identify());
            }
            SG::ReadHandle<Trk::SegmentCollection>  input_segs{m_patternSegs, ctx};
            for (const Trk::Segment *trk_seg : *input_segs) {
                const MuonSegment *seg = dynamic_cast<const Muon::MuonSegment *>(trk_seg);
                // Initial check that the segments are on the same detector side
                if (intersection.trackParameters->associatedSurface().center().z() * seg->globalPosition().z() < 0) continue;
            
                bool hasNSW{false};
                for (size_t n = 0; !hasNSW && n < seg->numberOfContainedROTs(); ++n) {
                    const MuonClusterOnTrack *clus = dynamic_cast<const MuonClusterOnTrack *>(seg->rioOnTrack(n));
                    hasNSW |=  (clus && needed_rios.count(clus->identify()));              
                }
                if (!hasNSW) continue;            
                if (m_segmentMatchingTool->match(ctx, intersection, *seg)) segments.emplace_back(seg->clone());
            }
            return;
        }
 
        m_clusterSegMakerNSW->find(ctx, cache);
        
        for (std::unique_ptr<MuonSegment>& seg : cache.constructedSegs) {
            ATH_MSG_DEBUG(" NSW segment " << m_printer->print(*seg));
            segments.emplace_back(std::move(seg));
        }        
    }

findCscSegments()

void Muon::MuonLayerSegmentFinderTool::findCscSegments ( const EventContext &  ctx, const MuonLayerPrepRawData &  layerPrepRawData, std::vector< std::shared_ptr< const Muon::MuonSegment > > &  segments  ) const

private

find csc segments

Definition at line 172 of file MuonLayerSegmentFinderTool.cxx.

                                                                                                                      {
        // run 2d segment finder
        std::unique_ptr<MuonSegmentCombinationCollection> combi2D = m_csc2dSegmentFinder->find(layerPrepRawData.cscs, ctx);
        if (!combi2D) return;
 
        // run 4d segment finder
        std::unique_ptr<MuonSegmentCombinationCollection> combi4D = m_csc4dSegmentFinder->find(*combi2D, ctx);
        if (!combi4D) return;
 
        // extract segments and clean-up memory
        for (auto com : *combi4D) {
            const Muon::MuonSegmentCombination& combi = *com;
            unsigned int nstations = combi.numberOfStations();
 
            // loop over chambers in combi and extract segments
            for (unsigned int i = 0; i < nstations; ++i) {
                // loop over segments in station
                Muon::MuonSegmentCombination::SegmentVec* segs = combi.stationSegments(i);
 
                // check if not empty
                if (!segs || segs->empty()) continue;
                // loop over new segments, copy them into collection
                for (std::unique_ptr<MuonSegment>& seg_it : *segs) {
                    ATH_MSG_DEBUG(" " << m_printer->print(*seg_it));
                    segments.emplace_back(std::move(seg_it));
                }
            }
        }
    }

findMdtSegments() [1/2]

void Muon::MuonLayerSegmentFinderTool::findMdtSegments ( const MuonSystemExtension::Intersection &  intersection, const MuonLayerPrepRawData &  layerPrepRawData, std::vector< std::shared_ptr< const Muon::MuonSegment > > &  segments  ) const

private

find mdt segments from hits in the layer

findMdtSegments() [2/2]

void Muon::MuonLayerSegmentFinderTool::findMdtSegments ( const MuonSystemExtension::Intersection &  intersection, const std::vector< const MdtDriftCircleOnTrack * > &  mdts, const std::vector< const MuonClusterOnTrack * > &  clusters, std::vector< std::shared_ptr< const Muon::MuonSegment > > &  segments  ) const

private

find mdt segments main routine

findMdtSegmentsFromHough()

void Muon::MuonLayerSegmentFinderTool::findMdtSegmentsFromHough ( const EventContext &  ctx, const MuonSystemExtension::Intersection &  intersection, std::vector< std::shared_ptr< const Muon::MuonSegment > > &  segments  ) const

overridevirtual

Implements Muon::IMuonLayerSegmentFinderTool.

Definition at line 202 of file MuonLayerSegmentFinderTool.cxx.

                                                                                                                               {
 
        if(m_houghDataPerSectorVecKey.empty()) return;
        unsigned int                          nprevSegments = segments.size();  // keep track of what is already there
        int                                   sector        = intersection.layerSurface.sector;
        MuonStationIndex::DetectorRegionIndex regionIndex   = intersection.layerSurface.regionIndex;
        MuonStationIndex::LayerIndex          layerIndex    = intersection.layerSurface.layerIndex;
 
        // get hough data
        SG::ReadHandle<MuonLayerHoughTool::HoughDataPerSectorVec> houghDataPerSectorVec{m_houghDataPerSectorVecKey, ctx};
        if (!houghDataPerSectorVec.isValid()) {
            ATH_MSG_ERROR("Hough data per sector vector not found");
            return;
        }
 
        // sanity check
        if (static_cast<int>(houghDataPerSectorVec->vec.size()) <= sector - 1) {
            ATH_MSG_WARNING(" MuonLayerHoughTool::HoughDataPerSectorVec smaller than sector "
                            << houghDataPerSectorVec->vec.size() << " sector " << sector);
            return;
        }
 
        // get hough maxima in the layer
        unsigned int sectorLayerHash = MuonStationIndex::sectorLayerHash(regionIndex, layerIndex);
        const MuonLayerHoughTool::HoughDataPerSector& houghDataPerSector = houghDataPerSectorVec->vec[sector - 1];
        ATH_MSG_DEBUG(" findMdtSegmentsFromHough: sector "
                    << sector << " " << MuonStationIndex::regionName(regionIndex) << " "
                    << MuonStationIndex::layerName(layerIndex) << " sector hash " << sectorLayerHash << " houghData "
                    << houghDataPerSectorVec->vec.size() << " " << houghDataPerSector.maxVec.size());
 
        // sanity check
        if (houghDataPerSector.maxVec.size() <= sectorLayerHash) {
            ATH_MSG_WARNING(" houghDataPerSector.maxVec.size() smaller than hash " << houghDataPerSector.maxVec.size()
                                                                                << " hash " << sectorLayerHash);
            return;
        }
        const MuonLayerHoughTool::MaximumVec& maxVec = houghDataPerSector.maxVec[sectorLayerHash];
 
        // get local coordinates in the layer frame
        bool barrelLike = intersection.layerSurface.regionIndex == MuonStationIndex::Barrel;
 
        float phi = intersection.trackParameters->position().phi();
 
        // in the endcaps take the r in the sector frame from the local position of the extrapolation
        float r = barrelLike ? m_muonSectorMapping.transformRToSector(intersection.trackParameters->position().perp(), phi,
                                                                    intersection.layerSurface.sector, true)
                            : intersection.trackParameters->parameters()[Trk::locX];
 
        float z     = intersection.trackParameters->position().z();
        float errx  = Amg::error(*intersection.trackParameters->covariance(), Trk::locX);
        float x     = barrelLike ? r : z;
        float y     = barrelLike ? z : r;
        float theta = std::atan2(x, y);
 
        ATH_MSG_DEBUG("  Got Hough maxima " << maxVec.size() << " extrapolated position in Hough space (" << x << "," << y
                                            << ") error " << errx << " "
                                            << " angle " << theta);
 
        // lambda to handle calibration and selection of MDTs
        std::vector<std::unique_ptr<const Trk::MeasurementBase>> garbage;
        auto handleMdt = [this, intersection, &garbage](const MdtPrepData& prd, std::vector<const MdtDriftCircleOnTrack*>& mdts) {
            const MdtDriftCircleOnTrack* mdt = m_muonPRDSelectionTool->calibrateAndSelect(intersection, prd);
            if (!mdt) return;
            mdts.push_back(mdt);
            garbage.emplace_back(mdt);
        };
 
 
        // lambda to handle calibration and selection of clusters
        auto handleCluster = [this, intersection,&garbage](const MuonCluster&                      prd,
                                                std::vector<const MuonClusterOnTrack*>& clusters) {
            const MuonClusterOnTrack* cluster = m_muonPRDSelectionTool->calibrateAndSelect(intersection, prd);
            if (!cluster) return;
            clusters.push_back(cluster);
            garbage.emplace_back(cluster);
        };
 
 
        // loop over maxima and associate them to the extrapolation
        MuonLayerHoughTool::MaximumVec::const_iterator mit     = maxVec.begin();
        MuonLayerHoughTool::MaximumVec::const_iterator mit_end = maxVec.end();
        for (; mit != mit_end; ++mit) {
            const MuonHough::MuonLayerHough::Maximum& maximum       = **mit;
            float                                     residual      = maximum.pos - y;
            float                                     residualTheta = maximum.theta - theta;
            float refPos   = (maximum.hough != nullptr) ? maximum.hough->m_descriptor.referencePosition : 0;
            float maxwidth = (maximum.binposmax - maximum.binposmin);
            if (maximum.hough) maxwidth *= maximum.hough->m_binsize;
            float pull = residual / std::hypot(errx ,  maxwidth * OneOverSqrt12);
 
            
            ATH_MSG_DEBUG("   Hough maximum " << maximum.max << " position (" << refPos << "," << maximum.pos
                                            << ") residual " << residual << " pull " << pull << " angle " << maximum.theta
                                            << " residual " << residualTheta);
 
            // select maximum
            if (std::abs(pull) > 5) continue;
 
            // loop over hits in maximum and add them to the hit list
            std::vector<const MdtDriftCircleOnTrack*>    mdts;
            std::vector<const MuonClusterOnTrack*>       clusters;
            for (const auto& hit : maximum.hits) {
 
                // treat the case that the hit is a composite TGC hit
                if (hit->tgc) {
                    for (const auto& prd : hit->tgc->etaCluster) {
                        handleCluster(*prd, clusters);
                    }
                } else if (hit->prd) {
                    Identifier id = hit->prd->identify();
                    if (m_idHelperSvc->isMdt(id))
                        handleMdt(static_cast<const MdtPrepData&>(*hit->prd), mdts);
                    else
                        handleCluster(static_cast<const MuonCluster&>(*hit->prd), clusters);
                }
            }
 
            // get phi hits
            const MuonLayerHoughTool::PhiMaximumVec& phiMaxVec =
                houghDataPerSector.phiMaxVec[intersection.layerSurface.regionIndex];
            ATH_MSG_DEBUG("   Got Phi Hough maxima " << phiMaxVec.size() << " phi " << phi);
 
            // loop over maxima and associate them to the extrapolation
            MuonLayerHoughTool::PhiMaximumVec::const_iterator pit     = phiMaxVec.begin();
            MuonLayerHoughTool::PhiMaximumVec::const_iterator pit_end = phiMaxVec.end();
            for (; pit != pit_end; ++pit) {
                const MuonHough::MuonPhiLayerHough::Maximum& maximum  = **pit;
                const float residual = deltaPhi( maximum.pos, phi);
                
                ATH_MSG_DEBUG("     Phi Hough maximum " << maximum.max << " phi " << maximum.pos << ") angle "
                                                        << maximum.pos << " residual " << residual);
 
                for (const auto& phi_hit : maximum.hits) {
                    // treat the case that the hit is a composite TGC hit
                    if (phi_hit->tgc) {
                        Identifier id = phi_hit->tgc->phiCluster.front()->identify();
                        if (m_idHelperSvc->layerIndex(id) != intersection.layerSurface.layerIndex) continue;
                        for (const auto& prd : phi_hit->tgc->phiCluster) handleCluster(*prd, clusters);
                    } else if (phi_hit->prd) {
                        Identifier id = phi_hit->prd->identify();
                        if (m_idHelperSvc->layerIndex(id) != intersection.layerSurface.layerIndex) continue;
                        handleCluster(static_cast<const MuonCluster&>(*phi_hit->prd), clusters);
                    }
                }
            }
 
            // call segment finder
            ATH_MSG_DEBUG("    Got hits: mdts " << mdts.size() << " clusters " << clusters.size());
            findMdtSegments(intersection, mdts, clusters, segments);
 
            // clean-up memory
            garbage.clear();
            ATH_MSG_DEBUG("  Done maximum: new segments " << segments.size() - nprevSegments);
        }
        ATH_MSG_DEBUG("  Done with layer: new segments " << segments.size() - nprevSegments);
   }

initialize()

StatusCode Muon::MuonLayerSegmentFinderTool::initialize ( )

override

Definition at line 27 of file MuonLayerSegmentFinderTool.cxx.

                                                      {
        ATH_CHECK(m_idHelperSvc.retrieve());
        ATH_CHECK(m_printer.retrieve());
        ATH_CHECK(m_muonPRDSelectionTool.retrieve());
        ATH_CHECK(m_segmentMaker.retrieve());
        ATH_CHECK(m_csc2dSegmentFinder.retrieve(DisableTool{!m_idHelperSvc->hasCSC() || m_csc2dSegmentFinder.empty()}));
        ATH_CHECK(m_csc4dSegmentFinder.retrieve(DisableTool{!m_idHelperSvc->hasCSC() || m_csc4dSegmentFinder.empty()}));
        ATH_CHECK(m_patternSegs.initialize(!m_patternSegs.empty()));
        ATH_CHECK(m_segmentMatchingTool.retrieve(DisableTool{m_patternSegs.empty()}));       
        ATH_CHECK(m_houghDataPerSectorVecKey.initialize(!m_houghDataPerSectorVecKey.empty()));        
        ATH_CHECK(m_clusterSegMakerNSW.retrieve(DisableTool{m_clusterSegMakerNSW.empty()|| !m_patternSegs.empty()}));
      
        return StatusCode::SUCCESS;
    }

inputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< AlgTool > >::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.

interfaceID()

static const InterfaceID& Muon::IMuonLayerSegmentFinderTool::interfaceID ( )

inlinestaticinherited

IAlgTool interface.

Definition at line 22 of file IMuonLayerSegmentFinderTool.h.

                                                {
            static const InterfaceID IID_IMuonLayerSegmentFinderTool("Muon::IMuonLayerSegmentFinderTool", 1, 0);
            return IID_IMuonLayerSegmentFinderTool;
        }

msg() [1/2]

MsgStream& AthCommonMsg< AlgTool >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msg() [2/2]

MsgStream& AthCommonMsg< AlgTool >::msg ( const MSG::Level  lvl ) const

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                  {
    return this->msgStream(lvl);
  }

msgLvl()

bool AthCommonMsg< AlgTool >::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< AlgTool > >::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< AlgTool > >::renounce ( T &  h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

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

renounceArray()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::renounceArray ( SG::VarHandleKeyArray &  handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )

overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in DerivationFramework::CfAthAlgTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and asg::AsgMetadataTool.

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::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< AlgTool > >::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_clusterSegMakerNSW

ToolHandle<IMuonNSWSegmentFinderTool> Muon::MuonLayerSegmentFinderTool::m_clusterSegMakerNSW

private

Initial value:

{
            this,
            "NSWMuonClusterSegmentFinderTool",
            "",
        }

Definition at line 100 of file MuonLayerSegmentFinderTool.h.

m_csc2dSegmentFinder

ToolHandle<ICscSegmentFinder> Muon::MuonLayerSegmentFinderTool::m_csc2dSegmentFinder

private

Initial value:

{
            this,
            "Csc2DSegmentMaker",
            "Csc2dSegmentMaker/Csc2dSegmentMaker",
        }

Definition at line 90 of file MuonLayerSegmentFinderTool.h.

m_csc4dSegmentFinder

ToolHandle<ICscSegmentFinder> Muon::MuonLayerSegmentFinderTool::m_csc4dSegmentFinder

private

Initial value:

{
            this,
            "Csc4DSegmentMaker",
            "Csc4dSegmentMaker/Csc4dSegmentMaker",
        }

Definition at line 95 of file MuonLayerSegmentFinderTool.h.

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

m_houghDataPerSectorVecKey

SG::ReadHandleKey<Muon::HoughDataPerSectorVec> Muon::MuonLayerSegmentFinderTool::m_houghDataPerSectorVecKey

private

Initial value:

{this, "HoughKey",
                                                                                   "", "HoughDataPerSectorVec key"}

Use the hough data to find sectors in the speectrometer traversed by a muon.

Definition at line 110 of file MuonLayerSegmentFinderTool.h.

m_idHelperSvc

ServiceHandle<Muon::IMuonIdHelperSvc> Muon::MuonLayerSegmentFinderTool::m_idHelperSvc

private

Initial value:

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

Definition at line 69 of file MuonLayerSegmentFinderTool.h.

m_muonPRDSelectionTool

ToolHandle<IMuonPRDSelectionTool> Muon::MuonLayerSegmentFinderTool::m_muonPRDSelectionTool

private

Initial value:

{
            this,
            "MuonPRDSelectionTool",
            "Muon::MuonPRDSelectionTool/MuonPRDSelectionTool",
        }

Definition at line 80 of file MuonLayerSegmentFinderTool.h.

m_muonSectorMapping

const Muon::MuonSectorMapping Muon::MuonLayerSegmentFinderTool::m_muonSectorMapping {}

private

Definition at line 116 of file MuonLayerSegmentFinderTool.h.

m_patternSegs

SG::ReadHandleKey<Trk::SegmentCollection> Muon::MuonLayerSegmentFinderTool::m_patternSegs {this,"InSegmentContainer","TrackMuonSegments"}

private

Do not rebuild the segments if the segment is already built upstream.

Definition at line 114 of file MuonLayerSegmentFinderTool.h.

m_printer

PublicToolHandle<MuonEDMPrinterTool> Muon::MuonLayerSegmentFinderTool::m_printer

private

Initial value:

{
            this,
            "MuonEDMPrinterTool",
            "Muon::MuonEDMPrinterTool/MuonEDMPrinterTool",
        }

Definition at line 75 of file MuonLayerSegmentFinderTool.h.

m_segmentMaker

ToolHandle<IMuonSegmentMaker> Muon::MuonLayerSegmentFinderTool::m_segmentMaker

private

Initial value:

{
            this,
            "SegmentMaker",
            "Muon::DCMathSegmentMaker/DCMathSegmentMaker",
        }

Definition at line 85 of file MuonLayerSegmentFinderTool.h.

m_segmentMatchingTool

ToolHandle<Muon::IMuonLayerSegmentMatchingTool> Muon::MuonLayerSegmentFinderTool::m_segmentMatchingTool

private

Initial value:

{
            this, "MuonLayerSegmentMatchingTool", "Muon::MuonLayerSegmentMatchingTool/MuonLayerSegmentMatchingTool"}

Definition at line 106 of file MuonLayerSegmentFinderTool.h.

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

---

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

• MuonLayerSegmentFinderTool.h
• MuonLayerSegmentFinderTool.cxx