#include <TGC_RDOAnalysis.h>

Inheritance diagram for TGC_RDOAnalysis:

Collaboration diagram for TGC_RDOAnalysis:

Public Member Functions
	TGC_RDOAnalysis (const std::string &name, ISvcLocator *pSvcLocator)

virtual	~TGC_RDOAnalysis ()

virtual StatusCode	initialize () override final

virtual StatusCode	execute () override final

virtual StatusCode	finalize () override final

virtual StatusCode	sysInitialize () override
	Override sysInitialize. More...

virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies. 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	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

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
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
SG::ReadHandleKey< TgcRdoContainer >	m_inputKey

SG::ReadHandleKey< MuonSimDataCollection >	m_inputTruthKey

std::vector< uint16_t > *	m_tgcID

std::vector< uint16_t > *	m_tgcSubDetID

std::vector< uint16_t > *	m_tgcRodID

std::vector< uint16_t > *	m_tgcTrigType

std::vector< uint16_t > *	m_tgcBcID

std::vector< uint16_t > *	m_tgcL1ID

std::vector< uint32_t > *	m_tgcOrbit

std::vector< uint16_t > *	m_tgcVersion

std::vector< uint16_t > *	m_bcTag

std::vector< uint16_t > *	m_subDetID

std::vector< uint16_t > *	m_rodID

std::vector< uint16_t > *	m_sswID

std::vector< uint16_t > *	m_slbID

std::vector< uint16_t > *	m_bcID

std::vector< uint16_t > *	m_l1ID

std::vector< int > *	m_type

std::vector< int > *	m_slbType

std::vector< bool > *	m_coinc

std::vector< uint16_t > *	m_bitPos

std::vector< uint16_t > *	m_track

std::vector< bool > *	m_adj

std::vector< bool > *	m_forward

std::vector< uint16_t > *	m_index

std::vector< uint16_t > *	m_pos

std::vector< uint16_t > *	m_delta

std::vector< uint16_t > *	m_segment

std::vector< uint16_t > *	m_subMat

std::vector< uint16_t > *	m_sector

std::vector< uint16_t > *	m_chip

std::vector< bool > *	m_hipt

std::vector< uint16_t > *	m_hitID

std::vector< uint16_t > *	m_hsub

std::vector< bool > *	m_strip

std::vector< uint16_t > *	m_inner

std::vector< bool > *	m_cand3plus

std::vector< bool > *	m_muplus

std::vector< bool > *	m_thresh

std::vector< bool > *	m_overlap

std::vector< bool > *	m_veto

std::vector< uint16_t > *	m_roi

std::vector< unsigned long long > *	m_sdoID

std::vector< int > *	m_sdoWord

std::vector< float > *	m_xPos

std::vector< float > *	m_yPos

std::vector< float > *	m_zPos

std::vector< int > *	m_barcode

std::vector< int > *	m_eventIndex

std::vector< double > *	m_radius

std::vector< float > *	m_localZ

std::vector< std::vector< int > > *	m_barcode_vec

std::vector< std::vector< int > > *	m_eventIndex_vec

std::vector< std::vector< double > > *	m_radius_vec

std::vector< std::vector< float > > *	m_localZ_vec

TH1 *	m_h_tgcID

TH1 *	m_h_tgcSubDetID

TH1 *	m_h_tgcRodID

TH1 *	m_h_tgcTrigType

TH1 *	m_h_tgcBcID

TH1 *	m_h_tgcL1ID

TH1 *	m_h_bcTag

TH1 *	m_h_subDetID

TH1 *	m_h_rodID

TH1 *	m_h_sswID

TH1 *	m_h_slbID

TH1 *	m_h_bcID

TH1 *	m_h_l1ID

TH1 *	m_h_type

TH1 *	m_h_slbType

TH1 *	m_h_bitPos

TH1 *	m_h_track

TH1 *	m_h_adj

TH1 *	m_h_sdoID

TH1 *	m_h_sdoWord

TH1 *	m_h_xPos

TH1 *	m_h_yPos

TH1 *	m_h_zPos

TH1 *	m_h_barcode

TH1 *	m_h_eventIndex

TH1 *	m_h_radius

TH1 *	m_h_localZ

TTree *	m_tree

std::string	m_ntupleFileName

std::string	m_ntupleDirName

std::string	m_ntupleTreeName

std::string	m_path

ServiceHandle< ITHistSvc >	m_thistSvc

DataObjIDColl	m_extendedExtraObjects

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 24 of file TGC_RDOAnalysis.h.

Member Typedef Documentation

◆ StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ TGC_RDOAnalysis()

TGC_RDOAnalysis::TGC_RDOAnalysis	(	const std::string &	name,
		ISvcLocator *	pSvcLocator
	)

Definition at line 17 of file TGC_RDOAnalysis.cxx.

   : AthAlgorithm(name, pSvcLocator)
   , m_inputKey("TGCRDO")
   , m_inputTruthKey("TGC_SDO")
   , m_tgcID(0)
   , m_tgcSubDetID(0)
   , m_tgcRodID(0)
   , m_tgcTrigType(0)
   , m_tgcBcID(0)
   , m_tgcL1ID(0)
   , m_tgcOrbit(0)
   , m_tgcVersion(0)
   , m_bcTag(0)
   , m_subDetID(0)
   , m_rodID(0)
   , m_sswID(0)
   , m_slbID(0)
   , m_bcID(0)
   , m_l1ID(0)
   , m_type(0)
   , m_slbType(0)
   , m_coinc(0)
   , m_bitPos(0)
   , m_track(0)
   , m_adj(0)
   , m_forward(0)
   , m_index(0)
   , m_pos(0)
   , m_delta(0)
   , m_segment(0)
   , m_subMat(0)
   , m_sector(0)
   , m_chip(0)
   , m_hipt(0)
   , m_hitID(0)
   , m_hsub(0)
   , m_strip(0)
   , m_inner(0)
   , m_cand3plus(0)
   , m_muplus(0)
   , m_thresh(0)
   , m_overlap(0)
   , m_veto(0)
   , m_roi(0)
  
   , m_sdoID(0)
   , m_sdoWord(0)
   , m_xPos(0)
   , m_yPos(0)
   , m_zPos(0)
   , m_barcode(0)
   , m_eventIndex(0)
   , m_radius(0)
   , m_localZ(0)
   , m_barcode_vec(0)
   , m_eventIndex_vec(0)
   , m_radius_vec(0)
   , m_localZ_vec(0)
  
   , m_h_tgcID(0)
   , m_h_tgcSubDetID(0)
   , m_h_tgcRodID(0)
   , m_h_tgcTrigType(0)
   , m_h_tgcBcID(0)
   , m_h_tgcL1ID(0)
   , m_h_bcTag(0)
   , m_h_subDetID(0)
   , m_h_rodID(0)
   , m_h_sswID(0)
   , m_h_slbID(0)
   , m_h_bcID(0)
   , m_h_l1ID(0)
   , m_h_type(0)
   , m_h_slbType(0)
   , m_h_bitPos(0)
   , m_h_track(0)
   , m_h_adj(0)
   , m_h_sdoID(0)
   , m_h_sdoWord(0)
   , m_h_xPos(0)
   , m_h_yPos(0)
   , m_h_zPos(0)
   , m_h_barcode(0)
   , m_h_eventIndex(0)
   , m_h_radius(0)
   , m_h_localZ(0)
  
   , m_tree(0)
   , m_ntupleFileName("/ntuples/file1")
   , m_ntupleDirName("/TGC_RDOAnalysis/")
   , m_ntupleTreeName("TGC_RDOAna")
   , m_path("/TGC_RDOAnalysis/")
   , m_thistSvc("THistSvc", name)
 {
   declareProperty("InputKey", m_inputKey);
   declareProperty("InputTruthKey", m_inputTruthKey);
   declareProperty("NtupleFileName", m_ntupleFileName);
   declareProperty("NtupleDirectoryName", m_ntupleDirName);
   declareProperty("NtupleTreeName", m_ntupleTreeName);
   declareProperty("HistPath", m_path);
 }

◆ ~TGC_RDOAnalysis()

virtual TGC_RDOAnalysis::~TGC_RDOAnalysis ( )

inlinevirtual

Definition at line 28 of file TGC_RDOAnalysis.h.

28 {}

Member Function Documentation

◆ declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::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< Algorithm > >::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< Algorithm > >::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< Algorithm > >::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< Algorithm > >::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< Algorithm > >::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< Algorithm > >::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< Algorithm > >::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< Algorithm > >::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< Algorithm > >::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< Algorithm > >::detStore ( ) const

inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

95 { return m_detStore; }

◆ evtStore() [1/2]

ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Algorithm > >::evtStore ( )

inlineinherited

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

Definition at line 85 of file AthCommonDataStore.h.

85 { return m_evtStore; }

◆ evtStore() [2/2]

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

◆ execute()

StatusCode TGC_RDOAnalysis::execute ( )

finaloverridevirtual

Definition at line 304 of file TGC_RDOAnalysis.cxx.

                                     {
   ATH_MSG_DEBUG( "In TGC_RDOAnalysis::execute()" );
  
   m_tgcID->clear();
   m_tgcSubDetID->clear();
   m_tgcRodID->clear();
   m_tgcTrigType->clear();
   m_tgcBcID->clear();
   m_tgcL1ID->clear();
   m_tgcOrbit->clear();
   m_tgcVersion->clear();
   m_bcTag->clear();
   m_subDetID->clear();
   m_rodID->clear();
   m_sswID->clear();
   m_slbID->clear();
   m_bcID->clear();
   m_l1ID->clear();
   m_type->clear();
   m_slbType->clear();
   m_coinc->clear();
   m_bitPos->clear();
   m_track->clear();
   m_adj->clear();
   m_forward->clear();
   m_index->clear();
   m_pos->clear();
   m_delta->clear();
   m_segment->clear();
   m_subMat->clear();
   m_sector->clear();
   m_chip->clear();
   m_hipt->clear();
   m_hitID->clear();
   m_hsub->clear();
   m_strip->clear();
   m_inner->clear();
   m_cand3plus->clear();
   m_muplus->clear();
   m_thresh->clear();
   m_overlap->clear();
   m_veto->clear();
   m_roi->clear();
  
   m_sdoID->clear();
   m_sdoWord->clear();
   m_xPos->clear();
   m_yPos->clear();
   m_zPos->clear();
   m_barcode->clear();
   m_eventIndex->clear();
   m_radius->clear();
   m_localZ->clear();
   m_barcode_vec->clear();
   m_eventIndex_vec->clear();
   m_radius_vec->clear();
   m_localZ_vec->clear();
  
   SG::ReadHandle<TgcRdoContainer> p_TGCcont (m_inputKey);
   if(p_TGCcont.isValid()) {
     TgcRdoContainer::const_iterator tgcCont_itr(p_TGCcont->begin());
     const TgcRdoContainer::const_iterator tgcCont_end(p_TGCcont->end());
  
     for ( ; tgcCont_itr != tgcCont_end; ++tgcCont_itr ) {
       const uint16_t tgcID((*tgcCont_itr)->identify());
       const uint16_t tgcSubDetID((*tgcCont_itr)->subDetectorId());
       const uint16_t tgcRodID((*tgcCont_itr)->rodId());
       const uint16_t tgcTrigType((*tgcCont_itr)->triggerType());
       const uint16_t tgcBcID((*tgcCont_itr)->bcId());
       const uint16_t tgcL1ID((*tgcCont_itr)->l1Id());
       // @todo variables to plot in the future
       // const TgcRdo::Errors& tgcErr = (*tgcCont_itr)->errors();
       // const TgcRdo::RodStatus& tgcRodStat = (*tgcCont_itr)->rodStatus();
       // const TgcRdo::LocalStatus& tgcLocalStat = (*tgcCont_itr)->localStatus();
       const uint32_t tgcOrbit((*tgcCont_itr)->orbit());
       const uint16_t tgcVersion((*tgcCont_itr)->version());
  
       m_tgcID->push_back(tgcID);
       m_tgcSubDetID->push_back(tgcSubDetID);
       m_tgcRodID->push_back(tgcRodID);
       m_tgcTrigType->push_back(tgcTrigType);
       m_tgcBcID->push_back(tgcBcID);
       m_tgcL1ID->push_back(tgcL1ID);
       m_tgcOrbit->push_back(tgcOrbit);
       m_tgcVersion->push_back(tgcVersion);
  
       m_h_tgcID->Fill(tgcID);
       m_h_tgcSubDetID->Fill(tgcSubDetID);
       m_h_tgcRodID->Fill(tgcRodID);
       m_h_tgcTrigType->Fill(tgcTrigType);
       m_h_tgcBcID->Fill(tgcBcID);
       m_h_tgcL1ID->Fill(tgcL1ID);
  
       const TgcRdo* p_TGCraw(*tgcCont_itr);
       TgcRdo::const_iterator tgc_itr(p_TGCraw->begin());
       const TgcRdo::const_iterator tgc_end(p_TGCraw->end());
  
       for ( ; tgc_itr != tgc_end; ++tgc_itr ) {
         const uint16_t bctag((*tgc_itr)->bcTag());
         const uint16_t subDetID((*tgc_itr)->subDetectorId());
         const uint16_t rodID((*tgc_itr)->rodId());
         const uint16_t sswID((*tgc_itr)->sswId());
         const uint16_t slbID((*tgc_itr)->slbId());
         const uint16_t bcID((*tgc_itr)->bcId());
         const uint16_t l1ID((*tgc_itr)->l1Id());
         TgcRawData::DataType type_var = (*tgc_itr)->type();
         TgcRawData::SlbType slbType_var = (*tgc_itr)->slbType();
         const bool coinc((*tgc_itr)->isCoincidence());
         const uint16_t bitPos((*tgc_itr)->bitpos());
         const uint16_t track((*tgc_itr)->tracklet());
         const bool adj((*tgc_itr)->isAdjacent());
         const bool forward((*tgc_itr)->isForward());
         const uint16_t ix((*tgc_itr)->index());
         const uint16_t pos((*tgc_itr)->position());
         const uint16_t del((*tgc_itr)->delta());
         const uint16_t seg((*tgc_itr)->segment());
         const uint16_t subMat((*tgc_itr)->subMatrix());
         const uint16_t sector((*tgc_itr)->sector());
         const uint16_t chip((*tgc_itr)->chip());
         const bool hipt((*tgc_itr)->isHipt());
         const uint16_t hitID((*tgc_itr)->hitId());
         const uint16_t hsub((*tgc_itr)->hsub());
         const bool strip((*tgc_itr)->isStrip());
         //const uint16_t inner((*tgc_itr)->inner());
         const bool cand3plus((*tgc_itr)->cand3plus());
         const bool muplus((*tgc_itr)->isMuplus());
         const bool thresh((*tgc_itr)->threshold());
         const bool overlap((*tgc_itr)->isOverlap());
         const bool veto((*tgc_itr)->isVeto());
         const uint16_t roi((*tgc_itr)->roi());
  
         m_bcTag->push_back(bctag);
         m_subDetID->push_back(subDetID);
         m_rodID->push_back(rodID);
         m_sswID->push_back(sswID);
         m_slbID->push_back(slbID);
         m_bcID->push_back(bcID);
         m_l1ID->push_back(l1ID);
         m_type->push_back(int(type_var));
         m_slbType->push_back(int(slbType_var));
         m_coinc->push_back(coinc);
         m_bitPos->push_back(bitPos);
         m_track->push_back(track);
         m_adj->push_back(adj);
         m_forward->push_back(forward);
         m_index->push_back(ix);
         m_pos->push_back(pos);
         m_delta->push_back(del);
         m_segment->push_back(seg);
         m_subMat->push_back(subMat);
         m_sector->push_back(sector);
         m_chip->push_back(chip);
         m_hipt->push_back(hipt);
         m_hitID->push_back(hitID);
         m_hsub->push_back(hsub);
         m_strip->push_back(strip);
         //m_inner->push_back(inner);
         m_cand3plus->push_back(cand3plus);
         m_muplus->push_back(muplus);
         m_thresh->push_back(thresh);
         m_overlap->push_back(overlap);
         m_veto->push_back(veto);
         m_roi->push_back(roi);
  
         m_h_bcTag->Fill(bctag);
         m_h_subDetID->Fill(subDetID);
         m_h_rodID->Fill(rodID);
         m_h_sswID->Fill(sswID);
         m_h_slbID->Fill(slbID);
         m_h_bcID->Fill(bcID);
         m_h_l1ID->Fill(l1ID);
         m_h_type->Fill(int(type_var));
         m_h_slbType->Fill(int(slbType_var));
         if (int(type_var) == 0) {
           m_h_bitPos->Fill(bitPos);
           m_h_track->Fill(track);
           m_h_adj->Fill(adj);
         }
       }
     }
   }
  
   // SimData
   SG::ReadHandle<MuonSimDataCollection> simDataMapTGC (m_inputTruthKey);
   if(simDataMapTGC.isValid()) {
     MuonSimDataCollection::const_iterator sdo_itr(simDataMapTGC->begin());
     const MuonSimDataCollection::const_iterator sdo_end(simDataMapTGC->end());
  
     std::vector<int> barcode_vec;
     std::vector<int> eventIndex_vec;
     std::vector<double> radius_vec;
     std::vector<float> localZ_vec;
     for ( ; sdo_itr != sdo_end; ++sdo_itr ) {
       const Identifier sdoID((*sdo_itr).first);
       const MuonSimData& sdo((*sdo_itr).second);
  
       const unsigned long long sdoID_int = sdoID.get_compact();
       const int sdoWord(sdo.word());
       const Amg::Vector3D gPos(sdo.globalPosition());
       const float xPos(gPos.x());
       const float yPos(gPos.y());
       const float zPos(gPos.z());
  
       m_sdoID->push_back(sdoID_int);
       m_sdoWord->push_back(sdoWord);
       m_xPos->push_back(xPos);
       m_yPos->push_back(yPos);
       m_zPos->push_back(zPos);
  
       m_h_sdoID->Fill(sdoID_int);
       m_h_sdoWord->Fill(sdoWord);
       m_h_xPos->Fill(xPos);
       m_h_yPos->Fill(yPos);
       m_h_zPos->Fill(zPos);
  
       // loop over deposits
       const std::vector<MuonSimData::Deposit>& deposits = sdo.getdeposits();
       std::vector<MuonSimData::Deposit>::const_iterator dep_itr(deposits.begin());
       const std::vector<MuonSimData::Deposit>::const_iterator dep_end(deposits.end());
       for ( ; dep_itr != dep_end; ++dep_itr ) {
         const HepMcParticleLink& particleLink = (*dep_itr).first;
         const int bar(HepMC::barcode(particleLink)); // FIXME barcode-based
         const int eventIx(particleLink.eventIndex());
         const MuonMCData& data = (*dep_itr).second;
         const double radius(data.firstEntry());
         const float localZ(data.secondEntry());
  
         m_barcode->push_back(bar);
         m_eventIndex->push_back(eventIx);
         m_radius->push_back(radius);
         m_localZ->push_back(localZ);
  
         m_h_barcode->Fill(bar);
         m_h_eventIndex->Fill(eventIx);
         m_h_radius->Fill(radius);
         m_h_localZ->Fill(localZ);
  
         barcode_vec.push_back(bar);
         eventIndex_vec.push_back(eventIx);
         radius_vec.push_back(radius);
         localZ_vec.push_back(localZ);
       }
       m_barcode_vec->push_back(barcode_vec);
       m_eventIndex_vec->push_back(eventIndex_vec);
       m_radius_vec->push_back(radius_vec);
       m_localZ_vec->push_back(localZ_vec);
       barcode_vec.clear();
       eventIndex_vec.clear();
       radius_vec.clear();
       localZ_vec.clear();
     }
   }
  
   if (m_tree) {
     m_tree->Fill();
   }
  
   return StatusCode::SUCCESS;
 }

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< 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 & AthAlgorithm::extraOutputDeps ( ) const

overridevirtualinherited

Return the list of extra output dependencies.

This list is extended to include symlinks implied by inheritance relations.

Definition at line 50 of file AthAlgorithm.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 Algorithm::extraOutputDeps();
 }

◆ finalize()

StatusCode TGC_RDOAnalysis::finalize ( )

finaloverridevirtual

Definition at line 564 of file TGC_RDOAnalysis.cxx.

                                      {
   return StatusCode::SUCCESS;
 }

◆ initialize()

StatusCode TGC_RDOAnalysis::initialize ( )

finaloverridevirtual

Definition at line 119 of file TGC_RDOAnalysis.cxx.

                                        {
   ATH_MSG_DEBUG( "Initializing TGC_RDOAnalysis" );
  
   // This will check that the properties were initialized
   // properly by job configuration.
   ATH_CHECK( m_inputKey.initialize() );
   ATH_CHECK( m_inputTruthKey.initialize() );
  
   ATH_CHECK(m_thistSvc.retrieve());
  
   m_tree = new TTree(TString(m_ntupleTreeName), "TGC_RDOAna");
   std::string fullNtupleName = m_ntupleFileName + m_ntupleDirName + m_ntupleTreeName;
   ATH_CHECK(m_thistSvc->regTree(fullNtupleName, m_tree));
   if (m_tree) {
     m_tree->Branch("tgcID", &m_tgcID);
     m_tree->Branch("tgcSubDetID", &m_tgcSubDetID);
     m_tree->Branch("tgcRodID", &m_tgcRodID);
     m_tree->Branch("tgcTrigType", &m_tgcTrigType);
     m_tree->Branch("tgcBcID", &m_tgcBcID);
     m_tree->Branch("tgcL1ID", &m_tgcL1ID);
     m_tree->Branch("tgcOrbit", &m_tgcOrbit);
     m_tree->Branch("tgcVersion", &m_tgcVersion);
     m_tree->Branch("bcTag", &m_bcTag);
     m_tree->Branch("subDetID", &m_subDetID);
     m_tree->Branch("rodID", &m_rodID);
     m_tree->Branch("sswID", &m_sswID);
     m_tree->Branch("slbID", &m_slbID);
     m_tree->Branch("bcID", &m_bcID);
     m_tree->Branch("l1ID", &m_l1ID);
     m_tree->Branch("type", &m_type);
     m_tree->Branch("slbType", &m_slbType);
     m_tree->Branch("coinc", &m_coinc);
     m_tree->Branch("bitPos", &m_bitPos);
     m_tree->Branch("track", &m_track);
     m_tree->Branch("adj", &m_adj);
     m_tree->Branch("forward", &m_forward);
     m_tree->Branch("index", &m_index);
     m_tree->Branch("pos", &m_pos);
     m_tree->Branch("delta", &m_delta);
     m_tree->Branch("segment", &m_segment);
     m_tree->Branch("subMat", &m_subMat);
     m_tree->Branch("sector", &m_sector);
     m_tree->Branch("chip", &m_chip);
     m_tree->Branch("hipt", &m_hipt);
     m_tree->Branch("hitID", &m_hitID);
     m_tree->Branch("hsub", &m_hsub);
     m_tree->Branch("strip", &m_strip);
     m_tree->Branch("inner", &m_inner);
     m_tree->Branch("cand3plus", &m_cand3plus);
     m_tree->Branch("muplus", &m_muplus);
     m_tree->Branch("thresh", &m_thresh);
     m_tree->Branch("overlap", &m_overlap);
     m_tree->Branch("veto", &m_veto);
     m_tree->Branch("roi", &m_roi);
  
     m_tree->Branch("sdoID", &m_sdoID);
     m_tree->Branch("sdoWord", &m_sdoWord);
     m_tree->Branch("xPos", &m_xPos);
     m_tree->Branch("yPos", &m_yPos);
     m_tree->Branch("zPos", &m_zPos);
     m_tree->Branch("barcode", &m_barcode);
     m_tree->Branch("eventIndex", &m_eventIndex);
     m_tree->Branch("radius", &m_radius);
     m_tree->Branch("localZ", &m_localZ);
     m_tree->Branch("barcode_vec", &m_barcode_vec);
     m_tree->Branch("eventIndex_vec", &m_eventIndex_vec);
     m_tree->Branch("radius_vec", &m_radius_vec);
     m_tree->Branch("localZ_vec", &m_localZ_vec);
   }
   else {
     ATH_MSG_ERROR("No tree found!");
   }
  
   // HISTOGRAMS
   m_h_tgcID = new TH1F("h_tgcID", "TGC ID", 100, 0, 25);
   m_h_tgcID->StatOverflows();
   ATH_CHECK(m_thistSvc->regHist(m_path + m_h_tgcID->GetName(), m_h_tgcID));
  
   m_h_tgcSubDetID = new TH1F("h_tgcSubDetID", "TGC sub-detector ID", 100, 0, 110);
   m_h_tgcSubDetID->StatOverflows();
   ATH_CHECK(m_thistSvc->regHist(m_path + m_h_tgcSubDetID->GetName(), m_h_tgcSubDetID));
  
   m_h_tgcRodID = new TH1F("h_tgcRodID", "TGC ROD ID", 100, 0, 15);
   m_h_tgcRodID->StatOverflows();
   ATH_CHECK(m_thistSvc->regHist(m_path + m_h_tgcRodID->GetName(), m_h_tgcRodID));
  
   m_h_tgcTrigType = new TH1F("h_tgcTrigType", "TGC trigger type", 100, 0, 2);
   m_h_tgcTrigType->StatOverflows();
   ATH_CHECK(m_thistSvc->regHist(m_path + m_h_tgcTrigType->GetName(), m_h_tgcTrigType));
  
   m_h_tgcBcID = new TH1F("h_tgcBcID", "TGC BCID", 100, 0, 2);
   m_h_tgcBcID->StatOverflows();
   ATH_CHECK(m_thistSvc->regHist(m_path + m_h_tgcBcID->GetName(), m_h_tgcBcID));
  
   m_h_tgcL1ID = new TH1F("h_tgcL1ID", "TGC L1ID", 100, 0, 2);
   m_h_tgcL1ID->StatOverflows();
   ATH_CHECK(m_thistSvc->regHist(m_path + m_h_tgcL1ID->GetName(), m_h_tgcL1ID));
  
   m_h_bcTag = new TH1F("h_bcTag", "BC Tag", 100, 0, 5);
   m_h_bcTag->StatOverflows();
   ATH_CHECK(m_thistSvc->regHist(m_path + m_h_bcTag->GetName(), m_h_bcTag));
  
   m_h_subDetID = new TH1F("h_subDetID", "Sub-detector ID", 100, 0, 110);
   m_h_subDetID->StatOverflows();
   ATH_CHECK(m_thistSvc->regHist(m_path + m_h_subDetID->GetName(), m_h_subDetID));
  
   m_h_rodID = new TH1F("h_rodID", "ROD ID", 100, 0, 15);
   m_h_rodID->StatOverflows();
   ATH_CHECK(m_thistSvc->regHist(m_path + m_h_rodID->GetName(), m_h_rodID));
  
   m_h_sswID = new TH1F("h_sswID", "SSW ID", 100, 0, 10);
   m_h_sswID->StatOverflows();
   ATH_CHECK(m_thistSvc->regHist(m_path + m_h_sswID->GetName(), m_h_sswID));
  
   m_h_slbID = new TH1F("h_slbID", "SLB ID", 100, 0, 30);
   m_h_slbID->StatOverflows();
   ATH_CHECK(m_thistSvc->regHist(m_path + m_h_slbID->GetName(), m_h_slbID));
  
   m_h_bcID = new TH1F("h_bcID", "BCID", 100, 0, 10);
   m_h_bcID->StatOverflows();
   ATH_CHECK(m_thistSvc->regHist(m_path + m_h_bcID->GetName(), m_h_bcID));
  
   m_h_l1ID = new TH1F("h_l1ID", "L1ID", 100, 0, 10);
   m_h_l1ID->StatOverflows();
   ATH_CHECK(m_thistSvc->regHist(m_path + m_h_l1ID->GetName(), m_h_l1ID));
  
   m_h_type = new TH1F("h_type", "type (hit or coinc)", 100, 0, 10);
   m_h_type->StatOverflows();
   ATH_CHECK(m_thistSvc->regHist(m_path + m_h_type->GetName(), m_h_type));
  
   m_h_slbType = new TH1F("h_slbType", "SLB type", 100, 0, 10);
   m_h_slbType->StatOverflows();
   ATH_CHECK(m_thistSvc->regHist(m_path + m_h_slbType->GetName(), m_h_slbType));
  
   m_h_bitPos = new TH1F("h_bitPos", "Bitmap position", 100, 0, 220);
   m_h_bitPos->StatOverflows();
   ATH_CHECK(m_thistSvc->regHist(m_path + m_h_bitPos->GetName(), m_h_bitPos));
  
   m_h_track = new TH1F("h_track", "tracklet", 100, 0, 10);
   m_h_track->StatOverflows();
   ATH_CHECK(m_thistSvc->regHist(m_path + m_h_track->GetName(), m_h_track));
  
   m_h_adj = new TH1F("h_adj", "Adjacent", 100, 0, 2);
   m_h_adj->StatOverflows();
   ATH_CHECK(m_thistSvc->regHist(m_path + m_h_adj->GetName(), m_h_adj));
  
   m_h_sdoID = new TH1F("h_sdoID", "sdoID", 100, 0, 1e19);
   m_h_sdoID->StatOverflows();
   ATH_CHECK(m_thistSvc->regHist(m_path + m_h_sdoID->GetName(), m_h_sdoID));
  
   m_h_sdoWord = new TH1F("h_sdoWord", "sdoWord", 100, 0, 10);
   m_h_sdoWord->StatOverflows();
   ATH_CHECK(m_thistSvc->regHist(m_path + m_h_sdoWord->GetName(), m_h_sdoWord));
  
   m_h_xPos = new TH1F("h_xPos", "Global x-position (SDO)", 100, -15000, 15000);
   m_h_xPos->StatOverflows();
   ATH_CHECK(m_thistSvc->regHist(m_path + m_h_xPos->GetName(), m_h_xPos));
  
   m_h_yPos = new TH1F("h_yPos", "Global y-position (SDO)", 100, -15000, 15000);
   m_h_yPos->StatOverflows();
   ATH_CHECK(m_thistSvc->regHist(m_path + m_h_yPos->GetName(), m_h_yPos));
  
   m_h_zPos = new TH1F("h_zPos", "Global z-position (SDO)", 100, -15000, 15000);
   m_h_zPos->StatOverflows();
   ATH_CHECK(m_thistSvc->regHist(m_path + m_h_zPos->GetName(), m_h_zPos));
  
   m_h_barcode = new TH1F("h_barcode", "Barcode (SDO)", 100, 0, 2.2e9);
   m_h_barcode->StatOverflows();
   ATH_CHECK(m_thistSvc->regHist(m_path + m_h_barcode->GetName(), m_h_barcode));
  
   m_h_eventIndex = new TH1F("h_eventIndex", "Event index (SDO)", 100, 0, 1000);
   m_h_eventIndex->StatOverflows();
   ATH_CHECK(m_thistSvc->regHist(m_path + m_h_eventIndex->GetName(), m_h_eventIndex));
  
   m_h_radius = new TH1F("h_radius", "Radius (SDO)", 100, 0, 1);
   m_h_radius->StatOverflows();
   ATH_CHECK(m_thistSvc->regHist(m_path + m_h_radius->GetName(), m_h_radius));
  
   m_h_localZ = new TH1F("h_localZ", "Local z-position (SDO)", 100, -250, 250);
   m_h_localZ->StatOverflows();
   ATH_CHECK(m_thistSvc->regHist(m_path + m_h_localZ->GetName(), m_h_localZ));
  
   return StatusCode::SUCCESS;
 }

◆ inputHandles()

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

◆ msg() [1/2]

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                 {
     return this->msgStream();
   }

◆ msg() [2/2]

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

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                   {
     return this->msgStream(lvl);
   }

◆ msgLvl()

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

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

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

◆ renounceArray()

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

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                           {
     handlesArray.renounce();
   }

◆ sysInitialize()

StatusCode AthAlgorithm::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< Algorithm > >.

Reimplemented in AthAnalysisAlgorithm, AthFilterAlgorithm, PyAthena::Alg, and AthHistogramAlgorithm.

Definition at line 66 of file AthAlgorithm.cxx.

                                        {
   StatusCode sc=AthCommonDataStore<AthCommonMsg<Algorithm>>::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< 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< 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_adj

std::vector<bool>* TGC_RDOAnalysis::m_adj

private

Definition at line 71 of file TGC_RDOAnalysis.h.

◆ m_barcode

std::vector<int>* TGC_RDOAnalysis::m_barcode

private

Definition at line 106 of file TGC_RDOAnalysis.h.

◆ m_barcode_vec

std::vector< std::vector<int> >* TGC_RDOAnalysis::m_barcode_vec

private

Definition at line 110 of file TGC_RDOAnalysis.h.

◆ m_bcID

std::vector<uint16_t>* TGC_RDOAnalysis::m_bcID

private

Definition at line 60 of file TGC_RDOAnalysis.h.

◆ m_bcTag

std::vector<uint16_t>* TGC_RDOAnalysis::m_bcTag

private

Definition at line 53 of file TGC_RDOAnalysis.h.

◆ m_bitPos

std::vector<uint16_t>* TGC_RDOAnalysis::m_bitPos

private

Definition at line 68 of file TGC_RDOAnalysis.h.

◆ m_cand3plus

std::vector<bool>* TGC_RDOAnalysis::m_cand3plus

private

Definition at line 91 of file TGC_RDOAnalysis.h.

◆ m_chip

std::vector<uint16_t>* TGC_RDOAnalysis::m_chip

private

Definition at line 84 of file TGC_RDOAnalysis.h.

◆ m_coinc

std::vector<bool>* TGC_RDOAnalysis::m_coinc

private

Definition at line 65 of file TGC_RDOAnalysis.h.

◆ m_delta

std::vector<uint16_t>* TGC_RDOAnalysis::m_delta

private

Definition at line 79 of file TGC_RDOAnalysis.h.

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_eventIndex

std::vector<int>* TGC_RDOAnalysis::m_eventIndex

private

Definition at line 107 of file TGC_RDOAnalysis.h.

◆ m_eventIndex_vec

std::vector< std::vector<int> >* TGC_RDOAnalysis::m_eventIndex_vec

private

Definition at line 111 of file TGC_RDOAnalysis.h.

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_extendedExtraObjects

DataObjIDColl AthAlgorithm::m_extendedExtraObjects

privateinherited

Definition at line 79 of file AthAlgorithm.h.

◆ m_forward

std::vector<bool>* TGC_RDOAnalysis::m_forward

private

Definition at line 74 of file TGC_RDOAnalysis.h.

◆ m_h_adj

TH1* TGC_RDOAnalysis::m_h_adj

private

Definition at line 133 of file TGC_RDOAnalysis.h.

◆ m_h_barcode

TH1* TGC_RDOAnalysis::m_h_barcode

private

Definition at line 140 of file TGC_RDOAnalysis.h.

◆ m_h_bcID

TH1* TGC_RDOAnalysis::m_h_bcID

private

Definition at line 127 of file TGC_RDOAnalysis.h.

◆ m_h_bcTag

TH1* TGC_RDOAnalysis::m_h_bcTag

private

Definition at line 122 of file TGC_RDOAnalysis.h.

◆ m_h_bitPos

TH1* TGC_RDOAnalysis::m_h_bitPos

private

Definition at line 131 of file TGC_RDOAnalysis.h.

◆ m_h_eventIndex

TH1* TGC_RDOAnalysis::m_h_eventIndex

private

Definition at line 141 of file TGC_RDOAnalysis.h.

◆ m_h_l1ID

TH1* TGC_RDOAnalysis::m_h_l1ID

private

Definition at line 128 of file TGC_RDOAnalysis.h.

◆ m_h_localZ

TH1* TGC_RDOAnalysis::m_h_localZ

private

Definition at line 143 of file TGC_RDOAnalysis.h.

◆ m_h_radius

TH1* TGC_RDOAnalysis::m_h_radius

private

Definition at line 142 of file TGC_RDOAnalysis.h.

◆ m_h_rodID

TH1* TGC_RDOAnalysis::m_h_rodID

private

Definition at line 124 of file TGC_RDOAnalysis.h.

◆ m_h_sdoID

TH1* TGC_RDOAnalysis::m_h_sdoID

private

Definition at line 135 of file TGC_RDOAnalysis.h.

◆ m_h_sdoWord

TH1* TGC_RDOAnalysis::m_h_sdoWord

private

Definition at line 136 of file TGC_RDOAnalysis.h.

◆ m_h_slbID

TH1* TGC_RDOAnalysis::m_h_slbID

private

Definition at line 126 of file TGC_RDOAnalysis.h.

◆ m_h_slbType

TH1* TGC_RDOAnalysis::m_h_slbType

private

Definition at line 130 of file TGC_RDOAnalysis.h.

◆ m_h_sswID

TH1* TGC_RDOAnalysis::m_h_sswID

private

Definition at line 125 of file TGC_RDOAnalysis.h.

◆ m_h_subDetID

TH1* TGC_RDOAnalysis::m_h_subDetID

private

Definition at line 123 of file TGC_RDOAnalysis.h.

◆ m_h_tgcBcID

TH1* TGC_RDOAnalysis::m_h_tgcBcID

private

Definition at line 120 of file TGC_RDOAnalysis.h.

◆ m_h_tgcID

TH1* TGC_RDOAnalysis::m_h_tgcID

private

Definition at line 116 of file TGC_RDOAnalysis.h.

◆ m_h_tgcL1ID

TH1* TGC_RDOAnalysis::m_h_tgcL1ID

private

Definition at line 121 of file TGC_RDOAnalysis.h.

◆ m_h_tgcRodID

TH1* TGC_RDOAnalysis::m_h_tgcRodID

private

Definition at line 118 of file TGC_RDOAnalysis.h.

◆ m_h_tgcSubDetID

TH1* TGC_RDOAnalysis::m_h_tgcSubDetID

private

Definition at line 117 of file TGC_RDOAnalysis.h.

◆ m_h_tgcTrigType

TH1* TGC_RDOAnalysis::m_h_tgcTrigType

private

Definition at line 119 of file TGC_RDOAnalysis.h.

◆ m_h_track

TH1* TGC_RDOAnalysis::m_h_track

private

Definition at line 132 of file TGC_RDOAnalysis.h.

◆ m_h_type

TH1* TGC_RDOAnalysis::m_h_type

private

Definition at line 129 of file TGC_RDOAnalysis.h.

◆ m_h_xPos

TH1* TGC_RDOAnalysis::m_h_xPos

private

Definition at line 137 of file TGC_RDOAnalysis.h.

◆ m_h_yPos

TH1* TGC_RDOAnalysis::m_h_yPos

private

Definition at line 138 of file TGC_RDOAnalysis.h.

◆ m_h_zPos

TH1* TGC_RDOAnalysis::m_h_zPos

private

Definition at line 139 of file TGC_RDOAnalysis.h.

◆ m_hipt

std::vector<bool>* TGC_RDOAnalysis::m_hipt

private

Definition at line 85 of file TGC_RDOAnalysis.h.

◆ m_hitID

std::vector<uint16_t>* TGC_RDOAnalysis::m_hitID

private

Definition at line 86 of file TGC_RDOAnalysis.h.

◆ m_hsub

std::vector<uint16_t>* TGC_RDOAnalysis::m_hsub

private

Definition at line 87 of file TGC_RDOAnalysis.h.

◆ m_index

std::vector<uint16_t>* TGC_RDOAnalysis::m_index

private

Definition at line 76 of file TGC_RDOAnalysis.h.

◆ m_inner

std::vector<uint16_t>* TGC_RDOAnalysis::m_inner

private

Definition at line 89 of file TGC_RDOAnalysis.h.

◆ m_inputKey

SG::ReadHandleKey<TgcRdoContainer> TGC_RDOAnalysis::m_inputKey

private

Definition at line 35 of file TGC_RDOAnalysis.h.

◆ m_inputTruthKey

SG::ReadHandleKey<MuonSimDataCollection> TGC_RDOAnalysis::m_inputTruthKey

private

Definition at line 36 of file TGC_RDOAnalysis.h.

◆ m_l1ID

std::vector<uint16_t>* TGC_RDOAnalysis::m_l1ID

private

Definition at line 61 of file TGC_RDOAnalysis.h.

◆ m_localZ

std::vector<float>* TGC_RDOAnalysis::m_localZ

private

Definition at line 109 of file TGC_RDOAnalysis.h.

◆ m_localZ_vec

std::vector< std::vector<float> >* TGC_RDOAnalysis::m_localZ_vec

private

Definition at line 113 of file TGC_RDOAnalysis.h.

◆ m_muplus

std::vector<bool>* TGC_RDOAnalysis::m_muplus

private

Definition at line 92 of file TGC_RDOAnalysis.h.

◆ m_ntupleDirName

std::string TGC_RDOAnalysis::m_ntupleDirName

private

Definition at line 147 of file TGC_RDOAnalysis.h.

◆ m_ntupleFileName

std::string TGC_RDOAnalysis::m_ntupleFileName

private

Definition at line 146 of file TGC_RDOAnalysis.h.

◆ m_ntupleTreeName

std::string TGC_RDOAnalysis::m_ntupleTreeName

private

Definition at line 148 of file TGC_RDOAnalysis.h.

◆ m_overlap

std::vector<bool>* TGC_RDOAnalysis::m_overlap

private

Definition at line 94 of file TGC_RDOAnalysis.h.

◆ m_path

std::string TGC_RDOAnalysis::m_path

private

Definition at line 149 of file TGC_RDOAnalysis.h.

◆ m_pos

std::vector<uint16_t>* TGC_RDOAnalysis::m_pos

private

Definition at line 78 of file TGC_RDOAnalysis.h.

◆ m_radius

std::vector<double>* TGC_RDOAnalysis::m_radius

private

Definition at line 108 of file TGC_RDOAnalysis.h.

◆ m_radius_vec

std::vector< std::vector<double> >* TGC_RDOAnalysis::m_radius_vec

private

Definition at line 112 of file TGC_RDOAnalysis.h.

◆ m_rodID

std::vector<uint16_t>* TGC_RDOAnalysis::m_rodID

private

Definition at line 56 of file TGC_RDOAnalysis.h.

◆ m_roi

std::vector<uint16_t>* TGC_RDOAnalysis::m_roi

private

Definition at line 96 of file TGC_RDOAnalysis.h.

◆ m_sdoID

std::vector<unsigned long long>* TGC_RDOAnalysis::m_sdoID

private

Definition at line 100 of file TGC_RDOAnalysis.h.

◆ m_sdoWord

std::vector<int>* TGC_RDOAnalysis::m_sdoWord

private

Definition at line 101 of file TGC_RDOAnalysis.h.

◆ m_sector

std::vector<uint16_t>* TGC_RDOAnalysis::m_sector

private

Definition at line 83 of file TGC_RDOAnalysis.h.

◆ m_segment

std::vector<uint16_t>* TGC_RDOAnalysis::m_segment

private

Definition at line 80 of file TGC_RDOAnalysis.h.

◆ m_slbID

std::vector<uint16_t>* TGC_RDOAnalysis::m_slbID

private

Definition at line 58 of file TGC_RDOAnalysis.h.

◆ m_slbType

std::vector<int>* TGC_RDOAnalysis::m_slbType

private

Definition at line 64 of file TGC_RDOAnalysis.h.

◆ m_sswID

std::vector<uint16_t>* TGC_RDOAnalysis::m_sswID

private

Definition at line 57 of file TGC_RDOAnalysis.h.

◆ m_strip

std::vector<bool>* TGC_RDOAnalysis::m_strip

private

Definition at line 88 of file TGC_RDOAnalysis.h.

◆ m_subDetID

std::vector<uint16_t>* TGC_RDOAnalysis::m_subDetID

private

Definition at line 55 of file TGC_RDOAnalysis.h.

◆ m_subMat

std::vector<uint16_t>* TGC_RDOAnalysis::m_subMat

private

Definition at line 81 of file TGC_RDOAnalysis.h.

◆ m_tgcBcID

std::vector<uint16_t>* TGC_RDOAnalysis::m_tgcBcID

private

Definition at line 42 of file TGC_RDOAnalysis.h.

◆ m_tgcID

std::vector<uint16_t>* TGC_RDOAnalysis::m_tgcID

private

Definition at line 38 of file TGC_RDOAnalysis.h.

◆ m_tgcL1ID

std::vector<uint16_t>* TGC_RDOAnalysis::m_tgcL1ID

private

Definition at line 43 of file TGC_RDOAnalysis.h.

◆ m_tgcOrbit

std::vector<uint32_t>* TGC_RDOAnalysis::m_tgcOrbit

private

Definition at line 47 of file TGC_RDOAnalysis.h.

◆ m_tgcRodID

std::vector<uint16_t>* TGC_RDOAnalysis::m_tgcRodID

private

Definition at line 40 of file TGC_RDOAnalysis.h.

◆ m_tgcSubDetID

std::vector<uint16_t>* TGC_RDOAnalysis::m_tgcSubDetID

private

Definition at line 39 of file TGC_RDOAnalysis.h.

◆ m_tgcTrigType

std::vector<uint16_t>* TGC_RDOAnalysis::m_tgcTrigType

private

Definition at line 41 of file TGC_RDOAnalysis.h.

◆ m_tgcVersion

std::vector<uint16_t>* TGC_RDOAnalysis::m_tgcVersion

private

Definition at line 48 of file TGC_RDOAnalysis.h.

◆ m_thistSvc

ServiceHandle<ITHistSvc> TGC_RDOAnalysis::m_thistSvc

private

Definition at line 150 of file TGC_RDOAnalysis.h.

◆ m_thresh

std::vector<bool>* TGC_RDOAnalysis::m_thresh

private

Definition at line 93 of file TGC_RDOAnalysis.h.

◆ m_track

std::vector<uint16_t>* TGC_RDOAnalysis::m_track

private

Definition at line 70 of file TGC_RDOAnalysis.h.

◆ m_tree

TTree* TGC_RDOAnalysis::m_tree

private

Definition at line 145 of file TGC_RDOAnalysis.h.

◆ m_type

std::vector<int>* TGC_RDOAnalysis::m_type

private

Definition at line 63 of file TGC_RDOAnalysis.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Algorithm > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_veto

std::vector<bool>* TGC_RDOAnalysis::m_veto

private

Definition at line 95 of file TGC_RDOAnalysis.h.

◆ m_vhka

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

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

◆ m_xPos

std::vector<float>* TGC_RDOAnalysis::m_xPos

private

Definition at line 102 of file TGC_RDOAnalysis.h.

◆ m_yPos

std::vector<float>* TGC_RDOAnalysis::m_yPos

private

Definition at line 103 of file TGC_RDOAnalysis.h.

◆ m_zPos

std::vector<float>* TGC_RDOAnalysis::m_zPos

private

Definition at line 104 of file TGC_RDOAnalysis.h.

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

Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ StoreGateSvc_t

Constructor & Destructor Documentation

◆ TGC_RDOAnalysis()

◆ ~TGC_RDOAnalysis()

Member Function Documentation

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

◆ execute()

◆ extraDeps_update_handler()

◆ extraOutputDeps()

◆ finalize()

◆ initialize()

◆ inputHandles()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msgLvl()

◆ outputHandles()

◆ renounce()

◆ renounceArray()

◆ sysInitialize()

◆ sysStart()

◆ updateVHKA()

Member Data Documentation

◆ m_adj

◆ m_barcode

◆ m_barcode_vec

◆ m_bcID

◆ m_bcTag

◆ m_bitPos

◆ m_cand3plus

◆ m_chip

◆ m_coinc

◆ m_delta

◆ m_detStore

◆ m_eventIndex

◆ m_eventIndex_vec

◆ m_evtStore

◆ m_extendedExtraObjects

◆ m_forward

◆ m_h_adj

◆ m_h_barcode

◆ m_h_bcID

◆ m_h_bcTag

◆ m_h_bitPos

◆ m_h_eventIndex

◆ m_h_l1ID

◆ m_h_localZ

◆ m_h_radius

◆ m_h_rodID

◆ m_h_sdoID

◆ m_h_sdoWord

◆ m_h_slbID

◆ m_h_slbType

◆ m_h_sswID

◆ m_h_subDetID

◆ m_h_tgcBcID

◆ m_h_tgcID

◆ m_h_tgcL1ID

◆ m_h_tgcRodID

◆ m_h_tgcSubDetID

◆ m_h_tgcTrigType

◆ m_h_track