MuonCluster Class Reference

#include <MuonCluster.h>

Inheritance diagram for MuonCluster:

Collaboration diagram for MuonCluster:

Classes
struct	lvl1_muclu_roi

Public Member Functions
	MuonCluster (const std::string &name, ISvcLocator *svc)
	Constructor.
	~MuonCluster ()
virtual StatusCode	initialize () override
	hltInitialize()
virtual StatusCode	execute (const EventContext &ctx) const override
	hltExecute(), main code of the algorithm
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

Public Attributes
SG::ReadHandleKey< TrigRoiDescriptorCollection >	m_roiCollectionKey
SG::WriteHandleKey< xAOD::TrigCompositeContainer >	m_outputCompositesKey
SG::WriteHandleKey< TrigRoiDescriptorCollection >	m_outputRoiDescriptorKey
SG::WriteDecorHandleKey< xAOD::TrigCompositeContainer >	m_muRoiClusEtaKey
SG::WriteDecorHandleKey< xAOD::TrigCompositeContainer >	m_muRoiClusPhiKey
SG::WriteDecorHandleKey< xAOD::TrigCompositeContainer >	m_muRoiClusNRoiKey

Protected Member Functions
float	DeltaR (lvl1_muclu_roi, lvl1_muclu_roi) const
	calculcate the deltaR between two Rois
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.

Protected Attributes
Gaudi::Property< float >	m_DeltaR {this, "DeltaR", 0.4, "radius of the muon cluster"}
	A property which specifies the radius of the cluster.
Gaudi::Property< std::string >	m_featureLabel {"MuonCluLabel", "MuonClusterInput", "label for the MuonCluster feature in the HLT Navigation, for the xAOD::TrigCompositeContainer"}

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
ToolHandle< GenericMonitoringTool >	m_monTool {this,"MonTool","","Monitoring Tool"}
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

Definition at line 46 of file Trigger/TrigAlgorithms/TrigLongLivedParticles/src/MuonCluster.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

MuonCluster()

MuonCluster::MuonCluster	(	const std::string &	name,
		ISvcLocator *	svc )

Constructor.

Definition at line 36 of file Trigger/TrigAlgorithms/TrigLongLivedParticles/src/MuonCluster.cxx.

  : AthReentrantAlgorithm(name, svc){
 
}

~MuonCluster()

MuonCluster::~MuonCluster

(

)

Definition at line 41 of file Trigger/TrigAlgorithms/TrigLongLivedParticles/src/MuonCluster.cxx.

                          {
}

Member Function Documentation

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

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

DeltaR()

float MuonCluster::DeltaR ( lvl1_muclu_roi p_roi, lvl1_muclu_roi q_roi ) const

protected

calculcate the deltaR between two Rois

Definition at line 291 of file Trigger/TrigAlgorithms/TrigLongLivedParticles/src/MuonCluster.cxx.

                                                                        {
 
    float delPhi = CxxUtils::wrapToPi((p_roi).phi-(q_roi).phi);
    float delEta = (p_roi).eta-(q_roi).eta;
 
    return(sqrt(delPhi*delPhi+delEta*delEta));
}

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 MuonCluster::execute ( const EventContext & ctx ) const

overridevirtual

hltExecute(), main code of the algorithm

Definition at line 66 of file Trigger/TrigAlgorithms/TrigLongLivedParticles/src/MuonCluster.cxx.

{
    ATH_MSG_DEBUG("MuonCluster::execute()");
 
    std::vector<double> RoiEta_mon;
    std::vector<double> RoiPhi_mon;
    std::vector<double> RoiZed_mon;
 
    auto CluEta = Monitored::Scalar<double>("CluEta", -99.);
    auto CluPhi = Monitored::Scalar<double>("CluPhi", -99.);
    auto CluNum = Monitored::Scalar<int>("NumRoi", 0);
 
    auto nL1RoIs = Monitored::Scalar<int>("nL1RoIs",-99);
    auto nRoIinClusters = Monitored::Scalar<int>("nRoIinClusters",-99);
    auto nClusters = Monitored::Scalar<int>("nClusters",-99);
 
    auto dPhi_cluSeed = Monitored::Scalar<float>("dPhiCluSeed", -99.);
    auto dEta_cluSeed = Monitored::Scalar<float>("dEtaCluSeed", -99.);
    auto dR_cluSeed = Monitored::Scalar<float>("dRCluSeed", -99.);
 
    auto dPhi_RoivecSeed = Monitored::Scalar<double>("dPhiRoiVecSeed", -99.);
    auto dEta_RoivecSeed = Monitored::Scalar<double>("dEtaRoiVecSeed", -99.);
    auto dR_RoivecSeed   = Monitored::Scalar<double>("dRRoiVecSeed", -99.);
 
    auto mon_roiEta = Monitored::Collection("RoiEta", RoiEta_mon);
    auto mon_roiPhi = Monitored::Collection("RoiPhi", RoiPhi_mon);
 
    auto t1         = Monitored::Timer("TIME_TrigAlg");
    auto t2         = Monitored::Timer("TIME_TrigAlg_Clustering");
 
    auto mon = Monitored::Group(m_monTool, mon_roiEta, mon_roiPhi,
                                CluEta, CluPhi, CluNum,
                                nL1RoIs, nRoIinClusters, nClusters,
                                dPhi_cluSeed, dR_cluSeed, dEta_cluSeed,
                                t1, t2);
 
    //Setup the composite container we will put the MuonRoICluster in
    auto trigCompColl = SG::makeHandle(m_outputCompositesKey, ctx);
    ATH_CHECK(
      trigCompColl.record(std::make_unique<xAOD::TrigCompositeContainer>(),std::make_unique<xAOD::TrigCompositeAuxContainer>())
    );
 
    //Setup Decorator Handlers
    SG::WriteDecorHandle<xAOD::TrigCompositeContainer, float> muRoiClusEta(m_muRoiClusEtaKey, ctx);
    SG::WriteDecorHandle<xAOD::TrigCompositeContainer, float> muRoiClusPhi(m_muRoiClusPhiKey, ctx);
    SG::WriteDecorHandle<xAOD::TrigCompositeContainer, int> muRoiClusNRoi(m_muRoiClusNRoiKey, ctx);
 
    //Setup the RoI Descriptor container we will put the MuonRoIDescriptors in
    SG::WriteHandle<TrigRoiDescriptorCollection> trigDescColl = TrigCompositeUtils::createAndStoreNoAux(m_outputRoiDescriptorKey, ctx);
 
    //check to make sure we have all the input trigger elements!
 
    int n_cl=0;
    lvl1_muclu_roi muonClu[20] = {{0,0,0}};
    lvl1_muclu_roi muonClu0[20] = {{0,0,0}};
 
    auto roiCollectionHdl = SG::makeHandle(m_roiCollectionKey, ctx);
    auto roiCollection = roiCollectionHdl.get();
 
    if (roiCollection->size() < 2){ //should be the L1 Muon RoI container
        ATH_MSG_WARNING("Input TrigRoiDescriptorCollection isn't the correct size! Potential L1 menu inconsistency. Got " << roiCollection->size() << " RoIs");
        return StatusCode::SUCCESS;
    }
 
    nL1RoIs = roiCollection->size();
    nRoIinClusters = 0;
    for (const TrigRoiDescriptor *roi : *roiCollection)
    {
        if(n_cl>= kMAX_ROI) {
            ATH_MSG_WARNING("Too many L1 Muon RoIs: bailing out");
            break;
        }
 
        RoiEta_mon.push_back(roi->eta());
        RoiPhi_mon.push_back(roi->phi());
        lvl1_muclu_roi my_lvl1_clu_roi;
        my_lvl1_clu_roi.eta = roi->eta();
        my_lvl1_clu_roi.phi = roi->phi();
        my_lvl1_clu_roi.nroi = 0;
        muonClu[n_cl] = my_lvl1_clu_roi;
        muonClu0[n_cl] = my_lvl1_clu_roi;
        ++n_cl;
    }
 
    if (msgLvl(MSG::DEBUG)) {
      ATH_MSG_DEBUG("Accumulated " << n_cl << " ROI Directions: ");
      ATH_MSG_DEBUG("  [eta,  phi]");
      for (int unsigned i=0;i<RoiEta_mon.size();i++) {
        ATH_MSG_DEBUG("  [" << RoiEta_mon.at(i) << "," << RoiPhi_mon.at(i) << "]");
      }
    }
 
    // start the clustering
 
    t2.start();
    int n_itr = 0;
    for(int i_cl=0; i_cl<n_cl; ++i_cl) { // loop on cluster
        ATH_MSG_DEBUG("Initial RoI Coordinates: eta = " << muonClu0[i_cl].eta << ", phi = " << muonClu0[i_cl].phi);
        bool improvement = true;
        n_itr = 0;
        while(improvement){
            ++n_itr;
            double eta_avg=0.0;
            double cosPhi_avg=0.0;
            double sinPhi_avg=0.0;
            int n_in_clu = 0;
            for (int j_cl=0; j_cl<n_cl; ++j_cl) { // loop on cluster
                float deltaR = DeltaR(muonClu0[j_cl],muonClu[i_cl]);
                if(deltaR<m_DeltaR){
                    ATH_MSG_DEBUG("  Adding Following RoI: eta = " << muonClu0[j_cl].eta << ", phi = " << muonClu0[j_cl].phi);
                    ++n_in_clu;
                    if(n_itr==1){
                        muonClu[i_cl].eta = muonClu[i_cl].eta + (muonClu0[j_cl].eta-muonClu[i_cl].eta)/n_in_clu;
                        muonClu[i_cl].phi = CxxUtils::wrapToPi(muonClu[i_cl].phi + CxxUtils::wrapToPi(muonClu0[j_cl].phi-muonClu[i_cl].phi)/n_in_clu);
                    } else{
                        //to recalculate the average with all RoIs within a dR = 0.4 cone of the seed position
                        eta_avg += muonClu0[j_cl].eta;
                        cosPhi_avg += cos(muonClu0[j_cl].phi);
                        sinPhi_avg += sin(muonClu0[j_cl].phi);
                    }
                } // End of if on deltaR<m_DeltaR
 
            } // End of for loop over j_cl
 
            if(n_itr > 1){
                //set cluster position as average position of RoIs
                //This, coupled with the improvement=true/false below, makes an assumption that
                //improvement = false means same # RoIs in cluster, but never less (code had this before, too)
                muonClu[i_cl].eta = eta_avg/n_in_clu;
                muonClu[i_cl].phi = atan2(sinPhi_avg,cosPhi_avg);
            }
 
            //find the number of ROIs in the new cluster
            //if the number is the same as before,
            Int_t n_in_clu2=0;
            for (int j_cl=0; j_cl<n_cl; ++j_cl) { // loop on cluster
                float deltaR = DeltaR(muonClu0[j_cl],muonClu[i_cl]);
                if(deltaR<m_DeltaR){
                    ++n_in_clu2;
                }
            }
 
            ATH_MSG_DEBUG("Finding the number of Muon RoIs in the new Cluster....   " << n_in_clu2);
            if(n_in_clu2>muonClu[i_cl].nroi){
                muonClu[i_cl].nroi=n_in_clu2;
                improvement = true;
            } else  improvement = false;
        }//end while
    }
    t2.stop(); // Stop Clustering Timer
 
    ATH_MSG_DEBUG("Total Improvement Iterations = " << n_itr);
 
 
    // find the cluster with max number of rois
    int ncl_max = 0;
    int sel_cl = -1;
    int nRoisInClu = 0;
    for(int i_cl=0; i_cl<n_cl; ++i_cl) { // loop on cluster
        nRoisInClu += muonClu[i_cl].nroi;
        if(muonClu[i_cl].nroi>ncl_max){
            CluEta = muonClu[i_cl].eta;
            CluPhi = muonClu[i_cl].phi;
            CluNum = muonClu[i_cl].nroi;
            ncl_max = muonClu[i_cl].nroi;
            sel_cl = i_cl;
            ATH_MSG_DEBUG("  -- ncl_max loop: i_cl = " << i_cl << " with ncl_max = " << ncl_max);
        }
    }
    nRoIinClusters = nRoisInClu;
    nClusters = n_cl;
 
    // Should never happen (we checked above that roiCollection->size() >=2),
    // but otherwise we get warnings from cppcheck.
    if (sel_cl < 0) {
      return StatusCode::FAILURE;
    }
 
    dPhi_cluSeed = CxxUtils::wrapToPi(muonClu0[sel_cl].phi)-CxxUtils::wrapToPi(muonClu[sel_cl].phi);
    dEta_cluSeed = muonClu0[sel_cl].eta-muonClu[sel_cl].eta;
    dR_cluSeed   = DeltaR(muonClu0[sel_cl],muonClu[sel_cl]);
 
    ATH_MSG_DEBUG("RoI Cluster Coordinates: eta = " << CluEta << ", phi = " << CluPhi << ", nRoI = " << CluNum);
    ATH_MSG_DEBUG("Found the Cluster with the maximum number of RoIs....   " << ncl_max);
    // finished now debugging
    ATH_MSG_DEBUG("Create an output Collection seeded by the input");
 
    xAOD::TrigComposite *compClu = new xAOD::TrigComposite();
    try{
        trigCompColl->push_back(compClu);  //add muon RoI clusters to the composite container
    }catch(const std::exception& e){
        ATH_MSG_ERROR("Write of MuonRoICluster TrigCompositeContainer object into trigCompColl failed!");
        ATH_MSG_ERROR("Error Message: " << e.what());
        return StatusCode::FAILURE;
    }
 
 
    compClu->setName("Cluster");
    muRoiClusEta(*compClu) = static_cast<float>(CluEta);
    muRoiClusPhi(*compClu) = static_cast<float>(CluPhi);
    muRoiClusNRoi(*compClu) = static_cast<int>(CluNum);
 
 
    //create a TrigRoiDescriptor to send to ID tracking, to seed track-finding
    //only need to do this if the MuonCluster will pass the hypo!
    if( (static_cast<int>(CluNum) >= 3 && std::abs(static_cast<double>(CluEta)) < 1.0) || \
        (static_cast<int>(CluNum) >= 4 && std::abs(static_cast<double>(CluEta)) >= 1.0 && std::abs(static_cast<double>(CluEta)) <= 2.5) )
    {
        double phiHalfWidth = 0.35;
        double phiMinus = CxxUtils::wrapToPi(static_cast<double>(CluPhi)-phiHalfWidth);
        double phiPlus  = CxxUtils::wrapToPi(static_cast<double>(CluPhi)+phiHalfWidth);
        TrigRoiDescriptor* roiClus =  new TrigRoiDescriptor(static_cast<double>(CluEta), static_cast<double>(CluEta)-0.4, static_cast<double>(CluEta)+0.4,static_cast<double>(CluPhi), phiMinus, phiPlus);
        trigDescColl->push_back(roiClus);
    }
 
    //----------------------------------------------------------------
    // REGTEST
    //----------------------------------------------------------------
    ATH_MSG_DEBUG(" REGTEST \t Cluster with : " << static_cast<int>(CluNum) << " LVL1-Roi");
    ATH_MSG_DEBUG(" REGTEST \t Cluster Eta " <<  static_cast<double>(CluEta) << "  Cluster Phi " << static_cast<double>(CluPhi));
    //----------------------------------------------------------------
 
    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();
  }

initialize()

StatusCode MuonCluster::initialize ( )

overridevirtual

hltInitialize()

Definition at line 44 of file Trigger/TrigAlgorithms/TrigLongLivedParticles/src/MuonCluster.cxx.

                                  {
 
    ATH_MSG_INFO("Parameters for MuonCluster:" << name());
    ATH_MSG_INFO("DeltaR : " << m_DeltaR);
    ATH_MSG_INFO("MuonCluLabel : " << m_featureLabel);
 
    ATH_MSG_DEBUG("Retrieve service StoreGateSvc");
    ATH_MSG_DEBUG("Timers are initializated here");
 
    ATH_CHECK( m_roiCollectionKey.initialize() );
    ATH_CHECK( m_outputCompositesKey.initialize() );
    ATH_CHECK( m_outputRoiDescriptorKey.initialize() );
 
    ATH_CHECK( m_muRoiClusEtaKey.initialize() );
    ATH_CHECK( m_muRoiClusPhiKey.initialize() );
    ATH_CHECK( m_muRoiClusNRoiKey.initialize() );
 
    if (!m_monTool.empty()) ATH_CHECK(m_monTool.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.

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_DeltaR

Gaudi::Property<float> MuonCluster::m_DeltaR {this, "DeltaR", 0.4, "radius of the muon cluster"}

protected

A property which specifies the radius of the cluster.

Definition at line 103 of file Trigger/TrigAlgorithms/TrigLongLivedParticles/src/MuonCluster.h.

{this, "DeltaR", 0.4, "radius of the muon cluster"};

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_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_featureLabel

Gaudi::Property<std::string> MuonCluster::m_featureLabel {"MuonCluLabel", "MuonClusterInput", "label for the MuonCluster feature in the HLT Navigation, for the xAOD::TrigCompositeContainer"}

protected

Definition at line 104 of file Trigger/TrigAlgorithms/TrigLongLivedParticles/src/MuonCluster.h.

{"MuonCluLabel", "MuonClusterInput", "label for the MuonCluster feature in the HLT Navigation, for the xAOD::TrigCompositeContainer"};

m_monTool

ToolHandle<GenericMonitoringTool> MuonCluster::m_monTool {this,"MonTool","","Monitoring Tool"}

private

Definition at line 91 of file Trigger/TrigAlgorithms/TrigLongLivedParticles/src/MuonCluster.h.

{this,"MonTool","","Monitoring Tool"};

m_muRoiClusEtaKey

SG::WriteDecorHandleKey<xAOD::TrigCompositeContainer> MuonCluster::m_muRoiClusEtaKey

Initial value:

{ this,
      "MuonRoiClusterEta",
      "HLT_MuRoICluster_Composites.ClusterEta",
      "Average Eta of the muon RoI Cluster"}

Definition at line 68 of file Trigger/TrigAlgorithms/TrigLongLivedParticles/src/MuonCluster.h.

                                                                     { this,
      "MuonRoiClusterEta",
      "HLT_MuRoICluster_Composites.ClusterEta",
      "Average Eta of the muon RoI Cluster"};

m_muRoiClusNRoiKey

SG::WriteDecorHandleKey<xAOD::TrigCompositeContainer> MuonCluster::m_muRoiClusNRoiKey

Initial value:

{ this,
      "MuonRoiClusterNRoIs",
      "HLT_MuRoICluster_Composites.nRoIs",
      "Number of muon RoIs used to construct this muon RoI cluster"}

Definition at line 78 of file Trigger/TrigAlgorithms/TrigLongLivedParticles/src/MuonCluster.h.

                                                                      { this,
      "MuonRoiClusterNRoIs",
      "HLT_MuRoICluster_Composites.nRoIs",
      "Number of muon RoIs used to construct this muon RoI cluster"};

m_muRoiClusPhiKey

SG::WriteDecorHandleKey<xAOD::TrigCompositeContainer> MuonCluster::m_muRoiClusPhiKey

Initial value:

{ this,
      "MuonRoiClusterPhi",
      "HLT_MuRoICluster_Composites.ClusterPhi",
      "Average Phi of the muonRoI Cluster"}

Definition at line 73 of file Trigger/TrigAlgorithms/TrigLongLivedParticles/src/MuonCluster.h.

                                                                     { this,
      "MuonRoiClusterPhi",
      "HLT_MuRoICluster_Composites.ClusterPhi",
      "Average Phi of the muonRoI Cluster"};

m_outputCompositesKey

SG::WriteHandleKey<xAOD::TrigCompositeContainer> MuonCluster::m_outputCompositesKey

Initial value:

{ this,
      "TrigRoIs_CompositeContainer",                        
      "HLT_MuRoICluster_Composites",                        
      "output Composites container"}

Definition at line 58 of file Trigger/TrigAlgorithms/TrigLongLivedParticles/src/MuonCluster.h.

                                                                    { this,
      "TrigRoIs_CompositeContainer",                        // property name
      "HLT_MuRoICluster_Composites",                        // default value of StoreGatekey
      "output Composites container"};

m_outputRoiDescriptorKey

SG::WriteHandleKey<TrigRoiDescriptorCollection> MuonCluster::m_outputRoiDescriptorKey

Initial value:

{ this,
      "TrigRoiDescriptorDataVector",
      "HLT_MuRoICluster_Descriptors",
      "output RoI Descriptor container with descriptor for cluster with maximum number of RoIs. For ID."}

Definition at line 63 of file Trigger/TrigAlgorithms/TrigLongLivedParticles/src/MuonCluster.h.

                                                                        { this,
      "TrigRoiDescriptorDataVector",
      "HLT_MuRoICluster_Descriptors",
      "output RoI Descriptor container with descriptor for cluster with maximum number of RoIs. For ID."};

m_roiCollectionKey

SG::ReadHandleKey<TrigRoiDescriptorCollection> MuonCluster::m_roiCollectionKey

Initial value:

{ this,
      "RoIs",                                       
      "HLT_muVtxCluster_RoIs",                      
      "input RoICollection"}

Definition at line 53 of file Trigger/TrigAlgorithms/TrigLongLivedParticles/src/MuonCluster.h.

                                                                 { this,
      "RoIs",                                       // property name
      "HLT_muVtxCluster_RoIs",                      // default value of StoreGatekey
      "input RoICollection"};

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.

---

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

• Trigger/TrigAlgorithms/TrigLongLivedParticles/src/MuonCluster.h
• Trigger/TrigAlgorithms/TrigLongLivedParticles/src/MuonCluster.cxx