#include <FPGATrackSimGenScanMonitoring.h>

Inheritance diagram for FPGATrackSimGenScanMonitoring:

Collaboration diagram for FPGATrackSimGenScanMonitoring:

Classes
struct	eventDispSet

Public Member Functions
	FPGATrackSimGenScanMonitoring (const std::string &, const std::string &, const IInterface *)

virtual StatusCode	initialize () override

StatusCode	registerHistograms (unsigned nLayers, const FPGATrackSimGenScanBinningBase *binning, double rin, double rout)

void	allocateDataFlowCounters ()

void	resetDataFlowCounters ()

StatusCode	registerGraphs ()

const std::string	dir () const

void	parseTruthInfo (std::vector< FPGATrackSimTruthTrack > const *truthtracks, bool isSingleParticle, const FPGATrackSimGenScanArray< int > &validBin)

void	fillHitLevelInput (const FPGATrackSimHit *hit)

void	fillBinLevelOutput (const FPGATrackSimGenScanBinningBase::IdxSet &idx, const FPGATrackSimGenScanTool::BinEntry &data, const std::vector< std::vector< const FPGATrackSimGenScanTool::StoredHit * > > &hitsByLayer)

void	fillPairingHits (std::vector< const FPGATrackSimGenScanTool::StoredHit * > const lastlyr, std::vector< const FPGATrackSimGenScanTool::StoredHit > const *lastlastlyr)

void	fillPairFilterCuts (const FPGATrackSimGenScanTool::HitPair &pair)

void	fillPairSetFilterCut (std::vector< TH1D * > &histset, double val, const FPGATrackSimGenScanTool::HitPair &pair, const FPGATrackSimGenScanTool::HitPair &lastpair, bool nminus1)

void	fillInputSummary (const std::vector< std::shared_ptr< const FPGATrackSimHit >> &hits, const FPGATrackSimGenScanArray< int > &validSlice, const FPGATrackSimGenScanArray< int > &validScan)

void	fillOutputSummary (const FPGATrackSimGenScanArray< int > &validSlice, const FPGATrackSimGenScanArray< int > &validSliceAndScan)

void	fillBuildGroupsWithPairs (const std::vector< FPGATrackSimGenScanTool::IntermediateState > &states, unsigned allowed_misses)

void	incrementInputPerSlice (const std::vector< unsigned > &sliceidx)

void	incrementInputPerScan (const FPGATrackSimGenScanBinningBase::IdxSet &idx, const std::pair< unsigned, unsigned > &rowRange, const FPGATrackSimHit *hit)

void	sliceCheck (const std::vector< unsigned > &sliceidx)

void	pairFilterCheck (const FPGATrackSimGenScanTool::HitPairSet &pairs, const FPGATrackSimGenScanTool::HitPairSet &filteredpairs, bool passedPairFilter)

void	pairSetFilterCheck (const FPGATrackSimGenScanTool::HitPairSet &filteredpairs, const std::vector< FPGATrackSimGenScanTool::HitPairSet > &pairsets, unsigned threshold)

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

Public Attributes
std::vector< TH1D * >	m_deltaDeltaPhi

std::vector< TH1D * >	m_deltaDeltaEta

std::vector< TH1D * >	m_pairSetMatchPhi

std::vector< TH1D * >	m_pairSetMatchEta

std::vector< TH1D * >	m_phiCurvature

std::vector< TH1D * >	m_etaCurvature

std::vector< TH1D * >	m_deltaPhiCurvature

std::vector< TH1D * >	m_deltaEtaCurvature

std::vector< TH1D * >	m_phiCurvatureMax

std::vector< TH1D * >	m_etaCurvatureMax

std::vector< TH1D * >	m_phiInExtrapCurved

std::vector< TH1D * >	m_phiOutExtrapCurved

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	setBinPlotsActive (const FPGATrackSimGenScanBinningBase::IdxSet &idx)

unsigned	pairpairCategory (const FPGATrackSimGenScanTool::HitPair &pair, const FPGATrackSimGenScanTool::HitPair &lastpair) const

template<typename HistType , typename... HistDef>
StatusCode	makeAndRegHist (HistType *&ptr, HistDef... histargs)

template<typename HistType , typename... HistDef>
StatusCode	makeAndRegHistVector (std::vector< HistType * > &vec, unsigned len, const std::vector< std::string > namevec, const char namebase, HistDef... histargs)

StatusCode	regGraph (TGraph *g) const

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
	specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
	specialization for handling Gaudi::Property<SG::VarHandleBase> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
	specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...

Private Attributes
ServiceHandle< ITHistSvc >	m_tHistSvc {this, "THistSvc", "THistSvc"}

Gaudi::Property< std::string >	m_dir {this, "dir", {"/GENSCAN/"}, "String name of output directory"}

unsigned	m_nLayers = 0

const FPGATrackSimGenScanBinningBase *	m_binning {nullptr}

double	m_rin =0.0

double	m_rout =0.0

std::vector< FPGATrackSimTruthTrack > const *	m_truthtracks {nullptr}

bool	m_isSingleParticle = false

bool	m_truthIsValid = false

FPGATrackSimTrackPars	m_truthpars

FPGATrackSimGenScanBinningBase::IdxSet	m_truthbin

FPGATrackSimGenScanBinningBase::ParSet	m_truthparset

bool	m_binPlotsActive = false

std::vector< unsigned >	m_hitsCntByLayer

FPGATrackSimGenScanArray< int >	m_inputhitsperslice

FPGATrackSimGenScanArray< int >	m_inputhitsperrow

FPGATrackSimGenScanArray< int >	m_outputhitsperslice

FPGATrackSimGenScanArray< int >	m_outputhitsperrow

FPGATrackSimGenScanArray< int >	m_outputroadsperrow

std::vector< TH2D * >	m_rZ_allhits

TH1D *	m_truthpars_hists [5] = {0, 0, 0, 0, 0}

std::vector< TH1D * >	m_phiResidual

std::vector< TH1D * >	m_etaResidual

std::vector< TH1D * >	m_phiTrueBinShift

std::vector< TH1D * >	m_etaTrueBinShift

TH1D *	m_inputHits = 0

TH1D *	m_inputHitsPerSlice = 0

TH1D *	m_outputHitsPerSlice = 0

TH1D *	m_inputHitsPerRow = 0

TH1D *	m_outputHitsPerRow = 0

TH1D *	m_outputRoadsPerRow = 0

TH1D *	m_outputHitsPerBin = 0

TH2D *	m_hitsPerLayer2D = 0

TH1D *	m_hitsPerLayer = 0

TH1D *	m_hitsLoadedPerLayer = 0

TH1D *	m_hitLyrsAllBins = 0

TH1D *	m_phiShift_road = 0

TH1D *	m_etaShift_road = 0

TH2D *	m_phiShift2D_road = 0

TH2D *	m_etaShift2D_road = 0

TH2D *	m_hitsPerLayer_road = 0

TH1D *	m_pairs = 0

TH1D *	m_filteredpairs = 0

TH1D *	m_pairsets = 0

TH2D *	m_unpairedHits = 0

TH2D *	m_pairsetsIncr = 0

TH2D *	m_pairsetsHits = 0

TH2D *	m_binStagesIncr = 0

TH2D *	m_totalInputIncr = 0

TH1D *	m_pairinghits = 0

TH1D *	m_roadFilterFlow = 0

TH1D *	m_deltaPhi = 0

TH1D *	m_deltaEta = 0

TH1D *	m_deltaPhiDR = 0

TH1D *	m_deltaEtaDR = 0

TH1D *	m_phiOutExtrap = 0

TH1D *	m_phiInExtrap = 0

TH1D *	m_phiOutExtrapCurveLimit =0

TH1D *	m_phiInExtrapCurveLimit =0

TH1D *	m_etaOutExtrap = 0

TH1D *	m_etaInExtrap = 0

std::vector< TH1D * >	m_deltaPhiByLyr

std::vector< TH1D * >	m_deltaEtaByLyr

unsigned	m_nminus1_idx = 6

TH2D *	m_pairMatchPhi2D = 0

TH2D *	m_pairMatchEta2D = 0

eventDispSet	m_allHitsGraph {std::string("allHits"), 10}

eventDispSet	m_roadGraph {std::string("road"), 10}

eventDispSet	m_lostPairFilterGraph {std::string("lostpairfilter"), 10}

eventDispSet	m_passPairFilterGraph {std::string("passpairfilter"), 10}

eventDispSet	m_lostPairSetFilterGraph {std::string("lostpairsetfilter"), 10}

eventDispSet	m_passPairSetFilterGraph {std::string("passpairsetfilter"), 10}

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

Static Private Attributes
static const std::vector< std::string >	m_twoPairClasses

Detailed Description

Definition at line 36 of file FPGATrackSimGenScanMonitoring.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

◆ FPGATrackSimGenScanMonitoring()

FPGATrackSimGenScanMonitoring::FPGATrackSimGenScanMonitoring	(	const std::string &	algname,
		const std::string &	name,
		const IInterface *	ifc
	)

Definition at line 14 of file FPGATrackSimGenScanMonitoring.cxx.

                                                                                                                                    :
   AthAlgTool(algname, name, ifc)
 {
 }

Member Function Documentation

◆ allocateDataFlowCounters()

void FPGATrackSimGenScanMonitoring::allocateDataFlowCounters ( )

Definition at line 184 of file FPGATrackSimGenScanMonitoring.cxx.

                                                              {
  
   m_hitsCntByLayer.resize(m_nLayers,0);
   
   m_inputhitsperslice.setsize(m_binning->sliceBins(), 0);
   m_inputhitsperrow.setsize(m_binning->sliceAndScanBins(), 0);
  
   m_outputhitsperslice.setsize(m_binning->sliceBins(), 0);
   m_outputhitsperrow.setsize(m_binning->sliceAndScanBins(),0);
   m_outputroadsperrow.setsize(m_binning->sliceAndScanBins(),0);
 }

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

◆ dir()

const std::string FPGATrackSimGenScanMonitoring::dir ( ) const

inline

Definition at line 58 of file FPGATrackSimGenScanMonitoring.h.

58 {return m_dir;}

◆ 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

◆ fillBinLevelOutput()

void FPGATrackSimGenScanMonitoring::fillBinLevelOutput	(	const FPGATrackSimGenScanBinningBase::IdxSet &	idx,
		const FPGATrackSimGenScanTool::BinEntry &	data,
		const std::vector< std::vector< const FPGATrackSimGenScanTool::StoredHit * > > &	hitsByLayer
	)

Definition at line 227 of file FPGATrackSimGenScanMonitoring.cxx.

 {
   setBinPlotsActive(idx);
  
   m_outputHitsPerBin->Fill(data.hits.size());
   m_outputhitsperslice[m_binning->sliceIdx(idx)] += data.hits.size();
   m_outputhitsperrow[m_binning->sliceAndScanIdx(idx)] += data.hits.size();
   m_outputroadsperrow[m_binning->sliceAndScanIdx(idx)] += 1;
  
   m_roadGraph.addEvent(data.hits);
  
   if (m_binPlotsActive) {
     for (auto& hit : data.hits) {
       m_phiShift_road->Fill(hit.phiShift);
       m_etaShift_road->Fill(hit.etaShift);
       m_phiShift2D_road->Fill(hit.phiShift, hit.hitptr->getR());
       m_etaShift2D_road->Fill(hit.etaShift, hit.hitptr->getR());
     }
   }
  
   for (unsigned lyr = 0; lyr < m_nLayers; lyr++)
   {
     m_hitsPerLayer_road->Fill(lyr, hitsByLayer[lyr].size());
   }
 }

◆ fillBuildGroupsWithPairs()

void FPGATrackSimGenScanMonitoring::fillBuildGroupsWithPairs	(	const std::vector< FPGATrackSimGenScanTool::IntermediateState > &	states,
		unsigned	allowed_misses
	)

Definition at line 558 of file FPGATrackSimGenScanMonitoring.cxx.

                              {
  
   for (unsigned i = 0; i < states.size(); i++) {
     m_unpairedHits->Fill(i, states[i].unpairedHits.size());
     m_pairsetsIncr->Fill(i, states[i].pairsets.size());
     for (auto& pair : states[i].pairsets) {
       m_pairsetsHits->Fill(i, pair.hitlist.size());
     }
     unsigned totalInput = states[i].pairsets.size() +states[i].unpairedHits.size();
     m_totalInputIncr->Fill(i, totalInput);
     m_binStagesIncr->Fill(i, (i <= allowed_misses)||(totalInput>0));
   }
 }

◆ fillHitLevelInput()

void FPGATrackSimGenScanMonitoring::fillHitLevelInput ( const FPGATrackSimHit * hit )

Definition at line 255 of file FPGATrackSimGenScanMonitoring.cxx.

                                                                                  {
   m_rZ_allhits[m_nLayers]->Fill(hit->getZ(), hit->getR());       // all layer plot
   m_rZ_allhits[hit->getLayer()]->Fill(hit->getZ(), hit->getR()); // layer specific plot
   m_hitsCntByLayer[hit->getLayer()]++;
   if (m_truthIsValid)
     {
       m_etaResidual[m_nLayers]->Fill(m_binning->etaResidual(m_truthparset, hit));
       m_etaResidual[hit->getLayer()]->Fill(m_binning->etaResidual(m_truthparset, hit));
       m_phiResidual[m_nLayers]->Fill(m_binning->phiResidual(m_truthparset, hit));
       m_phiResidual[hit->getLayer()]->Fill(m_binning->phiResidual(m_truthparset, hit));
  
       if (m_truthbin != m_binning->m_invalidBin) {
         m_etaTrueBinShift[m_nLayers]->Fill(m_binning->etaShift(m_truthbin,hit)); 
         m_etaTrueBinShift[hit->getLayer()]->Fill(m_binning->etaShift(m_truthbin,hit)); 
         m_phiTrueBinShift[m_nLayers]->Fill(m_binning->phiShift(m_truthbin,hit)); 
         m_phiTrueBinShift[hit->getLayer()]->Fill(m_binning->phiShift(m_truthbin,hit)); 
       }
   }
 }

◆ fillInputSummary()

void FPGATrackSimGenScanMonitoring::fillInputSummary	(	const std::vector< std::shared_ptr< const FPGATrackSimHit >> &	hits,
		const FPGATrackSimGenScanArray< int > &	validSlice,
		const FPGATrackSimGenScanArray< int > &	validScan
	)

Definition at line 322 of file FPGATrackSimGenScanMonitoring.cxx.

 {
   m_inputHits->Fill(hits.size());
   m_allHitsGraph.addEvent(hits);
  
   for (FPGATrackSimGenScanArray<int>::Iterator& val : m_inputhitsperslice)
   {
     if (!validSlice[val.idx()]) continue;
     m_inputHitsPerSlice->Fill(val.data());
   }
  
   for (FPGATrackSimGenScanArray<int>::Iterator& val : m_inputhitsperrow)
   {
     if (!validSliceAndScan[val.idx()]) continue;
     m_inputHitsPerRow->Fill(val.data());
   }
  
   for (unsigned i = 0; i < m_nLayers; i++)
   {
     m_hitsPerLayer->Fill(i, m_hitsCntByLayer[i]);
     m_hitsPerLayer2D->Fill(i, m_hitsCntByLayer[i]);
   }
 }

◆ fillOutputSummary()

void FPGATrackSimGenScanMonitoring::fillOutputSummary	(	const FPGATrackSimGenScanArray< int > &	validSlice,
		const FPGATrackSimGenScanArray< int > &	validSliceAndScan
	)

Definition at line 349 of file FPGATrackSimGenScanMonitoring.cxx.

 {
   for (FPGATrackSimGenScanArray<int>::Iterator& val : m_outputhitsperslice)
   {
     if (!validSlice[val.idx()]) continue;
     m_outputHitsPerSlice->Fill(val.data());
   }
   for (FPGATrackSimGenScanArray<int>::Iterator& val : m_outputhitsperrow)
   {
     if (!validSliceAndScan[val.idx()]) continue;
     m_outputHitsPerRow->Fill(val.data());
   }
   for (FPGATrackSimGenScanArray<int>::Iterator& val : m_outputroadsperrow) {
     if (!validSliceAndScan[val.idx()]) continue;
     m_outputRoadsPerRow->Fill(val.data());
   }
 }

◆ fillPairFilterCuts()

void FPGATrackSimGenScanMonitoring::fillPairFilterCuts ( const FPGATrackSimGenScanTool::HitPair & pair )

Definition at line 455 of file FPGATrackSimGenScanMonitoring.cxx.

                                                 {
  // m_pairs->Fill(pairs.pairList.size());
   if (m_binPlotsActive) {
       int lyr = pair.first->hitptr->getLayer();
       m_deltaPhi->Fill(pair.dPhi());
       m_deltaEta->Fill(pair.dEta());
       m_deltaPhiDR->Fill(pair.dPhi() / pair.dR());
       m_deltaEtaDR->Fill(pair.dEta() / pair.dR());
       m_deltaPhiByLyr[lyr]->Fill(pair.dPhi());
       m_deltaEtaByLyr[lyr]->Fill(pair.dEta());
       m_phiInExtrap->Fill(pair.PhiInExtrap(m_rin));
       m_phiOutExtrap->Fill(pair.PhiOutExtrap(m_rout));
       m_etaInExtrap->Fill(pair.EtaInExtrap(m_rin));
       m_etaOutExtrap->Fill(pair.EtaOutExtrap(m_rout));
   }
 }

◆ fillPairingHits()

void FPGATrackSimGenScanMonitoring::fillPairingHits	(	std::vector< const FPGATrackSimGenScanTool::StoredHit * > const *	lastlyr,
		std::vector< const FPGATrackSimGenScanTool::StoredHit * > const *	lastlastlyr
	)

Definition at line 437 of file FPGATrackSimGenScanMonitoring.cxx.

                       {
  
   auto size_if_nonzero_ptr =
       [](std::vector<const FPGATrackSimGenScanTool::StoredHit *> const *ptr) {
         if (ptr) {
           return int(ptr->size());
         } else {
           return 0;
         }
       };
  
   m_pairinghits->Fill(size_if_nonzero_ptr(lastlyr) +
                       size_if_nonzero_ptr(lastlastlyr));
 }

◆ fillPairSetFilterCut()

void FPGATrackSimGenScanMonitoring::fillPairSetFilterCut	(	std::vector< TH1D * > &	histset,
		double	val,
		const FPGATrackSimGenScanTool::HitPair &	pair,
		const FPGATrackSimGenScanTool::HitPair &	lastpair,
		bool	nminus1
	)

Definition at line 526 of file FPGATrackSimGenScanMonitoring.cxx.

                                                                   {
   
   if (m_binPlotsActive) {
     unsigned ppcat = pairpairCategory(pair, lastpair);
     histset[0]->Fill(val); // 0 is "all"
     histset[ppcat]->Fill(val); // 0 is "all"
     if (nminus1)
       histset[m_nminus1_idx]->Fill(val);
   }
  
 }

◆ incrementInputPerScan()

void FPGATrackSimGenScanMonitoring::incrementInputPerScan	(	const FPGATrackSimGenScanBinningBase::IdxSet &	idx,
		const std::pair< unsigned, unsigned > &	rowRange,
		const FPGATrackSimHit *	hit
	)

Definition at line 307 of file FPGATrackSimGenScanMonitoring.cxx.

                                                                              {
   if (rowRange.second > rowRange.first) {
     m_hitsLoadedPerLayer->Fill(double(hit->getLayer()));
     m_inputhitsperrow[m_binning->sliceAndScanIdx(idx)]++;
   } else {
     // Nice debug check for if hit is in the truthbin for single track sample
     if (m_truthIsValid && 
        (m_binning->subVec(m_binning->scanPars(), m_truthbin) == (m_binning->subVec(m_binning->scanPars(), idx)))) {
         ATH_MSG_DEBUG("truth bin missed row ");
     }
   }
 }

◆ incrementInputPerSlice()

void FPGATrackSimGenScanMonitoring::incrementInputPerSlice ( const std::vector< unsigned > & sliceidx )

inline

Definition at line 89 of file FPGATrackSimGenScanMonitoring.h.

89 { m_inputhitsperslice[sliceidx]++; }

◆ initialize()

StatusCode FPGATrackSimGenScanMonitoring::initialize ( )

overridevirtual

Definition at line 19 of file FPGATrackSimGenScanMonitoring.cxx.

 {
   // Dump the configuration to make sure it propagated through right  
   auto props = this->getProperties();
   for( Gaudi::Details::PropertyBase* prop : props ) {
     if (prop->ownerTypeName()==this->type()) {      
       ATH_MSG_DEBUG("Property:\t" << prop->name() << "\t : \t" << prop->toString());
     }
   }
  
   ATH_CHECK(m_tHistSvc.retrieve());
  
   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.

◆ makeAndRegHist()

template<typename HistType , typename... HistDef>

StatusCode FPGATrackSimGenScanMonitoring::makeAndRegHist	(	HistType *&	ptr,
		HistDef...	histargs
	)

inlineprivate

Definition at line 279 of file FPGATrackSimGenScanMonitoring.h.

     {   
         ptr = new HistType(histargs...);
         ATH_CHECK(m_tHistSvc->regHist(m_dir + ptr->GetName(), ptr));
         return StatusCode::SUCCESS;
     }

◆ makeAndRegHistVector()

template<typename HistType , typename... HistDef>

StatusCode FPGATrackSimGenScanMonitoring::makeAndRegHistVector	(	std::vector< HistType * > &	vec,
		unsigned	len,
		const std::vector< std::string > *	namevec,
		const char *	namebase,
		HistDef...	histargs
	)

inlineprivate

Definition at line 288 of file FPGATrackSimGenScanMonitoring.h.

     {
         if (vec.size()==0){
             for (unsigned i = 0; i < len; i++) {
                 HistType *ptr = 0;
                 std::string name = std::string(namebase);
                 if (!namevec) {
                     name += std::to_string(i); 
                 } else {
                     if (namevec->size()==len) {
                         name += (*namevec)[i];
                     } else {
                         return StatusCode::FAILURE;
                     }
                 }
                 ATH_CHECK(makeAndRegHist(ptr, name.c_str(), histargs...));            
                 vec.push_back(ptr);
             }
         }
         return StatusCode::SUCCESS;
     }

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

◆ pairFilterCheck()

void FPGATrackSimGenScanMonitoring::pairFilterCheck	(	const FPGATrackSimGenScanTool::HitPairSet &	pairs,
		const FPGATrackSimGenScanTool::HitPairSet &	filteredpairs,
		bool	passedPairFilter
	)

Definition at line 282 of file FPGATrackSimGenScanMonitoring.cxx.

                            {
  
   m_roadFilterFlow->Fill(0);
   m_pairs->Fill(pairs.pairList.size());
   m_filteredpairs->Fill(filteredpairs.pairList.size());
  
   if (passedPairFilter) {
     // if passed mark progress in flow histogram and make passed Histogram
     m_roadFilterFlow->Fill(1);
     m_passPairFilterGraph.addEvent(filteredpairs.hitlist);
   } else {
     // If the true bin didn't pass print some debug and make a lost event
     // display
     if (m_binPlotsActive) {
       ATH_MSG_INFO("lost at pair filter : hit layers = "
                    << filteredpairs.lyrCnt() << " "
                    << std::bitset<16>(filteredpairs.hitLayers));
       m_lostPairFilterGraph.addEvent(pairs.hitlist);
     }
   }
 }

◆ pairpairCategory()

unsigned FPGATrackSimGenScanMonitoring::pairpairCategory	(	const FPGATrackSimGenScanTool::HitPair &	pair,
		const FPGATrackSimGenScanTool::HitPair &	lastpair
	)		const

private

Definition at line 479 of file FPGATrackSimGenScanMonitoring.cxx.

 {
   int minlyr = std::min(lastpair.first->layer, lastpair.second->layer);
   minlyr = std::min(minlyr, pair.first->layer);
   minlyr = std::min(minlyr, pair.second->layer);
  
   unsigned hitbits =
       ((1 << lastpair.first->layer) | (1 << lastpair.second->layer) |
        (1 << pair.first->layer) | (1 << pair.second->layer));
   hitbits = hitbits >> minlyr;  // now bit list starts with lowest hit layer
  
   int hitlyrs = __builtin_popcount(hitbits);
  
   assert(hitbits & 0x1);
  
   unsigned retv = 0;
   if (hitlyrs == 2)  // must be same layers
   {
     retv = 1;
   } else if (hitlyrs == 3) {
     if (hitbits == 0b111)  // 3 bits in a row -> adjacent layers
     {
       if ((lastpair.first->layer == pair.second->layer) ||
           (pair.first->layer == lastpair.second->layer)) {
         retv = 2;  // sequential
       } else {
         retv = 3;  // one is a skip and the other isn't
       }
     } else if ((hitbits == 0b1101) || (hitbits == 0b1011))  // skips 1 layer
     {
       retv = 4;
     }
   } else {
     retv = 5;
   }
  
   ATH_MSG_VERBOSE("pairpairCat "
                 << m_twoPairClasses[retv] << " " << lastpair.first->layer << " "
                 << lastpair.second->layer << " " << pair.first->layer << " "
                 << pair.second->layer << " : " << minlyr << " "
                 << std::bitset<16>(hitbits));
  
   return retv;
 }

◆ pairSetFilterCheck()

void FPGATrackSimGenScanMonitoring::pairSetFilterCheck	(	const FPGATrackSimGenScanTool::HitPairSet &	filteredpairs,
		const std::vector< FPGATrackSimGenScanTool::HitPairSet > &	pairsets,
		unsigned	threshold
	)

Definition at line 541 of file FPGATrackSimGenScanMonitoring.cxx.

                         {
   m_pairsets->Fill(pairsets.size());
  
   for (auto pairset : pairsets) {
     // if over threshold add it to the output
     if (pairset.lyrCnt() >= threshold) {
       m_roadFilterFlow->Fill(3);
       m_passPairSetFilterGraph.addEvent(pairset.hitlist);
     } else {
       m_lostPairSetFilterGraph.addEvent(filteredpairs.hitlist);
     }
   }
 }

◆ parseTruthInfo()

void FPGATrackSimGenScanMonitoring::parseTruthInfo	(	std::vector< FPGATrackSimTruthTrack > const *	truthtracks,
		bool	isSingleParticle,
		const FPGATrackSimGenScanArray< int > &	validBin
	)

Definition at line 371 of file FPGATrackSimGenScanMonitoring.cxx.

 {
   ATH_MSG_DEBUG("In parseTruthInfo ptr = " << truthtracks 
                 << " size = " << (truthtracks ? truthtracks->size() : 0));
   m_isSingleParticle = isSingleParticle;
   m_truthtracks = truthtracks;
  
   if (m_truthtracks)
   {
     if (m_truthtracks->size() > 0)
     {
       m_truthpars = (*m_truthtracks)[0].getPars();
       m_truthpars[FPGATrackSimTrackPars::IHIP] = m_truthpars[FPGATrackSimTrackPars::IHIP] * 1000;
       m_truthbin = m_binning->parsToBin(m_truthpars);
       m_truthparset = m_binning->trackParsToParSet(m_truthpars);
  
       // histogram parameters
       for (unsigned i = 0; i < FPGATrackSimGenScanBinningBase::NPars; i++)
       {        
         // fill
         m_truthpars_hists[i]->Fill(m_truthparset[i]);
       }
  
       // a closure test
       FPGATrackSimTrackPars recovered = m_binning->parSetToTrackPars(m_truthparset);
       ATH_MSG_DEBUG("parset:" << m_truthparset << " " << m_truthpars
                               << " ?= " << recovered << " closure:"
                               << " " << recovered[FPGATrackSimTrackPars::IHIP] - m_truthpars[FPGATrackSimTrackPars::IHIP]
                               << " " << recovered[FPGATrackSimTrackPars::IPHI] - m_truthpars[FPGATrackSimTrackPars::IPHI]
                               << " " << recovered[FPGATrackSimTrackPars::ID0] - m_truthpars[FPGATrackSimTrackPars::ID0]
                               << " " << recovered[FPGATrackSimTrackPars::IETA] - m_truthpars[FPGATrackSimTrackPars::IETA]
                               << " " << recovered[FPGATrackSimTrackPars::IZ0] - m_truthpars[FPGATrackSimTrackPars::IZ0]);
     }
  
     // print if there are multiple tracks for debugging single track MC
     if (m_truthtracks->size() > 1)
     {
       for (unsigned i = 0; i < m_truthtracks->size(); i++)
       {
         ATH_MSG_INFO("Multiple truth" << i << " of "
                                       << m_truthtracks->size() << " " << (*m_truthtracks)[i].getPars());
       }
     }
  
     // find truth bin for later plotting selections
     ATH_MSG_DEBUG("truthbin " << m_truthtracks << " " << m_truthtracks->size() << " " << m_truthpars << " " << m_truthbin);
     if (!m_binning->inRange(m_truthparset))
     {
       ATH_MSG_INFO("Truth out of range");
     }
     else if (!validBin[m_truthbin])
     {
       ATH_MSG_INFO("Truth Bin not valid!" << m_truthbin << " : " << m_truthpars);
       std::vector<FPGATrackSimGenScanBinningBase::ParSet> parsets = m_binning->makeVariationSet(std::vector<unsigned>({0, 1, 2, 3, 4}), m_truthbin);
       for (FPGATrackSimGenScanBinningBase::ParSet& parset : parsets)
       {
         ATH_MSG_INFO("Truth Box " << m_binning->parSetToTrackPars(parset));
       }
     }
  
     m_truthIsValid = true;
   }
 }

◆ regGraph()

StatusCode FPGATrackSimGenScanMonitoring::regGraph ( TGraph * g ) const

inlineprivate

Definition at line 311 of file FPGATrackSimGenScanMonitoring.h.

311 { return m_tHistSvc->regGraph(m_dir + g->GetName(), g);}

◆ registerGraphs()

StatusCode FPGATrackSimGenScanMonitoring::registerGraphs ( )

Definition at line 210 of file FPGATrackSimGenScanMonitoring.cxx.

 {
   // Make a vector of pointers to all the eventDispSet instances...
   std::vector<FPGATrackSimGenScanMonitoring::eventDispSet *> allsets(
       {&m_allHitsGraph, &m_roadGraph, &m_lostPairFilterGraph,
        &m_passPairFilterGraph, &m_lostPairSetFilterGraph,
        &m_passPairSetFilterGraph});
  
   // Then loop to register them all
   for (auto& set : allsets) {
     ATH_CHECK(set->registerGraphs(this));
   }
  
   return StatusCode::SUCCESS;
 }

◆ registerHistograms()

StatusCode FPGATrackSimGenScanMonitoring::registerHistograms	(	unsigned	nLayers,
		const FPGATrackSimGenScanBinningBase *	binning,
		double	rin,
		double	rout
	)

Definition at line 35 of file FPGATrackSimGenScanMonitoring.cxx.

 {
   m_nLayers = nLayers;
   m_binning = binning;
   m_rin=rin;
   m_rout = rout;
  
   // This is because if you change the binning class you can change what axis
   // ranges you need for the plotting
   double phiScale = m_binning->phiHistScale();
   double etaScale = m_binning->etaHistScale();
   double drScale = (rout-rin) / nLayers;
   ATH_MSG_INFO("Hist scales phi: " << phiScale << "  eta: " << etaScale << "  dr:" << drScale);
   
   allocateDataFlowCounters();
  
   // Truth Parameter distributions, bounds should cover 3x nominal range
   for (unsigned i = 0; i < FPGATrackSimGenScanBinningBase::NPars; i++) {
     ATH_CHECK(makeAndRegHist(
         m_truthpars_hists[i], ("truth" + m_binning->parNames(i)).c_str(),
         (";" + m_binning->parNames(i) + ";").c_str(), 200,
         2 * m_binning->m_parMin[i] - m_binning->m_parMax[i],
         2 * m_binning->m_parMax[i] - m_binning->m_parMin[i]));
   }
  
   // All Hit level histograms
   ATH_CHECK(makeAndRegHist(m_hitLyrsAllBins , "HitLyrsAllBins" , ";Hit Layers", 10, 0, 10));
   ATH_CHECK(makeAndRegHistVector(m_rZ_allhits, m_nLayers+1, NULL , 
             "RZ_allhits", "; Z [mm] ; R [mm] ", 500, -2000, 2000, 500, 0, 500));
   
   ATH_CHECK(makeAndRegHistVector(m_phiResidual, m_nLayers+1, NULL , 
             "phiResidual", "phi residual [mm]", 1000, -10, 10));
   ATH_CHECK(makeAndRegHistVector(m_etaResidual,m_nLayers+1, NULL ,  
             "etaResidual", "eta residual [mm]", 1000, -10, 10));
  
   ATH_CHECK(makeAndRegHistVector(m_phiTrueBinShift, m_nLayers+1, NULL , 
             "phiTrueBinShift", "phi TrueBinShift [mm]", 1000, -10, 10));
   ATH_CHECK(makeAndRegHistVector(m_etaTrueBinShift,m_nLayers+1, NULL ,  
             "etaTrueBinShift", "eta TrueBinShift [mm]", 1000, -10, 10));
  
   // Road statistics
   ATH_CHECK(makeAndRegHist(m_outputHitsPerBin, "OutputHitsPerBin",  ";Output Hits Per Bin", 100, 0, 200));
   ATH_CHECK(makeAndRegHist(m_outputHitsPerSlice, "OutputHitsPerSlice",  ";Output Hits Per Slice", 1000, 0, 2000));
   ATH_CHECK(makeAndRegHist(m_outputHitsPerRow, "OutputHitsPerRow",  ";Output Hits Per Row", 1000, 0, 2000));
   ATH_CHECK(makeAndRegHist(m_outputRoadsPerRow, "OutputRoadsPerRow",  ";Output Roads Per Row", 100, 0, 100));
   ATH_CHECK(makeAndRegHist(m_roadFilterFlow , "roadFilterFlow" , "road filter flow", 10, 0, 10));
   ATH_CHECK(makeAndRegHist(m_phiShift_road, "phiShift_road", ";Phi Shift", 2000, -phiScale, phiScale));
   ATH_CHECK(makeAndRegHist(m_etaShift_road, "etaShift_road", ";Eta Shift", 2000, -etaScale, etaScale));
   ATH_CHECK(makeAndRegHist(m_phiShift2D_road, "phiShift2D_road", ";Phi Shift; R", 
                           400, -phiScale, phiScale, 100, 0, 400));
   ATH_CHECK(makeAndRegHist(m_etaShift2D_road, "etaShift2D_road", ";Phi Shift; R", 
                           400, -etaScale, etaScale, 100, 0, 400));
  
   ATH_CHECK(makeAndRegHist(m_hitsPerLayer_road , "HitsPerLayer_road" , "; Layer; Hits", m_nLayers, 0, m_nLayers, 20, 0, 20));
  
  
   // Data flow hists
   ATH_CHECK(makeAndRegHist(m_hitsLoadedPerLayer, "HitsLoadedPerLayer", "; Layer; Hits", m_nLayers, 0, m_nLayers));
   ATH_CHECK(makeAndRegHist(m_inputHits, "InputHits",  ";Input Hits", 200, 0, 100000));
   ATH_CHECK(makeAndRegHist(m_inputHitsPerSlice, "InputHitsPerSlice",  ";Input Hits Per Slice", 1000, 0, 10000));
   ATH_CHECK(makeAndRegHist(m_inputHitsPerRow, "InputHitsPerRow",  ";Input Hits Per Row", 1000, 0, 10000));
   ATH_CHECK(makeAndRegHist(m_hitsPerLayer, "HitsPerLayer", "Layer; Hits", m_nLayers, 0, m_nLayers));
   ATH_CHECK(makeAndRegHist(m_hitsPerLayer2D, "HitsPerLayer2D", "Layer; Hits",
                            m_nLayers, 0, m_nLayers, 20, 0,
                            m_isSingleParticle ? 20 : 10000));
   ATH_CHECK(makeAndRegHist(m_pairs, "pairs", ";pairs;", 100, 0, 500));
   ATH_CHECK(makeAndRegHist(m_pairinghits, "pairinghits", ";Pairing Hits;", 50, 0, 50));
   ATH_CHECK(makeAndRegHist(m_filteredpairs, "filteredpairs", "filteredpairs", 100, 0, 500));
   ATH_CHECK(makeAndRegHist(m_pairsets, "pairsets", ";pairsets;", 100, 0, 100));
  
  
   // Pair Filter Cuts
   ATH_CHECK(makeAndRegHist(m_phiOutExtrap, "PhiOutExtrap", ";Phi Out Extrap", 2000, -phiScale, phiScale));
   ATH_CHECK(makeAndRegHist(m_phiInExtrap, "PhiInExtrap", ";Phi In Extrap", 2000, -phiScale, phiScale));
   ATH_CHECK(makeAndRegHist(m_phiOutExtrapCurveLimit, "PhiOutExtrapCurveLimit", 
     ";Phi Out Extrap w/ Curve Limit", 2000, -phiScale, phiScale));
   ATH_CHECK(makeAndRegHist(m_phiInExtrapCurveLimit, "PhiInExtrapCurveLimit", 
     ";Phi In Extrap w/ Curve Limit", 2000, -phiScale, phiScale));
   ATH_CHECK(makeAndRegHist(m_etaOutExtrap, "EtaOutExtrap", ";Eta Out Extrap", 2000, -etaScale, etaScale));
   ATH_CHECK(makeAndRegHist(m_etaInExtrap, "EtaInExtrap", ";Eta In Extrap", 2000, -etaScale, etaScale));
   ATH_CHECK(makeAndRegHist(m_deltaPhi, "DeltaPhi", ";Delta Phi [rad]", 2000, -1.0*phiScale, phiScale));
   ATH_CHECK(makeAndRegHist(m_deltaEta, "DeltaEta", ";Delta Eta [rad]", 2000, -1.0*etaScale, etaScale));
   ATH_CHECK(makeAndRegHist(m_deltaPhiDR, "DeltaPhiDR", ";Delta Phi / Delta R", 2000, -0.1 * phiScale, 0.1 * phiScale));
   ATH_CHECK(makeAndRegHist(m_deltaEtaDR, "DeltaEtaDR", ";Delta Eta / Delta R", 2000, -0.1 * phiScale, 0.1 * phiScale));
   ATH_CHECK(makeAndRegHistVector(m_deltaPhiByLyr, m_nLayers, NULL, "DeltaPhiDR", ";Delta Phi / Delta R", 2000, -0.1 * phiScale, 0.1 * phiScale));
   ATH_CHECK(makeAndRegHistVector(m_deltaEtaByLyr, m_nLayers, NULL,  "DeltaEtaDR", ";Delta Eta / Delta R", 2000, -0.1 * phiScale, 0.1 * phiScale));
  
   // Pair Match Cuts
   ATH_CHECK(makeAndRegHistVector(
       m_pairSetMatchPhi, m_twoPairClasses.size(), &m_twoPairClasses,
       "PairSetMatchPhi", ";PairSet Match Phi [mm]", 500,
       -1*phiScale / drScale, phiScale / drScale));
   ATH_CHECK(makeAndRegHistVector(
       m_pairSetMatchEta, m_twoPairClasses.size(), &m_twoPairClasses,
       "PairSetMatchEta", ";PairSet Match Eta [mm]", 500,
       -1*etaScale / drScale, etaScale / drScale));
   ATH_CHECK(makeAndRegHistVector(
       m_deltaDeltaPhi, m_twoPairClasses.size(), &m_twoPairClasses,
       "DeltaDeltaPhi", ";DeltaDelta   Phi [mm]", 500, -1.0*phiScale / drScale,
       phiScale / drScale));
   ATH_CHECK(makeAndRegHistVector(
       m_deltaDeltaEta, m_twoPairClasses.size(), &m_twoPairClasses,
       "DeltaDeltaEta", ";DeltaDelta   Eta [mm]", 500, -1.0 * etaScale / drScale,
       1.0 * etaScale / drScale));
   ATH_CHECK(makeAndRegHistVector(m_phiCurvature, m_twoPairClasses.size(),
                                &m_twoPairClasses, "PhiCurvature",
                                ";Phi Curvature ", 500,
                                -0.1 * phiScale / drScale / drScale,
                                0.1 * phiScale / drScale / drScale));
   ATH_CHECK(makeAndRegHistVector(m_etaCurvature, m_twoPairClasses.size(),
                                &m_twoPairClasses, "EtaCurvature",
                                ";Eta Curvature ", 500,
                                -0.1 * etaScale / drScale / drScale,
                                0.1 * etaScale / drScale / drScale));
   ATH_CHECK(makeAndRegHistVector(m_deltaPhiCurvature, m_twoPairClasses.size(),
                                &m_twoPairClasses, "DeltaPhiCurvature",
                                ";Delta Phi Curvature ", 500,
                                -0.1 * phiScale / drScale / drScale,
                                0.1 * phiScale / drScale / drScale));
   ATH_CHECK(makeAndRegHistVector(m_deltaEtaCurvature, m_twoPairClasses.size(),
                                &m_twoPairClasses, "DeltaEtaCurvature",
                                ";Delta Eta Curvature ", 500,
                                -0.1 * etaScale / drScale / drScale,
                                0.1 * etaScale / drScale / drScale));
   ATH_CHECK(makeAndRegHistVector(m_phiOutExtrapCurved, m_twoPairClasses.size(),
                                &m_twoPairClasses, "PhiOutExtrapCurved",
                                ";Phi Out Extrap Curved", 2000, -phiScale,
                                phiScale));
   ATH_CHECK(makeAndRegHistVector(m_phiInExtrapCurved, m_twoPairClasses.size(),
                                &m_twoPairClasses, "PhiInExtrapCurved",
                                ";Phi In Extrap Curved ", 2000, -phiScale,
                                phiScale));
   ATH_CHECK(makeAndRegHist(m_pairMatchPhi2D, "PairSetMatchPhi2D",
                          ";PairSet Match Phi vs dRin [mm]", 100, 0, 100, 500,
                          -100.0 * phiScale, 100.0 * phiScale));
   ATH_CHECK(makeAndRegHist(m_pairMatchEta2D, "PairSetMatchEta2D",
                          ";PairSet Match Eta vs dRin [mm]", 100, 0, 100, 500,
                          -100.0 * etaScale, 100.0 * etaScale));
  
   ATH_CHECK(makeAndRegHist(m_unpairedHits, "UnpairedHits", "; Stage ; Unpaired Hits" , m_nLayers+1, 0, m_nLayers+1, 20, 0, 20));
   ATH_CHECK(makeAndRegHist(m_pairsetsIncr, "PairSetsIncr", "; Stage ; Pairsets" , m_nLayers+1, 0, m_nLayers+1, 20, 0, 20));
   ATH_CHECK(makeAndRegHist(m_pairsetsHits, "PairSetsHits", "; Stage ; Hits in Pairsets" , m_nLayers+1, 0, m_nLayers+1, 20, 0, 20));
   ATH_CHECK(makeAndRegHist(m_totalInputIncr, "TotalInputIncr", "; Stage ; Pairsets+Unpaired" , m_nLayers+1, 0, m_nLayers+1, 20, 0, 20));
   ATH_CHECK(makeAndRegHist(m_binStagesIncr, "BinStagesIncr", "; Stage ; Bins at this point" , m_nLayers+1, 0, m_nLayers+1, 20, 0, 20));
  
   return StatusCode::SUCCESS;
 }

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

◆ resetDataFlowCounters()

void FPGATrackSimGenScanMonitoring::resetDataFlowCounters ( )

Definition at line 196 of file FPGATrackSimGenScanMonitoring.cxx.

                                                           {
   for (auto& bin: m_hitsCntByLayer) { bin =0;}
   for (auto& bin: m_inputhitsperslice) { bin.data() =0;}
   for (auto& bin: m_inputhitsperrow) { bin.data() =0;}
   for (auto& bin: m_outputhitsperslice) { bin.data() =0;}
   for (auto& bin: m_outputhitsperrow) { bin.data() =0;}
   for (auto &bin : m_outputroadsperrow) {
     bin.data() = 0;
   }
 }

◆ setBinPlotsActive()

void FPGATrackSimGenScanMonitoring::setBinPlotsActive ( const FPGATrackSimGenScanBinningBase::IdxSet & idx )

inlineprivate

Definition at line 131 of file FPGATrackSimGenScanMonitoring.h.

131 {

132 m_binPlotsActive = ((m_truthbin == idx) || (!m_isSingleParticle));}

◆ sliceCheck()

void FPGATrackSimGenScanMonitoring::sliceCheck ( const std::vector< unsigned > & sliceidx )

Definition at line 275 of file FPGATrackSimGenScanMonitoring.cxx.

                                                                                    {
   if (m_truthIsValid &&
       (m_binning->subVec(m_binning->slicePars(), m_truthbin) == sliceidx)) {
     ATH_MSG_DEBUG("truth bin missed slice");
   }
 }

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

eventDispSet FPGATrackSimGenScanMonitoring::m_allHitsGraph {std::string("allHits"), 10}

private

Definition at line 269 of file FPGATrackSimGenScanMonitoring.h.

◆ m_binning

const FPGATrackSimGenScanBinningBase* FPGATrackSimGenScanMonitoring::m_binning {nullptr}

private

Definition at line 115 of file FPGATrackSimGenScanMonitoring.h.

◆ m_binPlotsActive

bool FPGATrackSimGenScanMonitoring::m_binPlotsActive = false

private

Definition at line 134 of file FPGATrackSimGenScanMonitoring.h.

◆ m_binStagesIncr

TH2D* FPGATrackSimGenScanMonitoring::m_binStagesIncr = 0

private

Definition at line 185 of file FPGATrackSimGenScanMonitoring.h.

◆ m_deltaDeltaEta

std::vector<TH1D *> FPGATrackSimGenScanMonitoring::m_deltaDeltaEta

Definition at line 220 of file FPGATrackSimGenScanMonitoring.h.

◆ m_deltaDeltaPhi

std::vector<TH1D *> FPGATrackSimGenScanMonitoring::m_deltaDeltaPhi

Definition at line 219 of file FPGATrackSimGenScanMonitoring.h.

◆ m_deltaEta

TH1D* FPGATrackSimGenScanMonitoring::m_deltaEta = 0

private

Definition at line 193 of file FPGATrackSimGenScanMonitoring.h.

◆ m_deltaEtaByLyr

std::vector<TH1D *> FPGATrackSimGenScanMonitoring::m_deltaEtaByLyr

private

Definition at line 203 of file FPGATrackSimGenScanMonitoring.h.

◆ m_deltaEtaCurvature

std::vector<TH1D *> FPGATrackSimGenScanMonitoring::m_deltaEtaCurvature

Definition at line 226 of file FPGATrackSimGenScanMonitoring.h.

◆ m_deltaEtaDR

TH1D* FPGATrackSimGenScanMonitoring::m_deltaEtaDR = 0

private

Definition at line 195 of file FPGATrackSimGenScanMonitoring.h.

◆ m_deltaPhi

TH1D* FPGATrackSimGenScanMonitoring::m_deltaPhi = 0

private

Definition at line 192 of file FPGATrackSimGenScanMonitoring.h.

◆ m_deltaPhiByLyr

std::vector<TH1D *> FPGATrackSimGenScanMonitoring::m_deltaPhiByLyr

private

Definition at line 202 of file FPGATrackSimGenScanMonitoring.h.

◆ m_deltaPhiCurvature

std::vector<TH1D *> FPGATrackSimGenScanMonitoring::m_deltaPhiCurvature

Definition at line 225 of file FPGATrackSimGenScanMonitoring.h.

◆ m_deltaPhiDR

TH1D* FPGATrackSimGenScanMonitoring::m_deltaPhiDR = 0

private

Definition at line 194 of file FPGATrackSimGenScanMonitoring.h.

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_dir

Gaudi::Property<std::string> FPGATrackSimGenScanMonitoring::m_dir {this, "dir", {"/GENSCAN/"}, "String name of output directory"}

private

Definition at line 110 of file FPGATrackSimGenScanMonitoring.h.

◆ m_etaCurvature

std::vector<TH1D *> FPGATrackSimGenScanMonitoring::m_etaCurvature

Definition at line 224 of file FPGATrackSimGenScanMonitoring.h.

◆ m_etaCurvatureMax

std::vector<TH1D *> FPGATrackSimGenScanMonitoring::m_etaCurvatureMax

Definition at line 228 of file FPGATrackSimGenScanMonitoring.h.

◆ m_etaInExtrap

TH1D* FPGATrackSimGenScanMonitoring::m_etaInExtrap = 0

private

Definition at line 201 of file FPGATrackSimGenScanMonitoring.h.

◆ m_etaOutExtrap

TH1D* FPGATrackSimGenScanMonitoring::m_etaOutExtrap = 0

private

Definition at line 200 of file FPGATrackSimGenScanMonitoring.h.

◆ m_etaResidual

std::vector<TH1D *> FPGATrackSimGenScanMonitoring::m_etaResidual

private

Definition at line 152 of file FPGATrackSimGenScanMonitoring.h.

◆ m_etaShift2D_road

TH2D* FPGATrackSimGenScanMonitoring::m_etaShift2D_road = 0

private

Definition at line 174 of file FPGATrackSimGenScanMonitoring.h.

◆ m_etaShift_road

TH1D* FPGATrackSimGenScanMonitoring::m_etaShift_road = 0

private

Definition at line 172 of file FPGATrackSimGenScanMonitoring.h.

◆ m_etaTrueBinShift

std::vector<TH1D *> FPGATrackSimGenScanMonitoring::m_etaTrueBinShift

private

Definition at line 154 of file FPGATrackSimGenScanMonitoring.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_filteredpairs

TH1D* FPGATrackSimGenScanMonitoring::m_filteredpairs = 0

private

Definition at line 178 of file FPGATrackSimGenScanMonitoring.h.

◆ m_hitLyrsAllBins

TH1D* FPGATrackSimGenScanMonitoring::m_hitLyrsAllBins = 0

private

Definition at line 169 of file FPGATrackSimGenScanMonitoring.h.

◆ m_hitsCntByLayer

std::vector<unsigned> FPGATrackSimGenScanMonitoring::m_hitsCntByLayer

private

Definition at line 138 of file FPGATrackSimGenScanMonitoring.h.

◆ m_hitsLoadedPerLayer

TH1D* FPGATrackSimGenScanMonitoring::m_hitsLoadedPerLayer = 0

private

Definition at line 167 of file FPGATrackSimGenScanMonitoring.h.

◆ m_hitsPerLayer

TH1D* FPGATrackSimGenScanMonitoring::m_hitsPerLayer = 0

private

Definition at line 166 of file FPGATrackSimGenScanMonitoring.h.

◆ m_hitsPerLayer2D

TH2D* FPGATrackSimGenScanMonitoring::m_hitsPerLayer2D = 0

private

Definition at line 165 of file FPGATrackSimGenScanMonitoring.h.

◆ m_hitsPerLayer_road

TH2D* FPGATrackSimGenScanMonitoring::m_hitsPerLayer_road = 0

private

Definition at line 175 of file FPGATrackSimGenScanMonitoring.h.

◆ m_inputHits

TH1D* FPGATrackSimGenScanMonitoring::m_inputHits = 0

private

Definition at line 156 of file FPGATrackSimGenScanMonitoring.h.

◆ m_inputhitsperrow

FPGATrackSimGenScanArray<int> FPGATrackSimGenScanMonitoring::m_inputhitsperrow

private

Definition at line 141 of file FPGATrackSimGenScanMonitoring.h.

◆ m_inputHitsPerRow

TH1D* FPGATrackSimGenScanMonitoring::m_inputHitsPerRow = 0

private

Definition at line 160 of file FPGATrackSimGenScanMonitoring.h.

◆ m_inputhitsperslice

FPGATrackSimGenScanArray<int> FPGATrackSimGenScanMonitoring::m_inputhitsperslice

private

Definition at line 140 of file FPGATrackSimGenScanMonitoring.h.

◆ m_inputHitsPerSlice

TH1D* FPGATrackSimGenScanMonitoring::m_inputHitsPerSlice = 0

private

Definition at line 157 of file FPGATrackSimGenScanMonitoring.h.

◆ m_isSingleParticle

bool FPGATrackSimGenScanMonitoring::m_isSingleParticle = false

private

Definition at line 122 of file FPGATrackSimGenScanMonitoring.h.

◆ m_lostPairFilterGraph

eventDispSet FPGATrackSimGenScanMonitoring::m_lostPairFilterGraph {std::string("lostpairfilter"), 10}

private

Definition at line 271 of file FPGATrackSimGenScanMonitoring.h.

◆ m_lostPairSetFilterGraph

eventDispSet FPGATrackSimGenScanMonitoring::m_lostPairSetFilterGraph {std::string("lostpairsetfilter"), 10}

private

Definition at line 273 of file FPGATrackSimGenScanMonitoring.h.

◆ m_nLayers

unsigned FPGATrackSimGenScanMonitoring::m_nLayers = 0

private

Definition at line 114 of file FPGATrackSimGenScanMonitoring.h.

◆ m_nminus1_idx

unsigned FPGATrackSimGenScanMonitoring::m_nminus1_idx = 6

private

Definition at line 213 of file FPGATrackSimGenScanMonitoring.h.

◆ m_outputHitsPerBin

TH1D* FPGATrackSimGenScanMonitoring::m_outputHitsPerBin = 0

private

Definition at line 163 of file FPGATrackSimGenScanMonitoring.h.

◆ m_outputhitsperrow

FPGATrackSimGenScanArray<int> FPGATrackSimGenScanMonitoring::m_outputhitsperrow

private

Definition at line 144 of file FPGATrackSimGenScanMonitoring.h.

◆ m_outputHitsPerRow

TH1D* FPGATrackSimGenScanMonitoring::m_outputHitsPerRow = 0

private

Definition at line 161 of file FPGATrackSimGenScanMonitoring.h.

◆ m_outputhitsperslice

FPGATrackSimGenScanArray<int> FPGATrackSimGenScanMonitoring::m_outputhitsperslice

private

Definition at line 143 of file FPGATrackSimGenScanMonitoring.h.

◆ m_outputHitsPerSlice

TH1D* FPGATrackSimGenScanMonitoring::m_outputHitsPerSlice = 0

private

Definition at line 158 of file FPGATrackSimGenScanMonitoring.h.

◆ m_outputroadsperrow

FPGATrackSimGenScanArray<int> FPGATrackSimGenScanMonitoring::m_outputroadsperrow

private

Definition at line 145 of file FPGATrackSimGenScanMonitoring.h.

◆ m_outputRoadsPerRow

TH1D* FPGATrackSimGenScanMonitoring::m_outputRoadsPerRow = 0

private

Definition at line 162 of file FPGATrackSimGenScanMonitoring.h.

◆ m_pairinghits

TH1D* FPGATrackSimGenScanMonitoring::m_pairinghits = 0

private

Definition at line 188 of file FPGATrackSimGenScanMonitoring.h.

◆ m_pairMatchEta2D

TH2D* FPGATrackSimGenScanMonitoring::m_pairMatchEta2D = 0

private

Definition at line 234 of file FPGATrackSimGenScanMonitoring.h.

◆ m_pairMatchPhi2D

TH2D* FPGATrackSimGenScanMonitoring::m_pairMatchPhi2D = 0

private

Definition at line 233 of file FPGATrackSimGenScanMonitoring.h.

◆ m_pairs

TH1D* FPGATrackSimGenScanMonitoring::m_pairs = 0

private

Definition at line 177 of file FPGATrackSimGenScanMonitoring.h.

◆ m_pairSetMatchEta

std::vector<TH1D *> FPGATrackSimGenScanMonitoring::m_pairSetMatchEta

Definition at line 222 of file FPGATrackSimGenScanMonitoring.h.

◆ m_pairSetMatchPhi

std::vector<TH1D *> FPGATrackSimGenScanMonitoring::m_pairSetMatchPhi

Definition at line 221 of file FPGATrackSimGenScanMonitoring.h.

◆ m_pairsets

TH1D* FPGATrackSimGenScanMonitoring::m_pairsets = 0

private

Definition at line 179 of file FPGATrackSimGenScanMonitoring.h.

◆ m_pairsetsHits

TH2D* FPGATrackSimGenScanMonitoring::m_pairsetsHits = 0

private

Definition at line 184 of file FPGATrackSimGenScanMonitoring.h.

◆ m_pairsetsIncr

TH2D* FPGATrackSimGenScanMonitoring::m_pairsetsIncr = 0

private

Definition at line 183 of file FPGATrackSimGenScanMonitoring.h.

◆ m_passPairFilterGraph

eventDispSet FPGATrackSimGenScanMonitoring::m_passPairFilterGraph {std::string("passpairfilter"), 10}

private

Definition at line 272 of file FPGATrackSimGenScanMonitoring.h.

◆ m_passPairSetFilterGraph

eventDispSet FPGATrackSimGenScanMonitoring::m_passPairSetFilterGraph {std::string("passpairsetfilter"), 10}

private

Definition at line 274 of file FPGATrackSimGenScanMonitoring.h.

◆ m_phiCurvature

std::vector<TH1D *> FPGATrackSimGenScanMonitoring::m_phiCurvature

Definition at line 223 of file FPGATrackSimGenScanMonitoring.h.

◆ m_phiCurvatureMax

std::vector<TH1D *> FPGATrackSimGenScanMonitoring::m_phiCurvatureMax

Definition at line 227 of file FPGATrackSimGenScanMonitoring.h.

◆ m_phiInExtrap

TH1D* FPGATrackSimGenScanMonitoring::m_phiInExtrap = 0

private

Definition at line 197 of file FPGATrackSimGenScanMonitoring.h.

◆ m_phiInExtrapCurved

std::vector<TH1D *> FPGATrackSimGenScanMonitoring::m_phiInExtrapCurved

Definition at line 229 of file FPGATrackSimGenScanMonitoring.h.

◆ m_phiInExtrapCurveLimit

TH1D* FPGATrackSimGenScanMonitoring::m_phiInExtrapCurveLimit =0

private

Definition at line 199 of file FPGATrackSimGenScanMonitoring.h.

◆ m_phiOutExtrap

TH1D* FPGATrackSimGenScanMonitoring::m_phiOutExtrap = 0

private

Definition at line 196 of file FPGATrackSimGenScanMonitoring.h.

◆ m_phiOutExtrapCurved

std::vector<TH1D *> FPGATrackSimGenScanMonitoring::m_phiOutExtrapCurved

Definition at line 230 of file FPGATrackSimGenScanMonitoring.h.

◆ m_phiOutExtrapCurveLimit

TH1D* FPGATrackSimGenScanMonitoring::m_phiOutExtrapCurveLimit =0

private

Definition at line 198 of file FPGATrackSimGenScanMonitoring.h.

◆ m_phiResidual

std::vector<TH1D *> FPGATrackSimGenScanMonitoring::m_phiResidual

private

Definition at line 151 of file FPGATrackSimGenScanMonitoring.h.

◆ m_phiShift2D_road

TH2D* FPGATrackSimGenScanMonitoring::m_phiShift2D_road = 0

private

Definition at line 173 of file FPGATrackSimGenScanMonitoring.h.

◆ m_phiShift_road

TH1D* FPGATrackSimGenScanMonitoring::m_phiShift_road = 0

private

Definition at line 171 of file FPGATrackSimGenScanMonitoring.h.

◆ m_phiTrueBinShift

std::vector<TH1D *> FPGATrackSimGenScanMonitoring::m_phiTrueBinShift

private

Definition at line 153 of file FPGATrackSimGenScanMonitoring.h.

◆ m_rin

double FPGATrackSimGenScanMonitoring::m_rin =0.0

private

Definition at line 116 of file FPGATrackSimGenScanMonitoring.h.

◆ m_roadFilterFlow

TH1D* FPGATrackSimGenScanMonitoring::m_roadFilterFlow = 0

private

Definition at line 190 of file FPGATrackSimGenScanMonitoring.h.

◆ m_roadGraph

eventDispSet FPGATrackSimGenScanMonitoring::m_roadGraph {std::string("road"), 10}

private

Definition at line 270 of file FPGATrackSimGenScanMonitoring.h.

◆ m_rout

double FPGATrackSimGenScanMonitoring::m_rout =0.0

private

Definition at line 117 of file FPGATrackSimGenScanMonitoring.h.

◆ m_rZ_allhits

std::vector<TH2D *> FPGATrackSimGenScanMonitoring::m_rZ_allhits

private

Definition at line 149 of file FPGATrackSimGenScanMonitoring.h.

◆ m_tHistSvc

ServiceHandle<ITHistSvc> FPGATrackSimGenScanMonitoring::m_tHistSvc {this, "THistSvc", "THistSvc"}

private

Definition at line 106 of file FPGATrackSimGenScanMonitoring.h.

◆ m_totalInputIncr

TH2D* FPGATrackSimGenScanMonitoring::m_totalInputIncr = 0

private

Definition at line 186 of file FPGATrackSimGenScanMonitoring.h.

◆ m_truthbin

FPGATrackSimGenScanBinningBase::IdxSet FPGATrackSimGenScanMonitoring::m_truthbin

private

Definition at line 125 of file FPGATrackSimGenScanMonitoring.h.

◆ m_truthIsValid

bool FPGATrackSimGenScanMonitoring::m_truthIsValid = false

private

Definition at line 123 of file FPGATrackSimGenScanMonitoring.h.

◆ m_truthpars

FPGATrackSimTrackPars FPGATrackSimGenScanMonitoring::m_truthpars

private

Definition at line 124 of file FPGATrackSimGenScanMonitoring.h.

◆ m_truthpars_hists

TH1D* FPGATrackSimGenScanMonitoring::m_truthpars_hists[5] = {0, 0, 0, 0, 0}

private

Definition at line 150 of file FPGATrackSimGenScanMonitoring.h.

◆ m_truthparset

FPGATrackSimGenScanBinningBase::ParSet FPGATrackSimGenScanMonitoring::m_truthparset

private

Definition at line 126 of file FPGATrackSimGenScanMonitoring.h.

◆ m_truthtracks

std::vector<FPGATrackSimTruthTrack> const* FPGATrackSimGenScanMonitoring::m_truthtracks {nullptr}

private

Definition at line 121 of file FPGATrackSimGenScanMonitoring.h.

◆ m_twoPairClasses

const std::vector<std::string> FPGATrackSimGenScanMonitoring::m_twoPairClasses

inlinestaticprivate

Initial value:

= {

"", "_same", "_sequential", "_sameend", "_skip1", "_skip2", "_nm1"}

Definition at line 211 of file FPGATrackSimGenScanMonitoring.h.

◆ m_unpairedHits

TH2D* FPGATrackSimGenScanMonitoring::m_unpairedHits = 0

private

Definition at line 182 of file FPGATrackSimGenScanMonitoring.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:

Classes

Public Member Functions

Public Attributes

Protected Member Functions

Private Types

Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Member Typedef Documentation

◆ StoreGateSvc_t

Constructor & Destructor Documentation

◆ FPGATrackSimGenScanMonitoring()

Member Function Documentation

◆ allocateDataFlowCounters()

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

◆ dir()

◆ evtStore() [1/2]

◆ evtStore() [2/2]

◆ extraDeps_update_handler()

◆ fillBinLevelOutput()

◆ fillBuildGroupsWithPairs()

◆ fillHitLevelInput()

◆ fillInputSummary()

◆ fillOutputSummary()

◆ fillPairFilterCuts()

◆ fillPairingHits()

◆ fillPairSetFilterCut()

◆ incrementInputPerScan()

◆ incrementInputPerSlice()

◆ initialize()

◆ inputHandles()

◆ makeAndRegHist()

◆ makeAndRegHistVector()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msgLvl()

◆ outputHandles()

◆ pairFilterCheck()

◆ pairpairCategory()

◆ pairSetFilterCheck()

◆ parseTruthInfo()

◆ regGraph()

◆ registerGraphs()

◆ registerHistograms()

◆ renounce()

◆ renounceArray()

◆ resetDataFlowCounters()

◆ setBinPlotsActive()

◆ sliceCheck()

◆ sysInitialize()

◆ sysStart()

◆ updateVHKA()

Member Data Documentation

◆ m_allHitsGraph

◆ m_binning

◆ m_binPlotsActive

◆ m_binStagesIncr

◆ m_deltaDeltaEta

◆ m_deltaDeltaPhi

◆ m_deltaEta

◆ m_deltaEtaByLyr

◆ m_deltaEtaCurvature

◆ m_deltaEtaDR

◆ m_deltaPhi

◆ m_deltaPhiByLyr

◆ m_deltaPhiCurvature

◆ m_deltaPhiDR

◆ m_detStore

◆ m_dir