#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)

void	fillHitsByLayer (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)

bool	isTruthBin (FPGATrackSimGenScanBinningBase::IdxSet idx) const

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

StatusCode	bookTree ()

void	ClearTreeVectors ()

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}

TTree *	m_bin_module_tree = nullptr

std::vector< unsigned >	m_tree_bin

std::vector< float >	m_tree_r

std::vector< float >	m_tree_z

std::vector< int >	m_tree_id

std::vector< int >	m_tree_hash

std::vector< int >	m_tree_layer

std::vector< int >	m_tree_side

std::vector< int >	m_tree_etamod

std::vector< int >	m_tree_phimod

std::vector< int >	m_tree_dettype

std::vector< int >	m_tree_detzone

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 35 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 18 of file FPGATrackSimGenScanMonitoring.cxx.

                                                                                                                                    :
   AthAlgTool(algname, name, ifc)
 {
 }

Member Function Documentation

◆ allocateDataFlowCounters()

void FPGATrackSimGenScanMonitoring::allocateDataFlowCounters ( )

Definition at line 223 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);
 }

◆ bookTree()

StatusCode FPGATrackSimGenScanMonitoring::bookTree ( )

private

Definition at line 190 of file FPGATrackSimGenScanMonitoring.cxx.

                                                    {
   ATH_MSG_DEBUG("Booking Layers Study  Tree");
   m_bin_module_tree = new TTree("LayerStudy","LayerStudy");
   m_bin_module_tree->Branch("bin", &m_tree_bin);
   m_bin_module_tree->Branch("r", &m_tree_r);
   m_bin_module_tree->Branch("z", &m_tree_z);
   m_bin_module_tree->Branch("id", &m_tree_id);
   m_bin_module_tree->Branch("hash", &m_tree_hash);
   m_bin_module_tree->Branch("layer", &m_tree_layer);
   m_bin_module_tree->Branch("side", &m_tree_side);
   m_bin_module_tree->Branch("etamod",  &m_tree_etamod);
   m_bin_module_tree->Branch("phimod",  &m_tree_phimod);
   m_bin_module_tree->Branch("dettype", &m_tree_dettype);
   m_bin_module_tree->Branch("detzone",  &m_tree_detzone);
  
   ATH_CHECK(m_tHistSvc->regTree(m_dir + m_bin_module_tree->GetName(), m_bin_module_tree));
   return StatusCode::SUCCESS;
 }

◆ ClearTreeVectors()

void FPGATrackSimGenScanMonitoring::ClearTreeVectors ( )

private

Definition at line 208 of file FPGATrackSimGenScanMonitoring.cxx.

 {
   m_tree_r.clear();
   m_tree_z.clear();
   m_tree_id.clear();
   m_tree_hash.clear();
   m_tree_layer.clear();
   m_tree_side.clear();
   m_tree_etamod.clear();
   m_tree_phimod.clear();
   m_tree_dettype.clear();
   m_tree_detzone.clear();
 }

◆ 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 57 of file FPGATrackSimGenScanMonitoring.h.

57 {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
	)

Definition at line 266 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());
     }
  
  
     // Module mapping and Layer definition studies
     // first sort hits by r+z radii
     std::vector<FPGATrackSimGenScanTool::StoredHit> sorted_hits = data.hits;
     std::sort(sorted_hits.begin(), sorted_hits.end(),
               [](const auto &hit1, const auto &hit2) {
                 return hit1.rzrad() < hit2.rzrad();
               });
  
     // Fill tree
     m_tree_bin = std::vector<unsigned>(idx);
     ClearTreeVectors();
     for (auto &hit : sorted_hits) {
       m_tree_r.push_back(hit.hitptr->getR());
       m_tree_z.push_back(hit.hitptr->getZ());
       m_tree_id.push_back(hit.hitptr->getIdentifier());
       m_tree_hash.push_back(hit.hitptr->getIdentifierHash());
       m_tree_layer.push_back(hit.hitptr->getLayerDisk());
       m_tree_side.push_back(hit.hitptr->getSide());
       m_tree_etamod.push_back(hit.hitptr->getEtaModule());
       m_tree_phimod.push_back(hit.hitptr->getPhiModule());
       m_tree_dettype.push_back((int)hit.hitptr->getDetType());
       m_tree_detzone.push_back((int)hit.hitptr->getDetectorZone());
     }
     ATH_MSG_DEBUG("For tree, bin=" << idx << " mods=" << m_tree_hash);
     m_bin_module_tree->Fill();
   }
 }

◆ fillBuildGroupsWithPairs()

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

Definition at line 627 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 324 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)); 
       }
   }
 }

◆ fillHitsByLayer()

void FPGATrackSimGenScanMonitoring::fillHitsByLayer ( const std::vector< std::vector< const FPGATrackSimGenScanTool::StoredHit * >> & hitsByLayer )

Definition at line 315 of file FPGATrackSimGenScanMonitoring.cxx.

 {
   for (unsigned lyr = 0; lyr < m_nLayers; lyr++)
   {
     m_hitsPerLayer_road->Fill(lyr, hitsByLayer[lyr].size());
   }
 }

◆ fillInputSummary()

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

Definition at line 391 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 418 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 524 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 506 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 595 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 376 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 91 of file FPGATrackSimGenScanMonitoring.h.

91 { m_inputhitsperslice[sliceidx]++; }

◆ initialize()

StatusCode FPGATrackSimGenScanMonitoring::initialize ( )

overridevirtual

Definition at line 23 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());
  
   ATH_CHECK(bookTree());
  
   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.

◆ isTruthBin()

bool FPGATrackSimGenScanMonitoring::isTruthBin ( FPGATrackSimGenScanBinningBase::IdxSet idx ) const

inline

Definition at line 105 of file FPGATrackSimGenScanMonitoring.h.

                                                                     {
       return idx==m_truthbin;
     }

◆ makeAndRegHist()

template<typename HistType , typename... HistDef>

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

inlineprivate

Definition at line 301 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 310 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 351 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 548 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 = std::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 610 of file FPGATrackSimGenScanMonitoring.cxx.

                         {
   m_pairsets->Fill(pairsets.size());
  
   for (const 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 440 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 333 of file FPGATrackSimGenScanMonitoring.h.

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

◆ registerGraphs()

StatusCode FPGATrackSimGenScanMonitoring::registerGraphs ( )

Definition at line 249 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 41 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(), 20000,
         m_binning->m_parMin[i], m_binning->m_parMax[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 235 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 137 of file FPGATrackSimGenScanMonitoring.h.

137 {

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

◆ sliceCheck()

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

Definition at line 344 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 275 of file FPGATrackSimGenScanMonitoring.h.

◆ m_bin_module_tree

TTree* FPGATrackSimGenScanMonitoring::m_bin_module_tree = nullptr

private

Definition at line 285 of file FPGATrackSimGenScanMonitoring.h.

◆ m_binning

const FPGATrackSimGenScanBinningBase* FPGATrackSimGenScanMonitoring::m_binning {nullptr}

private

Definition at line 121 of file FPGATrackSimGenScanMonitoring.h.

◆ m_binPlotsActive

bool FPGATrackSimGenScanMonitoring::m_binPlotsActive = false

private

Definition at line 140 of file FPGATrackSimGenScanMonitoring.h.

◆ m_binStagesIncr

TH2D* FPGATrackSimGenScanMonitoring::m_binStagesIncr = 0

private

Definition at line 191 of file FPGATrackSimGenScanMonitoring.h.

◆ m_deltaDeltaEta

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

Definition at line 226 of file FPGATrackSimGenScanMonitoring.h.

◆ m_deltaDeltaPhi

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

Definition at line 225 of file FPGATrackSimGenScanMonitoring.h.

◆ m_deltaEta

TH1D* FPGATrackSimGenScanMonitoring::m_deltaEta = 0

private

Definition at line 199 of file FPGATrackSimGenScanMonitoring.h.

◆ m_deltaEtaByLyr

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

private

Definition at line 209 of file FPGATrackSimGenScanMonitoring.h.

◆ m_deltaEtaCurvature

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

Definition at line 232 of file FPGATrackSimGenScanMonitoring.h.

◆ m_deltaEtaDR

TH1D* FPGATrackSimGenScanMonitoring::m_deltaEtaDR = 0

private

Definition at line 201 of file FPGATrackSimGenScanMonitoring.h.

◆ m_deltaPhi

TH1D* FPGATrackSimGenScanMonitoring::m_deltaPhi = 0

private

Definition at line 198 of file FPGATrackSimGenScanMonitoring.h.

◆ m_deltaPhiByLyr

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

private

Definition at line 208 of file FPGATrackSimGenScanMonitoring.h.

◆ m_deltaPhiCurvature

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

Definition at line 231 of file FPGATrackSimGenScanMonitoring.h.

◆ m_deltaPhiDR

TH1D* FPGATrackSimGenScanMonitoring::m_deltaPhiDR = 0

private

Definition at line 200 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 116 of file FPGATrackSimGenScanMonitoring.h.

◆ m_etaCurvature

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

Definition at line 230 of file FPGATrackSimGenScanMonitoring.h.

◆ m_etaCurvatureMax

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

Definition at line 234 of file FPGATrackSimGenScanMonitoring.h.

◆ m_etaInExtrap

TH1D* FPGATrackSimGenScanMonitoring::m_etaInExtrap = 0

private

Definition at line 207 of file FPGATrackSimGenScanMonitoring.h.

◆ m_etaOutExtrap

TH1D* FPGATrackSimGenScanMonitoring::m_etaOutExtrap = 0

private

Definition at line 206 of file FPGATrackSimGenScanMonitoring.h.

◆ m_etaResidual

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

private

Definition at line 158 of file FPGATrackSimGenScanMonitoring.h.

◆ m_etaShift2D_road

TH2D* FPGATrackSimGenScanMonitoring::m_etaShift2D_road = 0

private

Definition at line 180 of file FPGATrackSimGenScanMonitoring.h.

◆ m_etaShift_road

TH1D* FPGATrackSimGenScanMonitoring::m_etaShift_road = 0

private

Definition at line 178 of file FPGATrackSimGenScanMonitoring.h.

◆ m_etaTrueBinShift

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

private

Definition at line 160 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 184 of file FPGATrackSimGenScanMonitoring.h.

◆ m_hitLyrsAllBins

TH1D* FPGATrackSimGenScanMonitoring::m_hitLyrsAllBins = 0

private

Definition at line 175 of file FPGATrackSimGenScanMonitoring.h.

◆ m_hitsCntByLayer

std::vector<unsigned> FPGATrackSimGenScanMonitoring::m_hitsCntByLayer

private

Definition at line 144 of file FPGATrackSimGenScanMonitoring.h.

◆ m_hitsLoadedPerLayer

TH1D* FPGATrackSimGenScanMonitoring::m_hitsLoadedPerLayer = 0

private

Definition at line 173 of file FPGATrackSimGenScanMonitoring.h.

◆ m_hitsPerLayer

TH1D* FPGATrackSimGenScanMonitoring::m_hitsPerLayer = 0

private

Definition at line 172 of file FPGATrackSimGenScanMonitoring.h.

◆ m_hitsPerLayer2D

TH2D* FPGATrackSimGenScanMonitoring::m_hitsPerLayer2D = 0

private

Definition at line 171 of file FPGATrackSimGenScanMonitoring.h.

◆ m_hitsPerLayer_road

TH2D* FPGATrackSimGenScanMonitoring::m_hitsPerLayer_road = 0

private

Definition at line 181 of file FPGATrackSimGenScanMonitoring.h.

◆ m_inputHits

TH1D* FPGATrackSimGenScanMonitoring::m_inputHits = 0

private

Definition at line 162 of file FPGATrackSimGenScanMonitoring.h.

◆ m_inputhitsperrow

FPGATrackSimGenScanArray<int> FPGATrackSimGenScanMonitoring::m_inputhitsperrow

private

Definition at line 147 of file FPGATrackSimGenScanMonitoring.h.

◆ m_inputHitsPerRow

TH1D* FPGATrackSimGenScanMonitoring::m_inputHitsPerRow = 0

private

Definition at line 166 of file FPGATrackSimGenScanMonitoring.h.

◆ m_inputhitsperslice

FPGATrackSimGenScanArray<int> FPGATrackSimGenScanMonitoring::m_inputhitsperslice

private

Definition at line 146 of file FPGATrackSimGenScanMonitoring.h.

◆ m_inputHitsPerSlice

TH1D* FPGATrackSimGenScanMonitoring::m_inputHitsPerSlice = 0

private

Definition at line 163 of file FPGATrackSimGenScanMonitoring.h.

◆ m_isSingleParticle

bool FPGATrackSimGenScanMonitoring::m_isSingleParticle = false

private

Definition at line 128 of file FPGATrackSimGenScanMonitoring.h.

◆ m_lostPairFilterGraph

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

private

Definition at line 277 of file FPGATrackSimGenScanMonitoring.h.

◆ m_lostPairSetFilterGraph

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

private

Definition at line 279 of file FPGATrackSimGenScanMonitoring.h.

◆ m_nLayers

unsigned FPGATrackSimGenScanMonitoring::m_nLayers = 0

private

Definition at line 120 of file FPGATrackSimGenScanMonitoring.h.

◆ m_nminus1_idx

unsigned FPGATrackSimGenScanMonitoring::m_nminus1_idx = 6

private

Definition at line 219 of file FPGATrackSimGenScanMonitoring.h.

◆ m_outputHitsPerBin

TH1D* FPGATrackSimGenScanMonitoring::m_outputHitsPerBin = 0

private

Definition at line 169 of file FPGATrackSimGenScanMonitoring.h.

◆ m_outputhitsperrow

FPGATrackSimGenScanArray<int> FPGATrackSimGenScanMonitoring::m_outputhitsperrow

private

Definition at line 150 of file FPGATrackSimGenScanMonitoring.h.

◆ m_outputHitsPerRow

TH1D* FPGATrackSimGenScanMonitoring::m_outputHitsPerRow = 0

private

Definition at line 167 of file FPGATrackSimGenScanMonitoring.h.

◆ m_outputhitsperslice

FPGATrackSimGenScanArray<int> FPGATrackSimGenScanMonitoring::m_outputhitsperslice

private

Definition at line 149 of file FPGATrackSimGenScanMonitoring.h.

◆ m_outputHitsPerSlice

TH1D* FPGATrackSimGenScanMonitoring::m_outputHitsPerSlice = 0

private

Definition at line 164 of file FPGATrackSimGenScanMonitoring.h.

◆ m_outputroadsperrow

FPGATrackSimGenScanArray<int> FPGATrackSimGenScanMonitoring::m_outputroadsperrow

private

Definition at line 151 of file FPGATrackSimGenScanMonitoring.h.

◆ m_outputRoadsPerRow

TH1D* FPGATrackSimGenScanMonitoring::m_outputRoadsPerRow = 0

private

Definition at line 168 of file FPGATrackSimGenScanMonitoring.h.

◆ m_pairinghits

TH1D* FPGATrackSimGenScanMonitoring::m_pairinghits = 0

private

Definition at line 194 of file FPGATrackSimGenScanMonitoring.h.

◆ m_pairMatchEta2D

TH2D* FPGATrackSimGenScanMonitoring::m_pairMatchEta2D = 0

private

Definition at line 240 of file FPGATrackSimGenScanMonitoring.h.

◆ m_pairMatchPhi2D

TH2D* FPGATrackSimGenScanMonitoring::m_pairMatchPhi2D = 0

private

Definition at line 239 of file FPGATrackSimGenScanMonitoring.h.

◆ m_pairs

TH1D* FPGATrackSimGenScanMonitoring::m_pairs = 0

private

Definition at line 183 of file FPGATrackSimGenScanMonitoring.h.

◆ m_pairSetMatchEta

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

Definition at line 228 of file FPGATrackSimGenScanMonitoring.h.

◆ m_pairSetMatchPhi

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

Definition at line 227 of file FPGATrackSimGenScanMonitoring.h.

◆ m_pairsets

TH1D* FPGATrackSimGenScanMonitoring::m_pairsets = 0

private

Definition at line 185 of file FPGATrackSimGenScanMonitoring.h.

◆ m_pairsetsHits

TH2D* FPGATrackSimGenScanMonitoring::m_pairsetsHits = 0

private

Definition at line 190 of file FPGATrackSimGenScanMonitoring.h.

◆ m_pairsetsIncr

TH2D* FPGATrackSimGenScanMonitoring::m_pairsetsIncr = 0

private

Definition at line 189 of file FPGATrackSimGenScanMonitoring.h.

◆ m_passPairFilterGraph

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

private

Definition at line 278 of file FPGATrackSimGenScanMonitoring.h.

◆ m_passPairSetFilterGraph

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

private

Definition at line 280 of file FPGATrackSimGenScanMonitoring.h.

◆ m_phiCurvature

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

Definition at line 229 of file FPGATrackSimGenScanMonitoring.h.

◆ m_phiCurvatureMax

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

Definition at line 233 of file FPGATrackSimGenScanMonitoring.h.

◆ m_phiInExtrap

TH1D* FPGATrackSimGenScanMonitoring::m_phiInExtrap = 0

private

Definition at line 203 of file FPGATrackSimGenScanMonitoring.h.

◆ m_phiInExtrapCurved

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

Definition at line 235 of file FPGATrackSimGenScanMonitoring.h.

◆ m_phiInExtrapCurveLimit

TH1D* FPGATrackSimGenScanMonitoring::m_phiInExtrapCurveLimit =0

private

Definition at line 205 of file FPGATrackSimGenScanMonitoring.h.

◆ m_phiOutExtrap

TH1D* FPGATrackSimGenScanMonitoring::m_phiOutExtrap = 0

private

Definition at line 202 of file FPGATrackSimGenScanMonitoring.h.

◆ m_phiOutExtrapCurved

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

Definition at line 236 of file FPGATrackSimGenScanMonitoring.h.

◆ m_phiOutExtrapCurveLimit

TH1D* FPGATrackSimGenScanMonitoring::m_phiOutExtrapCurveLimit =0

private

Definition at line 204 of file FPGATrackSimGenScanMonitoring.h.

◆ m_phiResidual

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

private

Definition at line 157 of file FPGATrackSimGenScanMonitoring.h.

◆ m_phiShift2D_road

TH2D* FPGATrackSimGenScanMonitoring::m_phiShift2D_road = 0

private

Definition at line 179 of file FPGATrackSimGenScanMonitoring.h.

◆ m_phiShift_road

TH1D* FPGATrackSimGenScanMonitoring::m_phiShift_road = 0

private

Definition at line 177 of file FPGATrackSimGenScanMonitoring.h.

◆ m_phiTrueBinShift

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

private

Definition at line 159 of file FPGATrackSimGenScanMonitoring.h.

◆ m_rin

double FPGATrackSimGenScanMonitoring::m_rin =0.0

private

Definition at line 122 of file FPGATrackSimGenScanMonitoring.h.

◆ m_roadFilterFlow

TH1D* FPGATrackSimGenScanMonitoring::m_roadFilterFlow = 0

private

Definition at line 196 of file FPGATrackSimGenScanMonitoring.h.

◆ m_roadGraph

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

private

Definition at line 276 of file FPGATrackSimGenScanMonitoring.h.

◆ m_rout

double FPGATrackSimGenScanMonitoring::m_rout =0.0

private

Definition at line 123 of file FPGATrackSimGenScanMonitoring.h.

◆ m_rZ_allhits

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

private

Definition at line 155 of file FPGATrackSimGenScanMonitoring.h.

◆ m_tHistSvc

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

private

Definition at line 112 of file FPGATrackSimGenScanMonitoring.h.

◆ m_totalInputIncr

TH2D* FPGATrackSimGenScanMonitoring::m_totalInputIncr = 0

private

Definition at line 192 of file FPGATrackSimGenScanMonitoring.h.

◆ m_tree_bin

std::vector<unsigned> FPGATrackSimGenScanMonitoring::m_tree_bin

private

Definition at line 286 of file FPGATrackSimGenScanMonitoring.h.

◆ m_tree_dettype

std::vector<int> FPGATrackSimGenScanMonitoring::m_tree_dettype

private

Definition at line 295 of file FPGATrackSimGenScanMonitoring.h.

◆ m_tree_detzone

std::vector<int> FPGATrackSimGenScanMonitoring::m_tree_detzone

private

Definition at line 296 of file FPGATrackSimGenScanMonitoring.h.

◆ m_tree_etamod

std::vector<int> FPGATrackSimGenScanMonitoring::m_tree_etamod

private

Definition at line 293 of file FPGATrackSimGenScanMonitoring.h.

◆ m_tree_hash

std::vector<int> FPGATrackSimGenScanMonitoring::m_tree_hash

private

Definition at line 290 of file FPGATrackSimGenScanMonitoring.h.

◆ m_tree_id

std::vector<int> FPGATrackSimGenScanMonitoring::m_tree_id

private

Definition at line 289 of file FPGATrackSimGenScanMonitoring.h.

◆ m_tree_layer

std::vector<int> FPGATrackSimGenScanMonitoring::m_tree_layer

private

Definition at line 291 of file FPGATrackSimGenScanMonitoring.h.

◆ m_tree_phimod

std::vector<int> FPGATrackSimGenScanMonitoring::m_tree_phimod

private

Definition at line 294 of file FPGATrackSimGenScanMonitoring.h.

◆ m_tree_r

std::vector<float> FPGATrackSimGenScanMonitoring::m_tree_r

private

Definition at line 287 of file FPGATrackSimGenScanMonitoring.h.

◆ m_tree_side

std::vector<int> FPGATrackSimGenScanMonitoring::m_tree_side

private

Definition at line 292 of file FPGATrackSimGenScanMonitoring.h.

◆ m_tree_z

std::vector<float> FPGATrackSimGenScanMonitoring::m_tree_z

private

Definition at line 288 of file FPGATrackSimGenScanMonitoring.h.

◆ m_truthbin

FPGATrackSimGenScanBinningBase::IdxSet FPGATrackSimGenScanMonitoring::m_truthbin

private

Definition at line 131 of file FPGATrackSimGenScanMonitoring.h.

◆ m_truthIsValid

bool FPGATrackSimGenScanMonitoring::m_truthIsValid = false

private

Definition at line 129 of file FPGATrackSimGenScanMonitoring.h.

◆ m_truthpars

FPGATrackSimTrackPars FPGATrackSimGenScanMonitoring::m_truthpars

private

Definition at line 130 of file FPGATrackSimGenScanMonitoring.h.

◆ m_truthpars_hists

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

private

Definition at line 156 of file FPGATrackSimGenScanMonitoring.h.

◆ m_truthparset

FPGATrackSimGenScanBinningBase::ParSet FPGATrackSimGenScanMonitoring::m_truthparset

private

Definition at line 132 of file FPGATrackSimGenScanMonitoring.h.

◆ m_truthtracks

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

private

Definition at line 127 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 217 of file FPGATrackSimGenScanMonitoring.h.

◆ m_unpairedHits

TH2D* FPGATrackSimGenScanMonitoring::m_unpairedHits = 0

private

Definition at line 188 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()

◆ bookTree()

◆ ClearTreeVectors()

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

◆ fillHitsByLayer()

◆ fillInputSummary()

◆ fillOutputSummary()

◆ fillPairFilterCuts()

◆ fillPairingHits()

◆ fillPairSetFilterCut()

◆ incrementInputPerScan()

◆ incrementInputPerSlice()

◆ initialize()

◆ inputHandles()

◆ isTruthBin()

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

◆ m_binning

◆ m_binPlotsActive

◆ m_binStagesIncr

◆ m_deltaDeltaEta

◆ m_deltaDeltaPhi

◆ m_deltaEta

◆ m_deltaEtaByLyr

◆ m_deltaEtaCurvature

◆ m_deltaEtaDR

◆ m_deltaPhi