#include <MuonSegmentCombinationCleanerTool.h>

Inheritance diagram for Muon::MuonSegmentCombinationCleanerTool:

Collaboration diagram for Muon::MuonSegmentCombinationCleanerTool:

Public Member Functions
	MuonSegmentCombinationCleanerTool (const std::string &, const std::string &, const IInterface *)
	constructor More...

virtual	~MuonSegmentCombinationCleanerTool ()=default
	destructor More...

virtual StatusCode	initialize () override
	initializes private members More...

std::unique_ptr< MuonSegmentCombinationCollection >	clean (const MuonSegmentCombinationCollection &combiCol, MuonSegmentCombPatternCombAssociationMap *segPattMap) const override
	clean segment combination collections More...

std::unique_ptr< MuonSegmentCombination >	removeDuplicateSegments (MuonSegmentCombination &combi) const
	remove duplicates from a segment combination, returns a nullptr More...

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 ()
	access to tool 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	cleanAndMergeCombis (const MuonSegmentCombinationCollection &combiCol, std::unique_ptr< MuonSegmentCombinationCollection > &combiCleanCol, MuonSegmentCombPatternCombAssociationMap *segPattMap) const
	remove overlaps between combination and merge combinations with large overlap More...

bool	subSetOfPrevious (MuonSegmentCombiSummary &summary, std::vector< MuonSegmentCombiSummary > &summaries) const
	check whether current summary is a subset of the previous once More...

MuonSegmentCombiOverlapSummary	calculateOverlap (MuonSegmentCombiSummary &summary1, MuonSegmentCombiSummary &summary2) const
	calculate overlap between two summaries More...

void	resolveLayerOverlap (const std::vector< MuonSegment * > &chamberVec1, const std::vector< MuonSegment * > &chamberVec2, MuonSegmentCombiOverlapSummary &summary) const

void	fillSummary (MuonSegmentCombiSummary &combi) const
	create summary More...

std::string	print (MuonSegmentCombiSummary &summary) const
	print summaries 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...

Static Private Member Functions
static std::string	print (MuonSegmentCombiOverlapSummary &summary)

Private Attributes
ToolHandle< Muon::MuonEDMPrinterTool >	m_printer

ToolHandle< IMuonSegmentOverlapRemovalTool >	m_overlapRemovalTool

ServiceHandle< Muon::IMuonEDMHelperSvc >	m_edmHelperSvc

ServiceHandle< Muon::IMuonIdHelperSvc >	m_idHelperSvc

Gaudi::Property< bool >	m_mergeAllCombis {this, "MergeAllCombis", false, "merge all combinations into one large combination"}
	If set to true, all combinaties will be merged into one big one. More...

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 28 of file MuonSegmentCombinationCleanerTool.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

◆ MuonSegmentCombinationCleanerTool()

Muon::MuonSegmentCombinationCleanerTool::MuonSegmentCombinationCleanerTool	(	const std::string &	t,
		const std::string &	n,
		const IInterface *	p
	)

constructor

Definition at line 22 of file MuonSegmentCombinationCleanerTool.cxx.

                                                                                                                                     :
         AthAlgTool(t, n, p) {
         declareInterface<IMuonSegmentCombinationCleanerTool>(this);
     }

◆ ~MuonSegmentCombinationCleanerTool()

virtual Muon::MuonSegmentCombinationCleanerTool::~MuonSegmentCombinationCleanerTool ( )

virtualdefault

destructor

Member Function Documentation

◆ calculateOverlap()

MuonSegmentCombiOverlapSummary Muon::MuonSegmentCombinationCleanerTool::calculateOverlap	(	MuonSegmentCombiSummary &	summary1,
		MuonSegmentCombiSummary &	summary2
	)		const

private

calculate overlap between two summaries

Definition at line 254 of file MuonSegmentCombinationCleanerTool.cxx.

                                                                                                                                 {
         ATH_MSG_DEBUG(" calculating overlap, size first " << summary1.nsegments << " size second " << summary2.nsegments);
  
         MuonSegmentCombiOverlapSummary summary;
  
         // loop over all chamber layers and compare per layer
         for (unsigned int i = 0; i < MuonStationIndex::ChIndexMax; ++i) {
             // get segment in chamber layer
             MuonSegmentCombiSummary::SegVec& chamberVec1 = summary1.chamberSegments(i);
             MuonSegmentCombiSummary::SegVec& chamberVec2 = summary2.chamberSegments(i);
  
             // if both no segments do nothing
             if (chamberVec1.empty() && chamberVec2.empty()) continue;
  
             // if both not empty compare the two, exception for CSCs
             if (!chamberVec1.empty() && !chamberVec2.empty()) {
                 ATH_MSG_DEBUG(" resolving chambe layer " << MuonStationIndex::chName((MuonStationIndex::ChIndex)i));
  
                 resolveLayerOverlap(chamberVec1, chamberVec2, summary);
  
             } else {
                 if (!chamberVec1.empty()) summary.uniqueFirst.insert(summary.uniqueFirst.begin(), chamberVec1.begin(), chamberVec1.end());
                 if (!chamberVec2.empty()) summary.uniqueSecond.insert(summary.uniqueSecond.begin(), chamberVec2.begin(), chamberVec2.end());
             }
         }
         ATH_MSG_VERBOSE(print(summary));
         return summary;
     }

◆ clean()

std::unique_ptr< MuonSegmentCombinationCollection > Muon::MuonSegmentCombinationCleanerTool::clean	(	const MuonSegmentCombinationCollection &	combiCol,
		MuonSegmentCombPatternCombAssociationMap *	segPattMap
	)		const

overridevirtual

clean segment combination collections

Implements Muon::IMuonSegmentCombinationCleanerTool.

Definition at line 37 of file MuonSegmentCombinationCleanerTool.cxx.

                                                                                                                       {
         std::unique_ptr<MuonSegmentCombinationCollection> combiCleanCol = std::make_unique<MuonSegmentCombinationCollection>();
  
         cleanAndMergeCombis(combiCol, combiCleanCol, segPattMap);
  
         return combiCleanCol;
     }

◆ cleanAndMergeCombis()

void Muon::MuonSegmentCombinationCleanerTool::cleanAndMergeCombis	(	const MuonSegmentCombinationCollection &	combiCol,
		std::unique_ptr< MuonSegmentCombinationCollection > &	combiCleanCol,
		MuonSegmentCombPatternCombAssociationMap *	segPattMap
	)		const

private

remove overlaps between combination and merge combinations with large overlap

No duplicates were actually removed

Definition at line 46 of file MuonSegmentCombinationCleanerTool.cxx.

                                                                                                                             {
         ATH_MSG_DEBUG(" cleaning combis " << combiCol.size());
  
         std::vector<MuonSegmentCombiSummary> summaries;
  
         for (const Muon::MuonSegmentCombination* combi : combiCol) {
             if (!combi) {
                 ATH_MSG_INFO(" empty MuonSegmentCombination!!! ");
                 continue;
             }
  
             MuonSegmentCombiSummary summary{*combi};
             fillSummary(summary);
             ATH_MSG_VERBOSE(print(summary));
  
             if (summary.stations.size() < 2) {
                 // keep combination if Endcap middle
                 if (summary.stations.count(MuonStationIndex::EM)) {
                     ATH_MSG_VERBOSE(" Keeping single station endcap middle MuonSegmentCombination ");
  
                 } else {
                     ATH_MSG_DEBUG(" MuonSegmentCombination has too few station layers, rejecting  ");
                     continue;
                 }
             }
  
             if (summary.stationsGood.empty()) {
                 ATH_MSG_DEBUG(" MuonSegmentCombination has no station layer with good segment, rejecting  ");
                 continue;
             }
  
             if (!subSetOfPrevious(summary, summaries)) { summaries.emplace_back(std::move(summary)); }
         }
  
         for (MuonSegmentCombiSummary& summary : summaries) {
             // check whether there is an original, if so pass the pointer else clone the combi as it comes from the input
             // collection
  
             std::unique_ptr<MuonSegmentCombination> finalCombi = m_overlapRemovalTool->removeDuplicates(summary.segmentCombination());
  
             if (!finalCombi) {
                 if (summary.has_ownership()) {
                     finalCombi = summary.release();
                 } else {
                     finalCombi = std::make_unique<MuonSegmentCombination>(*summary.get());
                 }
             }
  
             const MuonSegmentCombination* originalCombi = summary.get();
  
             // lookup the patterncombi and add association
             unsigned int count = segPattMap->count(originalCombi);
             if (count != 1) {
                 ATH_MSG_INFO(" This list should only have one entry!! ");
             } else {
                 std::pair<MuonSegmentCombPatternCombAssociationMap::const_iterator,
                           MuonSegmentCombPatternCombAssociationMap::const_iterator>
                     range = segPattMap->equal_range(originalCombi);
                 const Muon::MuonPatternCombination* pat = (range.first)->second;
                 if (pat)
                     segPattMap->insert(std::make_pair(finalCombi.get(), pat));
                 else
                     ATH_MSG_INFO(" The pattern pointer should never be zero!!!! ");
             }
  
             combiCleanCol->push_back(std::move(finalCombi));
         }
     }

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

95 { 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.

85 { 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.

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

◆ fillSummary()

void Muon::MuonSegmentCombinationCleanerTool::fillSummary ( MuonSegmentCombiSummary & combi ) const

private

create summary

Definition at line 379 of file MuonSegmentCombinationCleanerTool.cxx.

                                                                                               {
         const MuonSegmentCombination& combi = summary.segmentCombination();
         unsigned int nstations = combi.numberOfStations();
  
         // loop over segments, add them to the chamber layers
         // loop over chambers in combi and extract segments
         for (unsigned int i = 0; i < nstations; ++i) {
             // loop over segments in station
             const MuonSegmentCombination::SegmentVec* stationSegs = combi.stationSegments(i);
  
             // check if not empty
             if (!stationSegs || stationSegs->empty()) continue;
  
             // get chamber identifier, chamber index and station index
             const Identifier chid = m_edmHelperSvc->chamberId(*stationSegs->front());
             const MuonStationIndex::ChIndex chIndex = m_idHelperSvc->chamberIndex(chid);
             const MuonStationIndex::StIndex stIndex = MuonStationIndex::toStationIndex(chIndex);
  
             summary.stations.insert(stIndex);
  
             // reserve space for the new segments
             MuonSegmentCombiSummary::SegVec& chamberVec = summary.chamberSegments(chIndex);
             chamberVec.reserve(chamberVec.size() + stationSegs->size());
  
             summary.nsegments += stationSegs->size();
             for (const std::unique_ptr<MuonSegment>& seg : *stationSegs) {
                 if (seg->numberOfContainedROTs() > 3) { summary.stationsGood.insert(stIndex); }
                 chamberVec.push_back(seg.get());
             }
         }
     }

◆ initialize()

StatusCode Muon::MuonSegmentCombinationCleanerTool::initialize ( )

overridevirtual

initializes private members

Definition at line 27 of file MuonSegmentCombinationCleanerTool.cxx.

                                                              {
         ATH_MSG_VERBOSE(" MuonSegmentCombinationCleanerTool::Initializing ");
         ATH_CHECK(m_printer.retrieve());
         ATH_CHECK(m_edmHelperSvc.retrieve());
         ATH_CHECK(m_idHelperSvc.retrieve());
         ATH_CHECK(m_overlapRemovalTool.retrieve());
         ATH_MSG_VERBOSE("End of Initializing");
         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::IMuonSegmentCombinationCleanerTool::interfaceID ( )

inlinestaticinherited

access to tool interface

Definition at line 18 of file IMuonSegmentCombinationCleanerTool.h.

                                                 {
             static const InterfaceID IID_IMuonSegmentCombinationCleanerTool("Muon::IMuonSegmentCombinationCleanerTool", 1, 0);
             return IID_IMuonSegmentCombinationCleanerTool;
         }

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

◆ print() [1/2]

std::string Muon::MuonSegmentCombinationCleanerTool::print ( MuonSegmentCombiOverlapSummary & summary )

staticprivate

Definition at line 518 of file MuonSegmentCombinationCleanerTool.cxx.

                                                                                               {
         std::ostringstream sout;
  
         sout << "SegmentCombi overlap " << std::endl
              << "  shared:       " << summary.shared.size() << std::endl
              << "  uniqueFirst:  " << summary.uniqueFirst.size() << std::endl
              << "  uniqueSecond: " << summary.uniqueSecond.size() << std::endl
              << "  subsetFirst:  " << summary.subsetFirst.size() << std::endl
              << "  subsetSecond: " << summary.subsetSecond.size() << std::endl;
         return sout.str();
     }

◆ print() [2/2]

std::string Muon::MuonSegmentCombinationCleanerTool::print ( MuonSegmentCombiSummary & summary ) const

private

print summaries

Definition at line 494 of file MuonSegmentCombinationCleanerTool.cxx.

                                                                                              {
         std::ostringstream sout;
  
         // loop over chamber layers
         int index = 0;
         MuonSegmentCombiSummary::ChSegVec& segmentsPerLayer = summary.segmentsPerLayer();
  
         sout << "SegmentCombi " << std::endl;
  
         for (MuonSegmentCombiSummary::SegVec& chiit : segmentsPerLayer) {
             // skip empty layers
             if (chiit.empty()) continue;
  
             sout << " Chamber Layer: " << MuonStationIndex::chName((MuonStationIndex::ChIndex)index) << " with " << chiit.size()
                  << " segments " << std::endl;
  
             for (MuonSegment* seg : chiit) sout << m_printer->print(*seg) << std::endl;
  
             ++index;
         }
  
         return sout.str();
     }

◆ removeDuplicateSegments()

std::unique_ptr< MuonSegmentCombination > Muon::MuonSegmentCombinationCleanerTool::removeDuplicateSegments ( MuonSegmentCombination & combi ) const

remove duplicates from a segment combination, returns a nullptr

Definition at line 411 of file MuonSegmentCombinationCleanerTool.cxx.

                                              {
         CompareMuonSegmentKeys compareKeys{};
  
         // store pointers to segments that should be kept
         std::set<MuonSegment*> segmentsToBeKept;
         unsigned int nsegments = 0;  // total number of segments
  
         unsigned int nstations = combi.numberOfStations();
  
         // loop over segments, add them to the chamber layers
         // loop over chambers in combi and extract segments
         for (unsigned int i = 0; i < nstations; ++i) {
             // loop over segments in station
             MuonSegmentCombination::SegmentVec* stationSegs = combi.stationSegments(i);
             // check if not empty
             if (!stationSegs || stationSegs->empty()) continue;
             nsegments += stationSegs->size();
  
             std::vector<std::pair<MuonSegmentKey, MuonSegment*> > keys;
             keys.reserve(stationSegs->size());
  
             for (const std::unique_ptr<MuonSegment>& seg : *stationSegs) {
                 ATH_MSG_VERBOSE("  segment " << m_printer->print(*seg) << std::endl << m_printer->print(seg->containedMeasurements()));
                 // create key
                 MuonSegmentKey key{*seg};
  
                 // loop over already added keys
                 bool addSegment = true;
                 for (std::pair<MuonSegmentKey, MuonSegment*>& key_pair : keys) {
                     CompareMuonSegmentKeys::OverlapResult overlapResult = compareKeys(key, key_pair.first);
                     ATH_MSG_VERBOSE("  overlap Result: " << compareKeys.print(overlapResult));
  
                     if (overlapResult == CompareMuonSegmentKeys::Identical || overlapResult == CompareMuonSegmentKeys::SubSet) {
                         addSegment = false;
                         break;
                     } else if (overlapResult == CompareMuonSegmentKeys::SuperSet) {
                         key_pair.first = key;
                         key_pair.second = seg.get();
                         addSegment = false;
                         break;
                     } else if (overlapResult == CompareMuonSegmentKeys::Unknown) {
                         ATH_MSG_WARNING(" Got invalid return argument comparing segments: " << compareKeys.print(overlapResult));
                     }
                 }
                 if (addSegment) keys.emplace_back(std::move(key), seg.get());
             }
             for (const std::pair<MuonSegmentKey, MuonSegment*>& key_pair : keys) segmentsToBeKept.insert(key_pair.second);
         }
  
         // check whether all segments were kept
         if (nsegments == segmentsToBeKept.size()) {
             ATH_MSG_DEBUG("  no segments removed ");
             return nullptr;
         }
  
         std::unique_ptr<MuonSegmentCombination> newCombi = std::make_unique<MuonSegmentCombination>();
  
         // create a new combination removing segments that overlap
         for (unsigned int i = 0; i < nstations; ++i) {
             // loop over segments in station
             MuonSegmentCombination::SegmentVec* stationSegs = combi.stationSegments(i);
  
             // check if not empty
             if (!stationSegs || stationSegs->empty()) continue;
  
             std::unique_ptr<MuonSegmentCombination::SegmentVec> segVec = std::make_unique<MuonSegmentCombination::SegmentVec>();
             segVec->reserve(stationSegs->size());
  
             for (std::unique_ptr<MuonSegment>& seg : *stationSegs) {
                 if (!segmentsToBeKept.count(seg.get())) {
                     ATH_MSG_VERBOSE(" dropping segment  " << m_printer->print(*seg));
                     continue;
                 } else
                     ATH_MSG_VERBOSE(" adding   segment  " << m_printer->print(*seg));
                 segVec->push_back(std::move(seg));
             }
             newCombi->addSegments(std::move(segVec));
         }
  
         return newCombi;
     }

◆ 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();
   }

◆ resolveLayerOverlap()

void Muon::MuonSegmentCombinationCleanerTool::resolveLayerOverlap	(	const std::vector< MuonSegment * > &	chamberVec1,
		const std::vector< MuonSegment * > &	chamberVec2,
		MuonSegmentCombiOverlapSummary &	summary
	)		const

private

Definition at line 284 of file MuonSegmentCombinationCleanerTool.cxx.

                                                                                                                {
         CompareMuonSegmentKeys compareKeys{};
  
         std::vector<int> uniqueFirst(chamberVec1.size(), 1);
         std::vector<int> uniqueSecond(chamberVec2.size(), 1);
  
         unsigned int index1 = 0;
         for (MuonSegment* seg_chamb1 : chamberVec1) {
             // identifier(s) of MDT chambers on segment
             std::set<Identifier> chIds1 = m_edmHelperSvc->chamberIds(*seg_chamb1);
             MuonSegmentKey key1(*seg_chamb1);
  
             unsigned int index2 = 0;
             for (MuonSegment* seg_chamb2 : chamberVec2) {
                 if (!uniqueSecond[index2]) {
                     ++index2;
                     continue;
                 }
  
                 // identifier(s) of MDT chambers on segment
                 std::set<Identifier> chIds2 = m_edmHelperSvc->chamberIds(*seg_chamb2);
  
                 // check whether chamber identifiers overlap
                 bool hasOverlap = std::find_if(chIds2.begin(), chIds2.end(),
                                                [&chIds1](const Identifier& id) { return chIds1.count(id) > 0; }) != chIds2.end();
                 // if no chamber identifier overlap continue with next segment
                 if (!hasOverlap) {
                     ++index2;
                     continue;
                 }
                 // compare the hits on the two segments
  
                 MuonSegmentKey key2(*seg_chamb2);
                 CompareMuonSegmentKeys::OverlapResult overlapResult = compareKeys(key1, key2);
                 ATH_MSG_VERBOSE("  overlap Result: " << compareKeys.print(overlapResult));
  
                 if (overlapResult == CompareMuonSegmentKeys::Identical) {
                     summary.shared.emplace_back(seg_chamb1, seg_chamb2);
                     uniqueFirst[index1] = 0;
                     uniqueSecond[index2] = 0;
                 } else if (overlapResult == CompareMuonSegmentKeys::SuperSet) {
                     summary.subsetSecond.emplace_back(seg_chamb1, seg_chamb2);
                     uniqueFirst[index1] = 0;
                     uniqueSecond[index2] = 0;
                 } else if (overlapResult == CompareMuonSegmentKeys::SubSet) {
                     summary.subsetFirst.emplace_back(seg_chamb1, seg_chamb2);
                     uniqueFirst[index1] = 0;
                     uniqueSecond[index2] = 0;
                 } else if (overlapResult == CompareMuonSegmentKeys::PartialOverlap) {
                     // keep partial overlaps for now....
  
                     // in case of full overlap in the MDTs
                     if (compareKeys.intersectionSize == compareKeys.segment1Size &&
                         compareKeys.intersectionSize == compareKeys.segment2Size) {
                         // mark as same if more than 75% overlap in trigger hits
                         double intersectFrac1 = compareKeys.intersectionSizeTrigger == 0
                                                     ? 0.
                                                     : compareKeys.intersectionSizeTrigger / (double)compareKeys.segment1SizeTrigger;
                         double intersectFrac2 = compareKeys.intersectionSizeTrigger == 0
                                                     ? 0.
                                                     : compareKeys.intersectionSizeTrigger / (double)compareKeys.segment2SizeTrigger;
                         double openingAngle = seg_chamb1->globalDirection().dot(seg_chamb2->globalDirection());
                         ATH_MSG_VERBOSE("  Partial overlap: (" << intersectFrac1 << "," << intersectFrac2 << "), opening angle "
                                                                << openingAngle);
                         if (intersectFrac1 > 0.75 && intersectFrac2 > 0.75 && openingAngle > 0.99) {
                             summary.shared.emplace_back(seg_chamb1, seg_chamb2);
                             uniqueFirst[index1] = 0;
                             uniqueSecond[index2] = 0;
                         }
                     }
  
                 } else if (overlapResult == CompareMuonSegmentKeys::NoOverlap) {
                 } else if (overlapResult == CompareMuonSegmentKeys::Unknown) {
                     ATH_MSG_WARNING(" Got invalid return argument comparing segments: " << compareKeys.print(overlapResult));
                 }
             }
             ++index1;
         }
  
         // add unique segments
         index1 = 0;
         for (MuonSegment* seg_chamb1 : chamberVec1) {
             if (uniqueFirst[index1]) summary.uniqueFirst.push_back(seg_chamb1);
             ++index1;
         }
  
         unsigned int index2 = 0;
         for (MuonSegment* seg_chamb2 : chamberVec2) {
             if (uniqueSecond[index2]) summary.uniqueSecond.push_back(seg_chamb2);
             ++index2;
         }
     }

◆ subSetOfPrevious()

bool Muon::MuonSegmentCombinationCleanerTool::subSetOfPrevious	(	MuonSegmentCombiSummary &	summary,
		std::vector< MuonSegmentCombiSummary > &	summaries
	)		const

private

check whether current summary is a subset of the previous once

Definition at line 118 of file MuonSegmentCombinationCleanerTool.cxx.

                                                                                                                   {
         if (summaries.empty()) return false;
  
         ATH_MSG_DEBUG(" comparing combi with aleady handled ones ");
         bool hasOverlap = false;
  
         for (MuonSegmentCombiSummary& existing : summaries) {
             MuonSegmentCombiOverlapSummary overlap = calculateOverlap(summary, existing);
  
             // simplest case: no subsets
             if (overlap.subsetFirst.empty() && overlap.subsetSecond.empty()) {
                 // no overlap
                 if (overlap.shared.empty()) {
                     if (!m_mergeAllCombis) continue;
                 }
                 // complete overlap, keep previous
                 if (overlap.uniqueFirst.empty() && overlap.uniqueSecond.empty()) {
                     ATH_MSG_VERBOSE("    -> complete overlap, keeping first ");
                     hasOverlap = true;
                     break;
                 }
             }
  
             // second simple case, no unique segments in first and no subsets in second combi
             if (overlap.uniqueFirst.empty() && overlap.subsetSecond.empty()) {
                 ATH_MSG_VERBOSE("    -> keeping selected combi ");
                 hasOverlap = true;
                 break;
             } else if (overlap.uniqueSecond.empty() && overlap.subsetFirst.empty()) {
                 ATH_MSG_VERBOSE("    -> replacing selected combi ");
                 existing = std::move(summary);
                 hasOverlap = true;
                 break;
             }
  
             // large overlap
  
             unsigned int overlappingSegments1 = overlap.subsetFirst.size() + overlap.shared.size();
             unsigned int overlappingSegments2 = overlap.subsetSecond.size() + overlap.shared.size();
  
             unsigned int uniqueSegments1 = overlap.uniqueFirst.size();
             unsigned int uniqueSegments2 = overlap.uniqueSecond.size();
             if (overlappingSegments1 > uniqueSegments1 || overlappingSegments2 > uniqueSegments2 || m_mergeAllCombis) {
                 ATH_MSG_VERBOSE("    -> large overlap, merge candidate ");
  
                 // set to make sure we are not adding segments twice
                 std::set<MuonSegment*> addedSegments;
                 std::vector<std::vector<MuonSegment*> > segmentsPerChamberLayer{MuonStationIndex::ChIndexMax};
  
                 // first add shared segments, take one with best chi2
                 for (std::pair<MuonSegment*, MuonSegment*>& sh_iter : overlap.shared) {
                     // select segment with best chi2
                     const Trk::FitQuality* fq1 = sh_iter.first->fitQuality();
                     const Trk::FitQuality* fq2 = sh_iter.second->fitQuality();
                     double chi2First = fq1 ? fq1->chiSquared() : 1e10;
                     double chi2Second = fq2 ? fq2->chiSquared() : 1e10;
                     MuonSegment* bestSegment = chi2First < chi2Second ? sh_iter.first : sh_iter.second;
  
                     // check whether already added
                     if (addedSegments.count(bestSegment)) continue;
                     addedSegments.insert(bestSegment);
                     Identifier chId = m_edmHelperSvc->chamberId(*bestSegment);
                     MuonStationIndex::ChIndex chIndex = m_idHelperSvc->chamberIndex(chId);
                     segmentsPerChamberLayer[chIndex].push_back(bestSegment);
                 }
  
                 for (MuonSegment* bestSegment : overlap.uniqueFirst) {
                     // check whether already added
                     if (addedSegments.count(bestSegment)) continue;
                     addedSegments.insert(bestSegment);
                     Identifier chId = m_edmHelperSvc->chamberId(*bestSegment);
                     MuonStationIndex::ChIndex chIndex = m_idHelperSvc->chamberIndex(chId);
                     segmentsPerChamberLayer[chIndex].push_back(bestSegment);
                 }
  
                 for (MuonSegment* bestSegment : overlap.uniqueSecond) {
                     // check whether already added
                     if (addedSegments.count(bestSegment)) continue;
                     addedSegments.insert(bestSegment);
                     Identifier chId = m_edmHelperSvc->chamberId(*bestSegment);
                     MuonStationIndex::ChIndex chIndex = m_idHelperSvc->chamberIndex(chId);
                     segmentsPerChamberLayer[chIndex].push_back(bestSegment);
                 }
  
                 for (std::pair<MuonSegment*, MuonSegment*>& sh_iter : overlap.subsetFirst) {
                     // check whether already added
                     MuonSegment* bestSegment = sh_iter.second;
  
                     // check whether already added
                     if (addedSegments.count(bestSegment)) continue;
                     addedSegments.insert(bestSegment);
                     Identifier chId = m_edmHelperSvc->chamberId(*bestSegment);
                     MuonStationIndex::ChIndex chIndex = m_idHelperSvc->chamberIndex(chId);
                     segmentsPerChamberLayer[chIndex].push_back(bestSegment);
                 }
  
                 for (const std::pair<MuonSegment*, MuonSegment*>& sh_iter : overlap.subsetSecond) {
                     // check whether already added
                     MuonSegment* bestSegment = sh_iter.first;
                     // check whether already added
                     if (addedSegments.count(bestSegment)) continue;
                     addedSegments.insert(bestSegment);
                     Identifier chId = m_edmHelperSvc->chamberId(*bestSegment);
                     MuonStationIndex::ChIndex chIndex = m_idHelperSvc->chamberIndex(chId);
                     segmentsPerChamberLayer[chIndex].push_back(bestSegment);
                 }
  
                 // now create new combi
                 std::unique_ptr<MuonSegmentCombination> newCombi = std::make_unique<MuonSegmentCombination>();
  
                 // loop over layers and add segments
                 for (const std::vector<MuonSegment*>& chamber_hits : segmentsPerChamberLayer) {
                     // skip empty ones
                     if (chamber_hits.empty()) continue;
  
                     std::unique_ptr<MuonSegmentCombination::SegmentVec> segVec = std::make_unique<MuonSegmentCombination::SegmentVec>();
                     segVec->reserve(chamber_hits.size());
                     for (MuonSegment* seg : chamber_hits) segVec->emplace_back(seg->clone());
                     newCombi->addSegments(std::move(segVec));
                 }
  
                 // create new summary
                 MuonSegmentCombiSummary newSummary{std::move(newCombi)};
                 fillSummary(newSummary);
  
                 ATH_MSG_VERBOSE("    -> merged combis ");
                 existing = std::move(newSummary);
                 hasOverlap = true;
                 break;
             }
         }
  
         return hasOverlap;
     }

◆ 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_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_edmHelperSvc

ServiceHandle<Muon::IMuonEDMHelperSvc> Muon::MuonSegmentCombinationCleanerTool::m_edmHelperSvc

private

Initial value:

{
            this,
            "edmHelper",
            "Muon::MuonEDMHelperSvc/MuonEDMHelperSvc",
            "Handle to the service providing the IMuonEDMHelperSvc interface",
        }

Definition at line 81 of file MuonSegmentCombinationCleanerTool.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_idHelperSvc

ServiceHandle<Muon::IMuonIdHelperSvc> Muon::MuonSegmentCombinationCleanerTool::m_idHelperSvc

private

Initial value:

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

Definition at line 87 of file MuonSegmentCombinationCleanerTool.h.

◆ m_mergeAllCombis

Gaudi::Property<bool> Muon::MuonSegmentCombinationCleanerTool::m_mergeAllCombis {this, "MergeAllCombis", false, "merge all combinations into one large combination"}

private

If set to true, all combinaties will be merged into one big one.

Definition at line 94 of file MuonSegmentCombinationCleanerTool.h.

◆ m_overlapRemovalTool

ToolHandle<IMuonSegmentOverlapRemovalTool> Muon::MuonSegmentCombinationCleanerTool::m_overlapRemovalTool

private

Initial value:

{
            this,
            "SegmentOverlapRemovalTool",
            "Muon::MuonSegmentOverlapRemovalTool/MuonSegmentOverlapRemovalTool",
            "tool to removal overlaps in segment combinations",
        }

Definition at line 74 of file MuonSegmentCombinationCleanerTool.h.

◆ m_printer

ToolHandle<Muon::MuonEDMPrinterTool> Muon::MuonSegmentCombinationCleanerTool::m_printer

private

Initial value:

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

Definition at line 69 of file MuonSegmentCombinationCleanerTool.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:

Public Member Functions

Static Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ StoreGateSvc_t

Constructor & Destructor Documentation

◆ MuonSegmentCombinationCleanerTool()

◆ ~MuonSegmentCombinationCleanerTool()

Member Function Documentation

◆ calculateOverlap()

◆ clean()

◆ cleanAndMergeCombis()

◆ declareGaudiProperty() [1/4]

◆ declareGaudiProperty() [2/4]

◆ declareGaudiProperty() [3/4]

◆ declareGaudiProperty() [4/4]

◆ declareProperty() [1/6]

◆ declareProperty() [2/6]

◆ declareProperty() [3/6]

◆ declareProperty() [4/6]

◆ declareProperty() [5/6]

◆ declareProperty() [6/6]

◆ detStore()

◆ evtStore() [1/2]

◆ evtStore() [2/2]

◆ extraDeps_update_handler()

◆ fillSummary()

◆ initialize()

◆ inputHandles()

◆ interfaceID()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msgLvl()

◆ outputHandles()

◆ print() [1/2]

◆ print() [2/2]

◆ removeDuplicateSegments()

◆ renounce()

◆ renounceArray()

◆ resolveLayerOverlap()

◆ subSetOfPrevious()

◆ sysInitialize()

◆ sysStart()

◆ updateVHKA()

Member Data Documentation

◆ m_detStore

◆ m_edmHelperSvc

◆ m_evtStore

◆ m_idHelperSvc

◆ m_mergeAllCombis

◆ m_overlapRemovalTool

◆ m_printer

◆ m_varHandleArraysDeclared

◆ m_vhka