#include <FPGATrackSimGenScanMonitoring.h>

Inheritance diagram for FPGATrackSimGenScanMonitoring:

Classes
struct	eventDispSet

Public Member Functions
	FPGATrackSimGenScanMonitoring (const std::string &, const std::string &, const IInterface *)
virtual StatusCode	initialize () override
StatusCode	registerHistograms (const FPGATrackSimBinnedHits *binnedhits)
void	allocateDataFlowCounters ()
void	resetDataFlowCounters ()
StatusCode	registerGraphs ()
const std::string	dir () const
void	parseTruthInfo (std::vector< FPGATrackSimTruthTrack > const *truthtracks, bool isSingleParticle)
void	fillHitLevelInput (const FPGATrackSimHit *hit)
void	fillBinLevelOutput (const FPGATrackSimBinUtil::IdxSet &idx, const FPGATrackSimBinnedHits::BinEntry &data)
void	fillHitsByLayer (const std::vector< std::vector< const FPGATrackSimBinUtil::StoredHit * > > &hitsByLayer)
void	fillPairingHits (std::vector< const FPGATrackSimBinUtil::StoredHit * > const lastlyr, std::vector< const FPGATrackSimBinUtil::StoredHit > const *lastlastlyr)
void	fillPairFilterCuts (const FPGATrackSimGenScanTool::HitPair &pair, double r_in, double r_out)
void	fillPairSetFilterCut (std::vector< TH1D * > &histset, double val, const FPGATrackSimGenScanTool::HitPair &pair, const FPGATrackSimGenScanTool::HitPair &lastpair, bool nminus1)
void	fillBinningSummary (const std::vector< std::shared_ptr< const FPGATrackSimHit > > &hits)
void	fillBuildGroupsWithPairs (const std::vector< FPGATrackSimGenScanTool::IntermediateState > &states, unsigned allowed_misses)
void	sliceCheck ()
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`.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard `StoreGateSvc/DetectorStore` Returns (kind of) a pointer to the `StoreGateSvc`.
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

Public Attributes
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
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.

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
void	setBinPlotsActive (const FPGATrackSimBinUtil::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, const HistDef &... histargs)
template<typename HistType, typename... HistDef>
StatusCode	makeAndRegHistVector (std::vector< HistType * > &vec, unsigned len, const std::vector< std::string > namevec, const char namebase, const HistDef &... histargs)
StatusCode	regGraph (TGraph *g) const
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
ServiceHandle< ITHistSvc >	m_tHistSvc {this, "THistSvc", "THistSvc"}
Gaudi::Property< std::string >	m_dir {this, "dir", {"/GENSCAN/"}, "String name of output directory"}
Gaudi::Property< double >	m_phiScale {this, "phiScale", {}, "Scale for Delta Phi variable"}
Gaudi::Property< double >	m_etaScale {this, "etaScale", {}, "Scale for Delta Eta variable"}
Gaudi::Property< double >	m_drScale {this, "drScale", {}, "Scale for radius differences"}
const FPGATrackSimBinnedHits *	m_binnedhits {nullptr}
std::vector< FPGATrackSimTruthTrack > const *	m_truthtracks {nullptr}
bool	m_isSingleParticle = false
bool	m_truthIsValid = false
FPGATrackSimTrackPars	m_truthpars
std::vector< FPGATrackSimBinUtil::IdxSet >	m_truthbin
FPGATrackSimBinUtil::ParSet	m_truthparset
bool	m_binPlotsActive = false
std::vector< unsigned >	m_hitsCntByLayer
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
std::vector< TH1D * >	m_hitsPerStepBin
TH1D *	m_hitsPerLayer = 0
TH2D *	m_hitsPerLayer2D = 0
TH1D *	m_numLyrsPerBin = 0
TH2D *	m_hitsPerLayer_bin = 0
TH1D *	m_phiShift_road = 0
TH1D *	m_etaShift_road = 0
TH2D *	m_phiShift2D_road = 0
TH2D *	m_etaShift2D_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)
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default)
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 37 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 21 of file FPGATrackSimGenScanMonitoring.cxx.

                                                                                                                                   :
  AthAlgTool(algname, name, ifc)
{
}

Member Function Documentation

◆ allocateDataFlowCounters()

void FPGATrackSimGenScanMonitoring::allocateDataFlowCounters ( )

Definition at line 226 of file FPGATrackSimGenScanMonitoring.cxx.

                                                             {
  m_hitsCntByLayer.resize(m_binnedhits->getNLayers(),0);  
}

◆ bookTree()

StatusCode FPGATrackSimGenScanMonitoring::bookTree ( )

private

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

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty	(	Gaudi::Property< T, V, H > &	hndl,
		const SG::VarHandleKeyType &	)

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

◆ declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T, V, H > & t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                     {
    typedef typename SG::HandleClassifier<T>::type htype;
    return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
  }

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

AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

StoreGateSvc_t m_detStore

Definition AthCommonDataStore.h:393

◆ dir()

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

inline

Definition at line 58 of file FPGATrackSimGenScanMonitoring.h.

58{return m_dir;}

◆ evtStore()

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

AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

StoreGateSvc_t m_evtStore

Definition AthCommonDataStore.h:390

◆ 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 FPGATrackSimBinUtil::IdxSet &	idx,
		const FPGATrackSimBinnedHits::BinEntry &	data )

Definition at line 253 of file FPGATrackSimGenScanMonitoring.cxx.

{
  setBinPlotsActive(idx);
 
  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<FPGATrackSimBinUtil::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();
  }
}

◆ fillBinningSummary()

void FPGATrackSimGenScanMonitoring::fillBinningSummary ( const std::vector< std::shared_ptr< const FPGATrackSimHit > > & hits )

Definition at line 353 of file FPGATrackSimGenScanMonitoring.cxx.

{
  m_inputHits->Fill(hits.size());
  m_allHitsGraph.addEvent(hits);
 
  for (auto &step : m_binnedhits->getBinTool().steps()) {
    for (auto bin : m_binnedhits->binnedHits()[step->stepNum()])
      m_hitsPerStepBin[step->stepNum()]->Fill(bin.data().hitCnt);
  }
 
  for (auto bin :m_binnedhits->binnedHits()[m_binnedhits->getBinTool().lastStep()->stepNum()]) {
    for (unsigned lyr = 0; lyr < m_binnedhits->getNLayers(); lyr++) {
      unsigned cnt = bin.data().hitsInLyr(lyr);
      m_hitsPerLayer->Fill(lyr, cnt);
      m_hitsPerLayer2D->Fill(lyr, cnt);
    }
  }
}

◆ fillBuildGroupsWithPairs()

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

Definition at line 569 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 305 of file FPGATrackSimGenScanMonitoring.cxx.

                                {
  const IFPGATrackSimBinDesc* bindesc = m_binnedhits->getBinTool().binDesc();
  m_rZ_allhits[m_binnedhits->getNLayers()]->Fill(hit->getZ(), hit->getR());       // all layer plot
  m_rZ_allhits[hit->getLayer()]->Fill(hit->getZ(), hit->getR()); // layer specific plot
  if (m_truthIsValid)
    {
      m_etaResidual[m_binnedhits->getNLayers()]->Fill(bindesc->etaResidual(m_truthparset, hit));
      m_etaResidual[hit->getLayer()]->Fill(bindesc->etaResidual(m_truthparset, hit));
      m_phiResidual[m_binnedhits->getNLayers()]->Fill(bindesc->phiResidual(m_truthparset, hit));
      m_phiResidual[hit->getLayer()]->Fill(bindesc->phiResidual(m_truthparset, hit));
 
      if (m_truthbin.back() != FPGATrackSimBinUtil::invalidBin) {
        FPGATrackSimBinUtil::ParSet binCenter = m_binnedhits->getBinTool().lastStep()->binCenter(m_truthbin.back());
        m_etaTrueBinShift[m_binnedhits->getNLayers()]->Fill(bindesc->etaResidual(binCenter, hit));
        m_etaTrueBinShift[hit->getLayer()]->Fill(bindesc->etaResidual(binCenter, hit));
        m_phiTrueBinShift[m_binnedhits->getNLayers()]->Fill(bindesc->phiResidual(binCenter, hit));
        m_phiTrueBinShift[hit->getLayer()]->Fill(bindesc->phiResidual(binCenter, hit));
      }
  }
}

◆ fillHitsByLayer()

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

Definition at line 296 of file FPGATrackSimGenScanMonitoring.cxx.

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

◆ fillPairFilterCuts()

void FPGATrackSimGenScanMonitoring::fillPairFilterCuts	(	const FPGATrackSimGenScanTool::HitPair &	pair,
		double	r_in,
		double	r_out )

Definition at line 469 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(r_in));
    m_phiOutExtrap->Fill(pair.PhiOutExtrap(r_out));
    m_etaInExtrap->Fill(pair.EtaInExtrap(r_in));
    m_etaOutExtrap->Fill(pair.EtaOutExtrap(r_out));
  }
}

◆ fillPairingHits()

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

Definition at line 452 of file FPGATrackSimGenScanMonitoring.cxx.

                                                                        {
 
  auto size_if_nonzero_ptr =
      [](std::vector<const FPGATrackSimBinUtil::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 538 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);
  }
}

◆ initialize()

StatusCode FPGATrackSimGenScanMonitoring::initialize ( )

overridevirtual

Definition at line 26 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.

◆ makeAndRegHist()

template<typename HistType, typename... HistDef>

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

inlineprivate

Definition at line 276 of file FPGATrackSimGenScanMonitoring.h.

    {   
        ptr = new HistType(histargs...);
        ATH_MSG_DEBUG("Booking Hist: " << ptr->GetName() << " min=" << ptr->GetXaxis()->GetXmin() << " max=" << ptr->GetXaxis()->GetXmax());
        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,
		const HistDef &...	histargs )

inlineprivate

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

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

◆ 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 328 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 492 of file FPGATrackSimGenScanMonitoring.cxx.

                                                          {
  unsigned 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 552 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 )

Definition at line 374 of file FPGATrackSimGenScanMonitoring.cxx.

{
  ATH_MSG_DEBUG("In parseTruthInfo ptr = " << truthtracks 
                << " size = " << (truthtracks ? truthtracks->size() : 0));
  m_isSingleParticle = isSingleParticle;
  m_truthtracks = truthtracks;
  m_truthIsValid = false;
 
  const IFPGATrackSimBinDesc* bindesc = m_binnedhits->getBinTool().binDesc();
 
  if (!m_truthtracks) return;
  if (m_truthtracks->size() == 0) return;
 
  // Convert to binning parameters and find truth bin for each step
  m_truthpars = (*m_truthtracks)[0].getPars();
  m_truthpars[FPGATrackSimTrackPars::IHIP] =
      m_truthpars[FPGATrackSimTrackPars::IHIP] * 1000;
  m_truthparset = bindesc->trackParsToParSet(m_truthpars);
  m_truthbin.clear();
  for (auto &step : m_binnedhits->getBinTool().steps()) {
    m_truthbin.push_back(step->binIdx(m_truthparset));
  }
 
  // histogram parameters
  for (unsigned i = 0; i < FPGATrackSimTrackPars::NPARS; i++) {
    m_truthpars_hists[i]->Fill(m_truthparset[i]);
  }
 
  // a closure test
  FPGATrackSimTrackPars recovered = bindesc->parSetToTrackPars(m_truthparset);
  ATH_MSG_DEBUG("truth 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_DEBUG("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);
 
  // Check if the truth track falls in the binning range
  if (!m_binnedhits->getBinTool().inRange(m_truthparset)) {
    ATH_MSG_INFO("Truth out of range");
    return;
  }
 
  // Check that truth track falls in an actual bin
  // this should alway pass, except for weird events
  m_truthIsValid = true;
  for (auto &step : m_binnedhits->getBinTool().steps()) {
    if (!step->validBinsFull()[m_truthbin[step->stepNum()]]) {
      ATH_MSG_INFO("Truth Bin not valid! Step " << step->stepName() << " "
                                                << m_truthbin[step->stepNum()]
                                                << " : " << m_truthpars);
      std::vector<FPGATrackSimBinUtil::IdxSet> idxsets =
          FPGATrackSimBinUtil::makeVariationSet(
              std::vector<unsigned>({0, 1, 2, 3, 4}),
              m_truthbin[step->stepNum()]);
      for (FPGATrackSimBinUtil::IdxSet &idxset : idxsets) {
        ATH_MSG_INFO("Truth Box "
                     << bindesc->parSetToTrackPars(step->binLowEdge(idxset)));
      }
      m_truthIsValid = false;
    }
  }
}

◆ regGraph()

StatusCode FPGATrackSimGenScanMonitoring::regGraph ( TGraph * g ) const

inlineprivate

Definition at line 309 of file FPGATrackSimGenScanMonitoring.h.

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

python.CaloCondTools.g

g

Definition CaloCondTools.py:15

◆ registerGraphs()

StatusCode FPGATrackSimGenScanMonitoring::registerGraphs ( )

Definition at line 236 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 ( const FPGATrackSimBinnedHits * binnedhits )

Definition at line 44 of file FPGATrackSimGenScanMonitoring.cxx.

{
  m_binnedhits = binnedhits;
  const FPGATrackSimBinTool &bintool = m_binnedhits->getBinTool();
  const IFPGATrackSimBinDesc* bindesc = bintool.binDesc();
  int nLyrs = m_binnedhits->getNLayers();
 
  // This is because if you change the binning class you can change what axis
  // ranges you need for the plotting
  ATH_MSG_INFO("Hist scales phi: " << m_phiScale << "  eta: " << m_etaScale << "  dr:" << m_drScale);
  
  allocateDataFlowCounters();
 
  // Truth Parameter distributions, bounds should cover 3x nominal range
  for (unsigned i = 0; i < FPGATrackSimTrackPars::NPARS; i++) {
    ATH_CHECK(makeAndRegHist(
        m_truthpars_hists[i], ("truth" + bindesc->parNames(i)).c_str(),
        (";" + m_binnedhits->getBinTool().binDesc()->parNames(i) + ";").c_str(), 200,
        -2 * m_binnedhits->getBinTool().parRange(i),
        2 * m_binnedhits->getBinTool().parRange(i)));
  }
 
  // All Hit level histograms
  ATH_CHECK(makeAndRegHistVector(m_rZ_allhits, nLyrs+1, NULL , 
            "RZ_allhits", "; Z [mm] ; R [mm] ", 500, -2000, 2000, 500, 0, 500));
  
  ATH_CHECK(makeAndRegHistVector(m_phiResidual, nLyrs+1, NULL , 
            "phiResidual", "phi residual [mm]", 1000, -10, 10));
  ATH_CHECK(makeAndRegHistVector(m_etaResidual,nLyrs+1, NULL ,  
            "etaResidual", "eta residual [mm]", 1000, -10, 10));
 
  ATH_CHECK(makeAndRegHistVector(m_phiTrueBinShift, nLyrs+1, NULL , 
            "phiTrueBinShift", "phi TrueBinShift [mm]", 1000, -10, 10));
  ATH_CHECK(makeAndRegHistVector(m_etaTrueBinShift,nLyrs+1, NULL ,  
            "etaTrueBinShift", "eta TrueBinShift [mm]", 1000, -10, 10));
 
  // Data flow hists
  ATH_CHECK(
      makeAndRegHist(m_inputHits, "InputHits", ";Input Hits", 200, 0, 100000));
  ATH_CHECK(makeAndRegHistVector(m_hitsPerStepBin, bintool.steps().size(),
                                 &bintool.stepNames(), "hitsPerStepBin_",
                                 "; Hits per bin in step", 1000, 0, 1000));
  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));
  ATH_CHECK(makeAndRegHist(m_numLyrsPerBin, "numLyrsPerBin",
                           ";#Hit Layers per Bin", nLyrs + 1, 0, nLyrs + 1));
  ATH_CHECK(makeAndRegHist(m_hitsPerLayer, "hitsPerLayer", "; Layer ; Hits ",
                           nLyrs, 0, nLyrs));
  ATH_CHECK(makeAndRegHist(m_hitsPerLayer2D, "hitsPerLayer2D",
                           "; Layer ; Hits ", nLyrs, 0, nLyrs, 20, 0,
                           m_isSingleParticle ? 20 : 10000));
  
 
  // Road statistics
  ATH_CHECK(makeAndRegHist(m_roadFilterFlow , "roadFilterFlow" , "road filter flow", 10, 0, 10));
  ATH_CHECK(makeAndRegHist(m_phiShift_road, "phiShift_road", ";Phi Shift", 2000, -1.0*m_phiScale, m_phiScale));
  ATH_CHECK(makeAndRegHist(m_etaShift_road, "etaShift_road", ";Eta Shift", 2000, -1.0*m_etaScale, m_etaScale));
  ATH_CHECK(makeAndRegHist(m_phiShift2D_road, "phiShift2D_road", ";Phi Shift; R", 
                          400, -1.0*m_phiScale, m_phiScale, 100, 0, 400));
  ATH_CHECK(makeAndRegHist(m_etaShift2D_road, "etaShift2D_road", ";Phi Shift; R", 
                          400, -1.0*m_etaScale, m_etaScale, 100, 0, 400));
 
  ATH_CHECK(makeAndRegHist(m_hitsPerLayer_bin, "HitsPerLayer_bin",
                           "; Layer; Hits in Bin Passing Threshold",
                           nLyrs, 0, nLyrs, 20, 0, 20));
 
 
  // Pair Filter Cuts
  ATH_CHECK(makeAndRegHist(m_phiOutExtrap, "PhiOutExtrap", ";Phi Out Extrap", 2000, -1.0*m_phiScale, m_phiScale));
  ATH_CHECK(makeAndRegHist(m_phiInExtrap, "PhiInExtrap", ";Phi In Extrap", 2000, -1.0*m_phiScale, m_phiScale));
  ATH_CHECK(makeAndRegHist(m_phiOutExtrapCurveLimit, "PhiOutExtrapCurveLimit", 
    ";Phi Out Extrap w/ Curve Limit", 2000, -1.0*m_phiScale, m_phiScale));
  ATH_CHECK(makeAndRegHist(m_phiInExtrapCurveLimit, "PhiInExtrapCurveLimit", 
    ";Phi In Extrap w/ Curve Limit", 2000, -1.0*m_phiScale, m_phiScale));
  ATH_CHECK(makeAndRegHist(m_etaOutExtrap, "EtaOutExtrap", ";Eta Out Extrap", 2000, -1.0*m_etaScale, m_etaScale));
  ATH_CHECK(makeAndRegHist(m_etaInExtrap, "EtaInExtrap", ";Eta In Extrap", 2000, -1.0* m_etaScale, m_etaScale));
  ATH_CHECK(makeAndRegHist(m_deltaPhi, "DeltaPhi", ";Delta Phi [rad]", 2000, -1.0*m_phiScale, m_phiScale));
  ATH_CHECK(makeAndRegHist(m_deltaEta, "DeltaEta", ";Delta Eta [rad]", 2000, -1.0*m_etaScale, m_etaScale));
  ATH_CHECK(makeAndRegHist(m_deltaPhiDR, "DeltaPhiDR", ";Delta Phi / Delta R", 2000, -0.1 * m_phiScale, 0.1 * m_phiScale));
  ATH_CHECK(makeAndRegHist(m_deltaEtaDR, "DeltaEtaDR", ";Delta Eta / Delta R", 2000, -0.1 * m_phiScale, 0.1 * m_phiScale));
  ATH_CHECK(makeAndRegHistVector(m_deltaPhiByLyr, nLyrs, NULL, "DeltaPhiDR", ";Delta Phi / Delta R", 2000, -0.1 * m_phiScale, 0.1 * m_phiScale));
  ATH_CHECK(makeAndRegHistVector(m_deltaEtaByLyr, nLyrs, NULL,  "DeltaEtaDR", ";Delta Eta / Delta R", 2000, -0.1 * m_phiScale, 0.1 * m_phiScale));
 
  // Pair Match Cuts
  ATH_CHECK(makeAndRegHistVector(
      m_pairSetMatchPhi, m_twoPairClasses.size(), &m_twoPairClasses,
      "PairSetMatchPhi", ";PairSet Match Phi [mm]", 500,
      -1.0*m_phiScale / m_drScale, m_phiScale / m_drScale));
  ATH_CHECK(makeAndRegHistVector(
      m_pairSetMatchEta, m_twoPairClasses.size(), &m_twoPairClasses,
      "PairSetMatchEta", ";PairSet Match Eta [mm]", 500,
      -1.0*m_etaScale / m_drScale, m_etaScale / m_drScale));
  ATH_CHECK(makeAndRegHistVector(
      m_deltaDeltaPhi, m_twoPairClasses.size(), &m_twoPairClasses,
      "DeltaDeltaPhi", ";DeltaDelta   Phi [mm]", 500, -1.0*m_phiScale / m_drScale,
      m_phiScale / m_drScale));
  ATH_CHECK(makeAndRegHistVector(
      m_deltaDeltaEta, m_twoPairClasses.size(), &m_twoPairClasses,
      "DeltaDeltaEta", ";DeltaDelta   Eta [mm]", 500, -1.0 * m_etaScale / m_drScale,
      1.0 * m_etaScale / m_drScale));
  ATH_CHECK(makeAndRegHistVector(m_phiCurvature, m_twoPairClasses.size(),
                               &m_twoPairClasses, "PhiCurvature",
                               ";Phi Curvature ", 5000,
                               -1.0 * m_phiScale / m_drScale / m_drScale,
                               1.0 * m_phiScale / m_drScale / m_drScale));
  ATH_CHECK(makeAndRegHistVector(m_etaCurvature, m_twoPairClasses.size(),
                               &m_twoPairClasses, "EtaCurvature",
                               ";Eta Curvature ", 5000,
                               -1.0 * m_etaScale / m_drScale / m_drScale,
                               1.0 * m_etaScale / m_drScale / m_drScale));
  ATH_CHECK(makeAndRegHistVector(m_deltaPhiCurvature, m_twoPairClasses.size(),
                               &m_twoPairClasses, "DeltaPhiCurvature",
                               ";Delta Phi Curvature ", 5000,
                               -1.0 * m_phiScale / m_drScale / m_drScale,
                               1.0 * m_phiScale / m_drScale / m_drScale));
  ATH_CHECK(makeAndRegHistVector(m_deltaEtaCurvature, m_twoPairClasses.size(),
                               &m_twoPairClasses, "DeltaEtaCurvature",
                               ";Delta Eta Curvature ", 500,
                               -0.1 * m_etaScale / m_drScale / m_drScale,
                               0.1 * m_etaScale / m_drScale / m_drScale));
  ATH_CHECK(makeAndRegHistVector(m_phiOutExtrapCurved, m_twoPairClasses.size(),
                               &m_twoPairClasses, "PhiOutExtrapCurved",
                               ";Phi Out Extrap Curved", 2000, -1.0*m_phiScale,
                               m_phiScale));
  ATH_CHECK(makeAndRegHistVector(m_phiInExtrapCurved, m_twoPairClasses.size(),
                               &m_twoPairClasses, "PhiInExtrapCurved",
                               ";Phi In Extrap Curved ", 2000, -1.0*m_phiScale,
                               m_phiScale));
  ATH_CHECK(makeAndRegHist(m_pairMatchPhi2D, "PairSetMatchPhi2D",
                         ";PairSet Match Phi vs dRin [mm]", 100, 0, 100, 500,
                         -100.0 * m_phiScale, 100.0 * m_phiScale));
  ATH_CHECK(makeAndRegHist(m_pairMatchEta2D, "PairSetMatchEta2D",
                         ";PairSet Match Eta vs dRin [mm]", 100, 0, 100, 500,
                         -100.0 * m_etaScale, 100.0 * m_etaScale));
 
  ATH_CHECK(makeAndRegHist(m_unpairedHits, "UnpairedHits", "; Stage ; Unpaired Hits" , nLyrs+1, 0, nLyrs+1, 20, 0, 20));
  ATH_CHECK(makeAndRegHist(m_pairsetsIncr, "PairSetsIncr", "; Stage ; Pairsets" , nLyrs+1, 0, nLyrs+1, 20, 0, 20));
  ATH_CHECK(makeAndRegHist(m_pairsetsHits, "PairSetsHits", "; Stage ; Hits in Pairsets" , nLyrs+1, 0, nLyrs+1, 20, 0, 20));
  ATH_CHECK(makeAndRegHist(m_totalInputIncr, "TotalInputIncr", "; Stage ; Pairsets+Unpaired" , nLyrs+1, 0, nLyrs+1, 20, 0, 20));
  ATH_CHECK(makeAndRegHist(m_binStagesIncr, "BinStagesIncr", "; Stage ; Bins at this point" , nLyrs+1, 0, nLyrs+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 230 of file FPGATrackSimGenScanMonitoring.cxx.

                                                          {
  for (auto& bin: m_hitsCntByLayer) { bin =0;}
}

◆ setBinPlotsActive()

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

inlineprivate

Definition at line 124 of file FPGATrackSimGenScanMonitoring.h.

124 {

125 m_binPlotsActive = ((m_truthbin.back() == idx) || (!m_isSingleParticle));}

◆ sliceCheck()

void FPGATrackSimGenScanMonitoring::sliceCheck ( )

◆ 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 asg::AsgMetadataTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and DerivationFramework::CfAthAlgTool.

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

250{std::string("allHits"), 10};

◆ m_bin_module_tree

TTree* FPGATrackSimGenScanMonitoring::m_bin_module_tree = nullptr

private

Definition at line 260 of file FPGATrackSimGenScanMonitoring.h.

◆ m_binnedhits

const FPGATrackSimBinnedHits* FPGATrackSimGenScanMonitoring::m_binnedhits {nullptr}

private

Definition at line 109 of file FPGATrackSimGenScanMonitoring.h.

109{nullptr};

◆ m_binPlotsActive

bool FPGATrackSimGenScanMonitoring::m_binPlotsActive = false

private

Definition at line 127 of file FPGATrackSimGenScanMonitoring.h.

◆ m_binStagesIncr

TH2D* FPGATrackSimGenScanMonitoring::m_binStagesIncr = 0

private

Definition at line 166 of file FPGATrackSimGenScanMonitoring.h.

◆ m_deltaDeltaEta

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

Definition at line 201 of file FPGATrackSimGenScanMonitoring.h.

◆ m_deltaDeltaPhi

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

Definition at line 200 of file FPGATrackSimGenScanMonitoring.h.

◆ m_deltaEta

TH1D* FPGATrackSimGenScanMonitoring::m_deltaEta = 0

private

Definition at line 174 of file FPGATrackSimGenScanMonitoring.h.

◆ m_deltaEtaByLyr

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

private

Definition at line 184 of file FPGATrackSimGenScanMonitoring.h.

◆ m_deltaEtaCurvature

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

Definition at line 207 of file FPGATrackSimGenScanMonitoring.h.

◆ m_deltaEtaDR

TH1D* FPGATrackSimGenScanMonitoring::m_deltaEtaDR = 0

private

Definition at line 176 of file FPGATrackSimGenScanMonitoring.h.

◆ m_deltaPhi

TH1D* FPGATrackSimGenScanMonitoring::m_deltaPhi = 0

private

Definition at line 173 of file FPGATrackSimGenScanMonitoring.h.

◆ m_deltaPhiByLyr

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

private

Definition at line 183 of file FPGATrackSimGenScanMonitoring.h.

◆ m_deltaPhiCurvature

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

Definition at line 206 of file FPGATrackSimGenScanMonitoring.h.

◆ m_deltaPhiDR

TH1D* FPGATrackSimGenScanMonitoring::m_deltaPhiDR = 0

private

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

102{this, "dir", {"/GENSCAN/"}, "String name of output directory"};

◆ m_drScale

Gaudi::Property<double> FPGATrackSimGenScanMonitoring::m_drScale {this, "drScale", {}, "Scale for radius differences"}

private

Definition at line 105 of file FPGATrackSimGenScanMonitoring.h.

105{this, "drScale", {}, "Scale for radius differences"};

◆ m_etaCurvature

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

Definition at line 205 of file FPGATrackSimGenScanMonitoring.h.

◆ m_etaCurvatureMax

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

Definition at line 209 of file FPGATrackSimGenScanMonitoring.h.

◆ m_etaInExtrap

TH1D* FPGATrackSimGenScanMonitoring::m_etaInExtrap = 0

private

Definition at line 182 of file FPGATrackSimGenScanMonitoring.h.

◆ m_etaOutExtrap

TH1D* FPGATrackSimGenScanMonitoring::m_etaOutExtrap = 0

private

Definition at line 181 of file FPGATrackSimGenScanMonitoring.h.

◆ m_etaResidual

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

private

Definition at line 138 of file FPGATrackSimGenScanMonitoring.h.

◆ m_etaScale

Gaudi::Property<double> FPGATrackSimGenScanMonitoring::m_etaScale {this, "etaScale", {}, "Scale for Delta Eta variable"}

private

Definition at line 104 of file FPGATrackSimGenScanMonitoring.h.

104{this, "etaScale", {}, "Scale for Delta Eta variable"};

◆ m_etaShift2D_road

TH2D* FPGATrackSimGenScanMonitoring::m_etaShift2D_road = 0

private

Definition at line 155 of file FPGATrackSimGenScanMonitoring.h.

◆ m_etaShift_road

TH1D* FPGATrackSimGenScanMonitoring::m_etaShift_road = 0

private

Definition at line 153 of file FPGATrackSimGenScanMonitoring.h.

◆ m_etaTrueBinShift

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

private

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

◆ m_hitsCntByLayer

std::vector<unsigned> FPGATrackSimGenScanMonitoring::m_hitsCntByLayer

private

Definition at line 131 of file FPGATrackSimGenScanMonitoring.h.

◆ m_hitsPerLayer

TH1D* FPGATrackSimGenScanMonitoring::m_hitsPerLayer = 0

private

Definition at line 146 of file FPGATrackSimGenScanMonitoring.h.

◆ m_hitsPerLayer2D

TH2D* FPGATrackSimGenScanMonitoring::m_hitsPerLayer2D = 0

private

Definition at line 147 of file FPGATrackSimGenScanMonitoring.h.

◆ m_hitsPerLayer_bin

TH2D* FPGATrackSimGenScanMonitoring::m_hitsPerLayer_bin = 0

private

Definition at line 150 of file FPGATrackSimGenScanMonitoring.h.

◆ m_hitsPerStepBin

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

private

Definition at line 145 of file FPGATrackSimGenScanMonitoring.h.

◆ m_inputHits

TH1D* FPGATrackSimGenScanMonitoring::m_inputHits = 0

private

Definition at line 142 of file FPGATrackSimGenScanMonitoring.h.

◆ m_isSingleParticle

bool FPGATrackSimGenScanMonitoring::m_isSingleParticle = false

private

Definition at line 115 of file FPGATrackSimGenScanMonitoring.h.

◆ m_lostPairFilterGraph

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

private

Definition at line 252 of file FPGATrackSimGenScanMonitoring.h.

252{std::string("lostpairfilter"), 10};

◆ m_lostPairSetFilterGraph

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

private

Definition at line 254 of file FPGATrackSimGenScanMonitoring.h.

254{std::string("lostpairsetfilter"), 10};

◆ m_nminus1_idx

unsigned FPGATrackSimGenScanMonitoring::m_nminus1_idx = 6

private

Definition at line 194 of file FPGATrackSimGenScanMonitoring.h.

◆ m_numLyrsPerBin

TH1D* FPGATrackSimGenScanMonitoring::m_numLyrsPerBin = 0

private

Definition at line 148 of file FPGATrackSimGenScanMonitoring.h.

◆ m_pairinghits

TH1D* FPGATrackSimGenScanMonitoring::m_pairinghits = 0

private

Definition at line 169 of file FPGATrackSimGenScanMonitoring.h.

◆ m_pairMatchEta2D

TH2D* FPGATrackSimGenScanMonitoring::m_pairMatchEta2D = 0

private

Definition at line 215 of file FPGATrackSimGenScanMonitoring.h.

◆ m_pairMatchPhi2D

TH2D* FPGATrackSimGenScanMonitoring::m_pairMatchPhi2D = 0

private

Definition at line 214 of file FPGATrackSimGenScanMonitoring.h.

◆ m_pairs

TH1D* FPGATrackSimGenScanMonitoring::m_pairs = 0

private

Definition at line 158 of file FPGATrackSimGenScanMonitoring.h.

◆ m_pairSetMatchEta

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

Definition at line 203 of file FPGATrackSimGenScanMonitoring.h.

◆ m_pairSetMatchPhi

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

Definition at line 202 of file FPGATrackSimGenScanMonitoring.h.

◆ m_pairsets

TH1D* FPGATrackSimGenScanMonitoring::m_pairsets = 0

private

Definition at line 160 of file FPGATrackSimGenScanMonitoring.h.

◆ m_pairsetsHits

TH2D* FPGATrackSimGenScanMonitoring::m_pairsetsHits = 0

private

Definition at line 165 of file FPGATrackSimGenScanMonitoring.h.

◆ m_pairsetsIncr

TH2D* FPGATrackSimGenScanMonitoring::m_pairsetsIncr = 0

private

Definition at line 164 of file FPGATrackSimGenScanMonitoring.h.

◆ m_passPairFilterGraph

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

private

Definition at line 253 of file FPGATrackSimGenScanMonitoring.h.

253{std::string("passpairfilter"), 10};

◆ m_passPairSetFilterGraph

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

private

Definition at line 255 of file FPGATrackSimGenScanMonitoring.h.

255{std::string("passpairsetfilter"), 10};

◆ m_phiCurvature

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

Definition at line 204 of file FPGATrackSimGenScanMonitoring.h.

◆ m_phiCurvatureMax

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

Definition at line 208 of file FPGATrackSimGenScanMonitoring.h.

◆ m_phiInExtrap

TH1D* FPGATrackSimGenScanMonitoring::m_phiInExtrap = 0

private

Definition at line 178 of file FPGATrackSimGenScanMonitoring.h.

◆ m_phiInExtrapCurved

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

Definition at line 210 of file FPGATrackSimGenScanMonitoring.h.

◆ m_phiInExtrapCurveLimit

TH1D* FPGATrackSimGenScanMonitoring::m_phiInExtrapCurveLimit =0

private

Definition at line 180 of file FPGATrackSimGenScanMonitoring.h.

◆ m_phiOutExtrap

TH1D* FPGATrackSimGenScanMonitoring::m_phiOutExtrap = 0

private

Definition at line 177 of file FPGATrackSimGenScanMonitoring.h.

◆ m_phiOutExtrapCurved

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

Definition at line 211 of file FPGATrackSimGenScanMonitoring.h.

◆ m_phiOutExtrapCurveLimit

TH1D* FPGATrackSimGenScanMonitoring::m_phiOutExtrapCurveLimit =0

private

Definition at line 179 of file FPGATrackSimGenScanMonitoring.h.

◆ m_phiResidual

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

private

Definition at line 137 of file FPGATrackSimGenScanMonitoring.h.

◆ m_phiScale

Gaudi::Property<double> FPGATrackSimGenScanMonitoring::m_phiScale {this, "phiScale", {}, "Scale for Delta Phi variable"}

private

Definition at line 103 of file FPGATrackSimGenScanMonitoring.h.

103{this, "phiScale", {}, "Scale for Delta Phi variable"};

◆ m_phiShift2D_road

TH2D* FPGATrackSimGenScanMonitoring::m_phiShift2D_road = 0

private

Definition at line 154 of file FPGATrackSimGenScanMonitoring.h.

◆ m_phiShift_road

TH1D* FPGATrackSimGenScanMonitoring::m_phiShift_road = 0

private

Definition at line 152 of file FPGATrackSimGenScanMonitoring.h.

◆ m_phiTrueBinShift

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

private

Definition at line 139 of file FPGATrackSimGenScanMonitoring.h.

◆ m_roadFilterFlow

TH1D* FPGATrackSimGenScanMonitoring::m_roadFilterFlow = 0

private

Definition at line 171 of file FPGATrackSimGenScanMonitoring.h.

◆ m_roadGraph

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

private

Definition at line 251 of file FPGATrackSimGenScanMonitoring.h.

251{std::string("road"), 10};

◆ m_rZ_allhits

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

private

Definition at line 135 of file FPGATrackSimGenScanMonitoring.h.

◆ m_tHistSvc

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

private

Definition at line 98 of file FPGATrackSimGenScanMonitoring.h.

98{this, "THistSvc", "THistSvc"};

◆ m_totalInputIncr

TH2D* FPGATrackSimGenScanMonitoring::m_totalInputIncr = 0

private

Definition at line 167 of file FPGATrackSimGenScanMonitoring.h.

◆ m_tree_bin

std::vector<unsigned> FPGATrackSimGenScanMonitoring::m_tree_bin

private

Definition at line 261 of file FPGATrackSimGenScanMonitoring.h.

◆ m_tree_dettype

std::vector<int> FPGATrackSimGenScanMonitoring::m_tree_dettype

private

Definition at line 270 of file FPGATrackSimGenScanMonitoring.h.

◆ m_tree_detzone

std::vector<int> FPGATrackSimGenScanMonitoring::m_tree_detzone

private

Definition at line 271 of file FPGATrackSimGenScanMonitoring.h.

◆ m_tree_etamod

std::vector<int> FPGATrackSimGenScanMonitoring::m_tree_etamod

private

Definition at line 268 of file FPGATrackSimGenScanMonitoring.h.

◆ m_tree_hash

std::vector<int> FPGATrackSimGenScanMonitoring::m_tree_hash

private

Definition at line 265 of file FPGATrackSimGenScanMonitoring.h.

◆ m_tree_id

std::vector<int> FPGATrackSimGenScanMonitoring::m_tree_id

private

Definition at line 264 of file FPGATrackSimGenScanMonitoring.h.

◆ m_tree_layer

std::vector<int> FPGATrackSimGenScanMonitoring::m_tree_layer

private

Definition at line 266 of file FPGATrackSimGenScanMonitoring.h.

◆ m_tree_phimod

std::vector<int> FPGATrackSimGenScanMonitoring::m_tree_phimod

private

Definition at line 269 of file FPGATrackSimGenScanMonitoring.h.

◆ m_tree_r

std::vector<float> FPGATrackSimGenScanMonitoring::m_tree_r

private

Definition at line 262 of file FPGATrackSimGenScanMonitoring.h.

◆ m_tree_side

std::vector<int> FPGATrackSimGenScanMonitoring::m_tree_side

private

Definition at line 267 of file FPGATrackSimGenScanMonitoring.h.

◆ m_tree_z

std::vector<float> FPGATrackSimGenScanMonitoring::m_tree_z

private

Definition at line 263 of file FPGATrackSimGenScanMonitoring.h.

◆ m_truthbin

std::vector<FPGATrackSimBinUtil::IdxSet> FPGATrackSimGenScanMonitoring::m_truthbin

private

Definition at line 118 of file FPGATrackSimGenScanMonitoring.h.

◆ m_truthIsValid

bool FPGATrackSimGenScanMonitoring::m_truthIsValid = false

private

Definition at line 116 of file FPGATrackSimGenScanMonitoring.h.

◆ m_truthpars

FPGATrackSimTrackPars FPGATrackSimGenScanMonitoring::m_truthpars

private

Definition at line 117 of file FPGATrackSimGenScanMonitoring.h.

◆ m_truthpars_hists

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

private

Definition at line 136 of file FPGATrackSimGenScanMonitoring.h.

136{0, 0, 0, 0, 0};

◆ m_truthparset

FPGATrackSimBinUtil::ParSet FPGATrackSimGenScanMonitoring::m_truthparset

private

Definition at line 119 of file FPGATrackSimGenScanMonitoring.h.

◆ m_truthtracks

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

private

Definition at line 114 of file FPGATrackSimGenScanMonitoring.h.

114{nullptr};

◆ m_twoPairClasses

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

inlinestaticprivate

Initial value:

= {

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

Definition at line 192 of file FPGATrackSimGenScanMonitoring.h.

192 {

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

◆ m_unpairedHits

TH2D* FPGATrackSimGenScanMonitoring::m_unpairedHits = 0

private

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

◆ declareProperty()

◆ detStore()

◆ dir()

◆ evtStore()

◆ extraDeps_update_handler()

◆ fillBinLevelOutput()

◆ fillBinningSummary()

◆ fillBuildGroupsWithPairs()

◆ fillHitLevelInput()

◆ fillHitsByLayer()

◆ fillPairFilterCuts()

◆ fillPairingHits()

◆ fillPairSetFilterCut()

◆ initialize()

◆ inputHandles()

◆ makeAndRegHist()

◆ makeAndRegHistVector()

◆ msg()

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

◆ 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

◆ m_drScale

◆ m_etaCurvature

◆ m_etaCurvatureMax

◆ m_etaInExtrap

◆ m_etaOutExtrap

◆ m_etaResidual

◆ m_etaScale

◆ m_etaShift2D_road

◆ m_etaShift_road