#include <FPGATrackSimGenScanTool.h>

Inheritance diagram for FPGATrackSimGenScanTool:

Collaboration diagram for FPGATrackSimGenScanTool:

Classes
struct	BinEntry

class	HitPair

struct	HitPairSet

struct	IntermediateState

struct	StoredHit

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

virtual StatusCode	initialize () override

virtual StatusCode	getRoads (const std::vector< std::shared_ptr< const FPGATrackSimHit >> &hits, std::vector< std::shared_ptr< const FPGATrackSimRoad >> &road) override

virtual int	getSubRegion () const override

Protected Member Functions
void	computeValidBins ()

StatusCode	fillImage (const std::vector< std::shared_ptr< const FPGATrackSimHit >> &hits)

StatusCode	pairThenGroupFilter (const BinEntry &bindata, const FPGATrackSimGenScanBinningBase::IdxSet &bin, std::vector< HitPairSet > &output_pairset)

void	updateState (const IntermediateState &inputstate, IntermediateState &outputstate, unsigned lyridx, const std::vector< const StoredHit * > &newhits)

StatusCode	incrementalBuildFilter (const BinEntry &bindata, const FPGATrackSimGenScanBinningBase::IdxSet &bin, std::vector< HitPairSet > &output_pairset)

StatusCode	sortHitsByLayer (const BinEntry &bindata, std::vector< std::vector< const StoredHit * >> &hitsByLayer)

StatusCode	makePairs (const std::vector< std::vector< const StoredHit * >> &hitsByLayer, HitPairSet &pairs)

bool	pairPassesFilter (const HitPair &pair)

StatusCode	filterPairs (HitPairSet &pairs, HitPairSet &filteredpairs)

StatusCode	groupPairs (HitPairSet &filteredpairs, std::vector< HitPairSet > &clusters, bool verbose)

bool	pairMatchesPairSet (const HitPairSet &pairset, const HitPair &pair, bool verbose)

void	addRoad (std::vector< const StoredHit * > const &hits, const FPGATrackSimGenScanBinningBase::IdxSet &idx)

Protected Attributes
ServiceHandle< IFPGATrackSimEventSelectionSvc >	m_EvtSel {this, "FPGATrackSimEventSelectionSvc", "FPGATrackSimEventSelectionSvc"}

ServiceHandle< IFPGATrackSimBankSvc >	m_FPGATrackSimBankSvc {this, "FPGATrackSimBankSvc", "FPGATrackSimBankSvc"}

ServiceHandle< IFPGATrackSimMappingSvc >	m_FPGATrackSimMapping {this, "FPGATrackSimMappingSvc", "FPGATrackSimMappingSvc"}

ToolHandle< FPGATrackSimGenScanMonitoring >	m_monitoring {this, "Monitoring", "FPGATrackSimGenScanMonitoring", "Monitoring Tool"}

ToolHandle< FPGATrackSimGenScanBinningBase >	m_binning {this, "Binning", "FPGATrackSimGenScanBinningBase", "Gen Scan Binning Tool"}

Gaudi::Property< std::string >	m_parSet {this, "parSet", {}, "String name of parameter set"}

Gaudi::Property< std::vector< float > >	m_parMin {this, "parMin", {}, "Vector of minimum bounds of parameters (expect 5"}

Gaudi::Property< std::vector< float > >	m_parMax {this, "parMax", {}, "Vector of maximum bounds of parameters (expect 5"}

Gaudi::Property< std::vector< unsigned > >	m_parBins {this, "parBins", {}, "Vector of number of bins for each parameter (expect 5)"}

Gaudi::Property< double >	m_rin {this, "rin", {-1.0}, "Radius of inner layer for extrapolations and keylayer definition"}

Gaudi::Property< double >	m_rout {this, "rout", {-1.0}, "Radius of outer layer for extrapolations and keylayer definition"}

Gaudi::Property< double >	m_d0FractionalPadding {this, "d0FractionalPadding", {}, "Fractional padding used when calculating the valid range of bins"}

Gaudi::Property< double >	m_z0FractionalPadding {this, "z0FractionalPadding", {}, "Fractional padding used when calculating the valid range of bins"}

Gaudi::Property< double >	m_etaFractionalPadding {this, "etaFractionalPadding", {}, "Fractional padding used when calculating the valid range of bins"}

Gaudi::Property< double >	m_phiFractionalPadding {this, "phiFractionalPadding", {}, "Fractional padding used when calculating the valid range of bins"}

Gaudi::Property< double >	m_qOverPtFractionalPadding {this, "qOverPtFractionalPadding", {}, "Fractional padding used when calculating the valid range of bins"}

Gaudi::Property< unsigned >	m_threshold {this, "threshold", {}, "Minimum value to accept as a road (inclusive)"}

Gaudi::Property< std::string >	m_binFilter {this, "binFilter", {"PairThenGroup"}, "which bin filter to run, current options: PairThenGroup, IncrementalBuild"}

Gaudi::Property< bool >	m_applyPairFilter {this, "applyPairFilter", {}, "Apply Pair Filter"}

Gaudi::Property< bool >	m_reversePairDir {this, "reversePairDir", {}, "Build Pairs starting at last layer and work in"}

Gaudi::Property< std::vector< double > >	m_pairFilterDeltaPhiCut {this, "pairFilterDeltaPhiCut", {}, "Pair Filter Delta Phi Cut Value (list one per layer)"}

Gaudi::Property< std::vector< double > >	m_pairFilterDeltaEtaCut {this, "pairFilterDeltaEtaCut", {}, "Pair Filter Delta Eta Cut Value (list one per layer)"}

Gaudi::Property< std::vector< double > >	m_pairFilterPhiExtrapCut {this, "pairFilterPhiExtrapCut", {}, "Pair Filter Phi Extrap Cut Value (in/out pair)"}

Gaudi::Property< std::vector< double > >	m_pairFilterEtaExtrapCut {this, "pairFilterEtaExtrapCut", {}, "Pair Filter Eta Extrap Cut Value(in/out pair)"}

Gaudi::Property< bool >	m_applyPairSetFilter {this, "applyPairSetFilter", {}, "Apply PairSet Filter"}

Gaudi::Property< double >	m_pairSetMatchPhiCut {this, "pairSetMatchPhiCut", {}, "Pair Set Match Phi Cut Value"}

Gaudi::Property< double >	m_pairSetMatchEtaCut {this, "pairSetMatchEtaCut", {}, "Pair Set Match Eta Cut Value"}

Gaudi::Property< double >	m_pairSetDeltaDeltaPhiCut {this, "pairSetDeltaDeltaPhiCut", {}, "Pair Set Delta Delta Phi Cut Value"}

Gaudi::Property< double >	m_pairSetDeltaDeltaEtaCut {this, "pairSetDeltaDeltaEtaCut", {}, "Pair Set Delta Eta Cut Value"}

Gaudi::Property< double >	m_pairSetPhiCurvatureCut {this, "pairSetPhiCurvatureCut", {}, "Pair Set Phi Cut Value"}

Gaudi::Property< double >	m_pairSetEtaCurvatureCut {this, "pairSetEtaCurvatureCut", {}, "Pair Set Eta Cut Value"}

Gaudi::Property< double >	m_pairSetDeltaPhiCurvatureCut {this, "pairSetDeltaPhiCurvatureCut", {}, "Pair Set Delta Phi Curvature Cut Value"}

Gaudi::Property< double >	m_pairSetDeltaEtaCurvatureCut {this, "pairSetDeltaEtaCurvatureCut", {}, "Pair Set Delta Eta Curvature Cut Value"}

Gaudi::Property< std::vector< double > >	m_pairSetPhiExtrapCurvedCut {this, "pairSetPhiExtrapCurvedCut", {}, "Pair Set Phi Extrap Curved Cut Value(in/out pair)"}

int	m_evtsProcessed = 0

unsigned	m_nLayers = 0

std::vector< unsigned int >	m_pairingLayers

FPGATrackSimGenScanArray< BinEntry >	m_image

FPGATrackSimGenScanArray< int >	m_validBin

FPGATrackSimGenScanArray< int >	m_validSlice

FPGATrackSimGenScanArray< int >	m_validScan

FPGATrackSimGenScanArray< int >	m_validSliceAndScan

std::vector< FPGATrackSimRoad >	m_roads {}

Friends
class	FPGATrackSimGenScanMonitoring

std::ostream &	operator<< (std::ostream &os, const StoredHit &hit)

Detailed Description

Definition at line 73 of file FPGATrackSimGenScanTool.h.

Constructor & Destructor Documentation

◆ FPGATrackSimGenScanTool()

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

Definition at line 55 of file FPGATrackSimGenScanTool.cxx.

                                                                                                                        :
   base_class(algname, name, ifc)
 {
   declareInterface<IFPGATrackSimRoadFinderTool>(this);
 }

Member Function Documentation

◆ addRoad()

void FPGATrackSimGenScanTool::addRoad	(	std::vector< const StoredHit * > const &	hits,
		const FPGATrackSimGenScanBinningBase::IdxSet &	idx
	)

protected

Definition at line 702 of file FPGATrackSimGenScanTool.cxx.

 {
   layer_bitmask_t hitLayers = 0;
   std::vector<std::shared_ptr<const FPGATrackSimHit>> outhits;
   for (const FPGATrackSimGenScanTool::StoredHit* hit : hits)
   {
     hitLayers |= 1 << hit->hitptr->getLayer();
     outhits.push_back(hit->hitptr);
   }
  
   std::vector<std::vector<std::shared_ptr<const FPGATrackSimHit>>>  sorted_hits = ::sortByLayer(outhits);
   sorted_hits.resize(m_nLayers); // If no hits in last layer, return from sortByLayer will be too short
  
   m_roads.emplace_back();
   FPGATrackSimRoad &r = m_roads.back();
  
   r.setRoadID(m_roads.size() - 1);
   //    r.setPID(y * m_imageSize_y + x);
   r.setHits(std::move(sorted_hits));
   FPGATrackSimTrackPars trackpars = m_binning->parSetToTrackPars(m_binning->binCenter(idx));
   r.setX(trackpars[FPGATrackSimTrackPars::IPHI]);
   r.setY(trackpars[FPGATrackSimTrackPars::IHIP]);
   r.setXBin(idx[3]);
   r.setYBin(idx[4]);
   r.setHitLayers(hitLayers);
   r.setSubRegion(0);
 }

◆ computeValidBins()

void FPGATrackSimGenScanTool::computeValidBins ( )

protected

Definition at line 833 of file FPGATrackSimGenScanTool.cxx.

                                                {
   // determine which bins are valid
   m_validBin.setsize(m_binning->m_parBins,false);
   m_validSlice.setsize(m_binning->sliceBins(),false);
   m_validScan.setsize(m_binning->scanBins(),false);
   m_validSliceAndScan.setsize(m_binning->sliceAndScanBins(),false);
  
   FPGATrackSimTrackPars min_padded;
   FPGATrackSimTrackPars max_padded;
   FPGATrackSimTrackPars padding;
   padding[FPGATrackSimTrackPars::ID0] = m_d0FractionalPadding;
   padding[FPGATrackSimTrackPars::IZ0] = m_z0FractionalPadding;
   padding[FPGATrackSimTrackPars::IETA] = m_etaFractionalPadding;
   padding[FPGATrackSimTrackPars::IPHI] = m_phiFractionalPadding;
   padding[FPGATrackSimTrackPars::IHIP] = m_qOverPtFractionalPadding;
   for (unsigned par = 0; par < FPGATrackSimTrackPars::NPARS; par++)
   {
     min_padded[par] = m_EvtSel->getMin()[par] - padding[par] * (m_EvtSel->getMax()[par]-m_EvtSel->getMin()[par]);
     max_padded[par] = m_EvtSel->getMax()[par] + padding[par] * (m_EvtSel->getMax()[par]-m_EvtSel->getMin()[par]);
     if (par==FPGATrackSimTrackPars::IHIP) {
       // working in units of GeV internally
       min_padded[par] *= 1000;
       max_padded[par] *= 1000;
     }
     ATH_MSG_INFO("Padded Parameter Range: " << FPGATrackSimTrackPars::parName(par)
                                             << " min=" << min_padded[par] << " max=" << max_padded[par]);
   }
  
  
   for (FPGATrackSimGenScanArray<int>::Iterator bin : m_validBin) 
   {
     // this finds the parameters at all 2^5 corners of the bin and then finds the min and max of those
     std::vector<FPGATrackSimGenScanBinningBase::ParSet> parsets = m_binning->makeVariationSet(std::vector<unsigned>({0,1,2,3,4}),bin.idx());
     FPGATrackSimTrackPars minvals = m_binning->parSetToTrackPars(m_binning->binCenter(bin.idx()));
     FPGATrackSimTrackPars maxvals = m_binning->parSetToTrackPars(m_binning->binCenter(bin.idx()));
     for (FPGATrackSimGenScanBinningBase::ParSet & parset : parsets) {
       FPGATrackSimTrackPars trackpars = m_binning->parSetToTrackPars(parset);
       for (unsigned par =0; par < FPGATrackSimTrackPars::NPARS; par++) {
         minvals[par] = std::min(minvals[par],trackpars[par]);
         maxvals[par] = std::max(maxvals[par],trackpars[par]);
       }
     }
  
     // make sure bin overlaps with active region
     bool inRange = true;
     for (unsigned par =0; par < FPGATrackSimTrackPars::NPARS; par++) {
       inRange = inRange && (minvals[par] < max_padded[par]) && (maxvals[par] > min_padded[par]);
     }
     if (inRange)
     {
       bin.data() = true;
       m_validSlice[m_binning->sliceIdx(bin.idx())] = true;
       m_validScan[m_binning->scanIdx(bin.idx())] = true;
       m_validSliceAndScan[m_binning->sliceAndScanIdx(bin.idx())] = true;
     }
  
     if (bin.data() == false)
     {
       ATH_MSG_VERBOSE("Invalid bin: " << bin.idx() << " :" << m_binning->parSetToTrackPars(m_binning->binCenter(bin.idx()))
       << " minvals: " << minvals << " maxvals: " << maxvals );
     }
   }
  
   // count valid bins
   int validBins = 0;
   for (FPGATrackSimGenScanArray<int>::Iterator bin : m_validBin) { if(bin.data()) validBins++;}
  
   int validSlices = 0;
   for (FPGATrackSimGenScanArray<int>::Iterator bin : m_validSlice) { if(bin.data()) validSlices++;}
  
   int validScans = 0;
   for (FPGATrackSimGenScanArray<int>::Iterator bin : m_validScan) { if(bin.data()) validScans++;}
  
   ATH_MSG_INFO("Valid Bins: " << validBins
                               << " valid slices: " << validSlices
                               << " valid scans: " << validScans);
 }

◆ fillImage()

StatusCode FPGATrackSimGenScanTool::fillImage ( const std::vector< std::shared_ptr< const FPGATrackSimHit >> & hits )

protected

Definition at line 242 of file FPGATrackSimGenScanTool.cxx.

 {
   ATH_MSG_DEBUG("In fillImage");
   
   for (const std::shared_ptr<const FPGATrackSimHit>& hit : hits)
   {
     m_monitoring->fillHitLevelInput(hit.get());
  
     // The following code loops sequentially of the slice, then scan, then row parameters
     // skipping invalid slices/scans/row/bins and adding hits if the hits are in the bin
     // according to the m_binning class
  
     // this will contain current bin idx as it is built from slices and scans
     FPGATrackSimGenScanBinningBase::IdxSet idx;    
  
     // iterate over slices
     for (FPGATrackSimGenScanArray<int>::Iterator slicebin : m_validSlice)
     {
       // if slice is not valid continue
       if (!slicebin.data()) continue; 
  
       // set the slice bins in the current bin idx object
       ATH_CHECK(m_binning->setIdxSubVec(idx, m_binning->slicePars(), slicebin.idx()));
  
       // if hit is not in slice skip slice (continue)
       if (!m_binning->hitInSlice(idx, hit.get()))
       {
         m_monitoring->sliceCheck(slicebin.idx());
         continue;
       }
  
       m_monitoring->incrementInputPerSlice(slicebin.idx());
  
       // iterate over scan bins
       for (FPGATrackSimGenScanArray<int>::Iterator scanbin : m_validScan) {
  
         // if scan bin is not valid continue
         if (!scanbin.data()) continue; // scan bin not valid
  
         // set the scan bins in the current bin idx object
         ATH_CHECK(m_binning->setIdxSubVec(idx, m_binning->scanPars(), scanbin.idx()));
  
         // Find the min/max bins for hit in the row
         std::pair<unsigned, unsigned> rowRange = m_binning->idxsetToRowParBinRange(idx, hit.get());
  
         // put hit in row bins according to row range
         for (unsigned rowbin = rowRange.first; rowbin < rowRange.second; rowbin++)
         {
           idx[m_binning->rowParIdx()] = rowbin;
     
           // if full bin is not valid continue
           if (!m_validBin[idx]) continue;
           
           // make a stored hit and fill it with the eta/phishifts as
           // speficied by the Binning class
           StoredHit s_hit; 
           s_hit.hitptr = hit;
           s_hit.layer = hit->getLayer(); 
           s_hit.phiShift = m_binning->phiShift(idx, hit.get());
           s_hit.etaShift = m_binning->etaShift(idx, hit.get());
           
           // add hit to the BinEntry for the bin
           m_image[idx].addHit(s_hit);
         }
       }
     }
   }
  
   m_monitoring->fillInputSummary(hits, m_validSlice, m_validSliceAndScan);
  
   return StatusCode::SUCCESS;
 }

◆ filterPairs()

StatusCode FPGATrackSimGenScanTool::filterPairs	(	HitPairSet &	pairs,
		HitPairSet &	filteredpairs
	)

protected

Definition at line 553 of file FPGATrackSimGenScanTool.cxx.

 {
   ATH_MSG_VERBOSE("In filterPairs");
  
   for (const FPGATrackSimGenScanTool::HitPair &pair : pairs.pairList) {
     if (pairPassesFilter(pair)) {
       filteredpairs.addPair(pair);
     }
   }
   return StatusCode::SUCCESS;
 }

◆ getRoads()

StatusCode FPGATrackSimGenScanTool::getRoads	(	const std::vector< std::shared_ptr< const FPGATrackSimHit >> &	hits,
		std::vector< std::shared_ptr< const FPGATrackSimRoad >> &	road
	)

overridevirtual

Definition at line 172 of file FPGATrackSimGenScanTool.cxx.

 {
   ATH_MSG_DEBUG("In getRoads, Processing Event# " << ++m_evtsProcessed << " hit size = " << hits.size());
  
   roads.clear();
   m_roads.clear();
   m_monitoring->resetDataFlowCounters();
   
   // Currently assume that if less than 100 hits its a single track MC
   m_monitoring->parseTruthInfo(getTruthTracks(),(hits.size() < 100),m_validBin);
   
   // do the binning...
   ATH_CHECK(fillImage(hits));
  
   // scan over image building pairs for bins over threshold
   for (FPGATrackSimGenScanArray<BinEntry>::Iterator &bin : m_image)
   {
     // apply threshold
     if (bin.data().lyrCnt() < m_threshold) continue;
     ATH_MSG_DEBUG("newRoad " << bin.data().lyrCnt() << " " << bin.idx());
  
     // pass hits for bin to filterRoad and get back pairs of hits grouped into pairsets
     std::vector<HitPairSet> pairsets;
     if (m_binFilter=="PairThenGroup") {
       ATH_CHECK(pairThenGroupFilter(bin.data(), bin.idx(), pairsets));
     } else if (m_binFilter=="IncrementalBuild") {
       ATH_CHECK(incrementalBuildFilter(bin.data(), bin.idx(), pairsets));
     } else {
       ATH_MSG_FATAL("Unknown bin filter" << m_binFilter);
     }
     ATH_MSG_DEBUG("grouped PairSets " << pairsets.size());
  
     // convert the group pairsets to FPGATrackSimRoads
     for (const FPGATrackSimGenScanTool::HitPairSet& pairset: pairsets)
       {      
         addRoad(pairset.hitlist, bin.idx());
  
         // debug statement if more than one road found in bin
         // not necessarily a problem
         if (pairsets.size() >1) {
           std::string s = "";
           for (const FPGATrackSimGenScanTool::StoredHit* const hit : pairset.hitlist)
           {
             s += "(" + std::to_string(hit->hitptr->getLayer()) + "," + std::to_string(hit->hitptr->getR()) + "), ";
           }        
           ATH_MSG_DEBUG("Duplicate Group " << s);
         }
       }  
   }
  
   // copy roads to output vector
   roads.reserve(m_roads.size());  
   for (FPGATrackSimRoad & r : m_roads) roads.emplace_back(std::make_shared<const FPGATrackSimRoad>(r));
   ATH_MSG_DEBUG("Roads = " << roads.size());
   m_monitoring->fillOutputSummary(m_validSlice, m_validSliceAndScan);
  
   // clear previous event 
   // (reusing saves having to reallocate memory for each event)
   for (FPGATrackSimGenScanArray<BinEntry>::Iterator& bin : m_image)
   {
     bin.data().reset();
   }
  
   m_evtsProcessed++;
   return StatusCode::SUCCESS;
 }

◆ getSubRegion()

virtual int FPGATrackSimGenScanTool::getSubRegion ( ) const

inlineoverridevirtual

Definition at line 87 of file FPGATrackSimGenScanTool.h.

87 {return 0;}

◆ groupPairs()

StatusCode FPGATrackSimGenScanTool::groupPairs	(	HitPairSet &	filteredpairs,
		std::vector< HitPairSet > &	clusters,
		bool	verbose
	)

protected

Definition at line 567 of file FPGATrackSimGenScanTool.cxx.

 {
   ATH_MSG_VERBOSE("In groupPairs");
   for (const FPGATrackSimGenScanTool::HitPair & pair : filteredpairs.pairList)
   {
     bool added = false;
     for (FPGATrackSimGenScanTool::HitPairSet &pairset : pairsets)
     {      
       // Only add skip pairs if skipped layer is not already hit
       if ((std::abs(pair.second->layer - pair.first->layer) > 1) // gives if is a skip pair
           && (pairset.hasLayer(std::min(pair.first->layer,pair.second->layer) + 1))) // gives true if skipped layer already in set
       {
         // if it matches mark as added so it doesn't start a new pairset
         // false here is so it doesn't plot these either
         if (pairMatchesPairSet(pairset, pair, verbose))
           added = true;
         if (!added) {
           ATH_MSG_VERBOSE("Skip pair does not match non-skip pair");
         }
       }
       else
       {
         if (pairMatchesPairSet(pairset, pair, verbose))
         {
           int size = pairset.addPair(pair);
           if (verbose)
             ATH_MSG_VERBOSE("addPair " << pairsets.size() << " " << pairset.pairList.size() << " " << size);
           added = true;
         }
       }      
  
     }
  
     if (!added)
     {
       HitPairSet newpairset;
       newpairset.addPair(pair);
       pairsets.push_back(newpairset);
     }
   }
   
   return StatusCode::SUCCESS;
  
 }

◆ incrementalBuildFilter()

StatusCode FPGATrackSimGenScanTool::incrementalBuildFilter	(	const BinEntry &	bindata,
		const FPGATrackSimGenScanBinningBase::IdxSet &	bin,
		std::vector< HitPairSet > &	output_pairset
	)

protected

Definition at line 459 of file FPGATrackSimGenScanTool.cxx.

 {
   ATH_MSG_VERBOSE("In buildGroupsWithPairs");
  
   // Organize Hits by Layer
   std::vector<std::vector<const StoredHit *>> hitsByLayer(m_nLayers);
   ATH_CHECK(sortHitsByLayer(bindata, hitsByLayer));
   
   // This is monitoring for each bin over threshold
   // It's here so it can get the hitsByLayer
   m_monitoring->fillBinLevelOutput(idx, bindata, hitsByLayer);
  
   std::vector<IntermediateState> states{m_nLayers+1};
   for (unsigned lyridx = 0; lyridx < m_nLayers; lyridx++) {
     unsigned lyr = m_pairingLayers[lyridx];
     updateState(states[lyridx] , states[lyridx+1], lyridx, hitsByLayer[lyr]);
   }
  
   // this is a little ugly because it requires copying the output pairsets right now
   output_pairsets=states[m_nLayers].pairsets;
  
   m_monitoring->fillBuildGroupsWithPairs(states,m_nLayers-m_threshold);
   
   return StatusCode::SUCCESS;
 }

◆ initialize()

StatusCode FPGATrackSimGenScanTool::initialize ( )

overridevirtual

Definition at line 62 of file FPGATrackSimGenScanTool.cxx.

 {
   // Dump the configuration to make sure it propagated through right
   const std::vector<Gaudi::Details::PropertyBase*> 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());
     }
   }
  
   // Retrieve info
   ATH_CHECK(m_FPGATrackSimBankSvc.retrieve());
   ATH_CHECK(m_FPGATrackSimMapping.retrieve());
   ATH_MSG_INFO("Map specifies :" << m_nLayers);
   ATH_CHECK(m_monitoring.retrieve());
   ATH_MSG_INFO("Monitoring Dir :" << m_monitoring->dir());
   ATH_CHECK(m_binning.retrieve());
  
   // Setup layer configuration
   m_nLayers = m_FPGATrackSimMapping->PlaneMap_1st(getSubRegion())->getNLogiLayers();
  
   // This is the layers they get paired with previous layers
   for (unsigned lyr = 0; lyr < m_nLayers; ++lyr) m_pairingLayers.push_back(lyr);
   if (m_reversePairDir) {
     std::reverse(m_pairingLayers.begin(),m_pairingLayers.end());
   }
   ATH_MSG_INFO("Pairing Layers: " << m_pairingLayers);
   
   // Check inputs
   bool ok = false;
   if (m_pairFilterDeltaPhiCut.size() != m_nLayers - 1)
     ATH_MSG_FATAL("initialize() pairFilterDeltaPhiCut must have size nLayers-1=" << m_nLayers - 1 << " found " << m_pairFilterDeltaPhiCut.size());
   else if (m_pairFilterDeltaEtaCut.size() != m_nLayers - 1)
     ATH_MSG_FATAL("initialize() pairFilterDeltaEtaCut must have size nLayers-1=" << m_nLayers - 1 << " found " << m_pairFilterDeltaEtaCut.size());
   else if (m_pairFilterPhiExtrapCut.size() != 2)
     ATH_MSG_FATAL("initialize() pairFilterPhiExtrapCut must have size 2 found " << m_pairFilterPhiExtrapCut.size());
   else if (m_pairFilterEtaExtrapCut.size() != 2)
     ATH_MSG_FATAL("initialize() pairFilterEtaExtrapCut must have size 2 found " << m_pairFilterEtaExtrapCut.size());
   else if (m_pairSetPhiExtrapCurvedCut.size() != 2)
     ATH_MSG_FATAL("initialize() PairSetPhiExtrapCurvedCut must have size 2found " << m_pairSetPhiExtrapCurvedCut.size());
   else if ((m_rin < 0.0) || (m_rout < 0.0))
     ATH_MSG_FATAL("Radii not set");
   else
     ok = true;
   if (!ok)
     return StatusCode::FAILURE;
  
  
   // Dump Binning
   for (unsigned par : m_binning->slicePars()) { ATH_MSG_INFO("Slice Par: " << m_binning->parNames(par)); }
   for (unsigned par : m_binning->scanPars()) { ATH_MSG_INFO("Scan Par: " << m_binning->parNames(par)); }
   ATH_MSG_INFO("Row Par: " << m_binning->parNames(m_binning->rowParIdx()));
  
   // Configure Binning
   for (unsigned par = 0; par < FPGATrackSimGenScanBinningBase::NPars; par++)
   {    
     m_binning->m_parMin[par] = m_parMin[par];
     m_binning->m_parMax[par] = m_parMax[par];
     m_binning->m_parBins[par] = m_parBins[par];
     if (m_parBins[par] <= 0)
     {
       ATH_MSG_FATAL("Every dimension must be at least one bin");
       return StatusCode::FAILURE;
     }
     m_binning->m_parStep[par] = (m_parMax[par] - m_parMin[par]) / m_parBins[par];
   }
  
   // Build Image
   m_image.setsize(m_binning->m_parBins, BinEntry());
   ATH_MSG_INFO("Final Image Size: " << m_image.size());
   // make sure image is starts reset
   // (reusing saves having to reallocate memory for each event)
   for (FPGATrackSimGenScanArray<BinEntry>::Iterator bin : m_image)
   {
     bin.data().reset();
   }
  
   // Compute which bins correspond to track parameters that are in the region
   // i.e. the pT, eta, phi, z0 and d0 bounds
   computeValidBins();
  
   // register histograms
   ATH_CHECK(m_monitoring->registerHistograms(m_nLayers, m_binning.get(), m_rin, m_rout));
  
   return StatusCode::SUCCESS;
 }

◆ makePairs()

StatusCode FPGATrackSimGenScanTool::makePairs	(	const std::vector< std::vector< const StoredHit * >> &	hitsByLayer,
		HitPairSet &	pairs
	)

protected

Definition at line 507 of file FPGATrackSimGenScanTool.cxx.

 {
   ATH_MSG_VERBOSE("In makePairs");
  
   std::vector<const FPGATrackSimGenScanTool::StoredHit *> const *  lastlyr = 0;
   std::vector<const FPGATrackSimGenScanTool::StoredHit *> const *  lastlastlyr = 0;
  
   // order here is designed so lower radius hits come first
   for (unsigned lyr : m_pairingLayers) {
     for (const FPGATrackSimGenScanTool::StoredHit *const &ptr1 :
          hitsByLayer[lyr]) {
       if (lastlyr) {
         for (const FPGATrackSimGenScanTool::StoredHit *const &ptr2 : *lastlyr) {
           pairs.addPair(HitPair(ptr2, ptr1,m_reversePairDir));
         }
         // Add Pairs that skip one layer
         if (lastlastlyr) {
           for (const FPGATrackSimGenScanTool::StoredHit *const &ptr2 : *lastlastlyr) {
             pairs.addPair(HitPair(ptr2, ptr1,m_reversePairDir));
           }
         }
       }
     }
     lastlastlyr = lastlyr;
     lastlyr = &hitsByLayer[lyr];    
     m_monitoring->fillPairingHits(lastlyr,lastlastlyr);
   }
  
   return StatusCode::SUCCESS;
 }

◆ pairMatchesPairSet()

bool FPGATrackSimGenScanTool::pairMatchesPairSet	(	const HitPairSet &	pairset,
		const HitPair &	pair,
		bool	verbose
	)

protected

Definition at line 615 of file FPGATrackSimGenScanTool.cxx.

                                                                {
   // In order to make it easy to have a long list of possible cuts,
   // a vector of cutvar structs is used to represent each cut
   // then apply the AND of all the cuts is done with a std::count_if function
  
   // define the struct (effectively mapping because variable, configured cut value, 
   // and histograms for plotting
   struct cutvar {
     cutvar(std::string name, double val, double cut, std::vector<TH1D *>& histset) :
        m_name(std::move(name)), m_val(val), m_cut(cut), m_histset(histset) {}
     bool passed() { return std::abs(m_val) < m_cut; }
     void fill(unsigned cat) {  m_histset[cat]->Fill(m_val); }
     std::string m_name;
     double m_val;
     double m_cut;
     std::vector<TH1D *> &m_histset;
   };
  
   // add the cuts to the list of all cuts
   std::vector<cutvar> allcuts;
   allcuts.push_back(cutvar("MatchPhi", pairset.MatchPhi(pair),
                            m_pairSetMatchPhiCut,
                            m_monitoring->m_pairSetMatchPhi));
   allcuts.push_back(cutvar("MatchEta", pairset.MatchEta(pair),
                            m_pairSetMatchEtaCut,
                            m_monitoring->m_pairSetMatchEta));
   allcuts.push_back(cutvar("DeltaDeltaPhi", pairset.DeltaDeltaPhi(pair),
                            m_pairSetDeltaDeltaPhiCut,
                            m_monitoring->m_deltaDeltaPhi));
   allcuts.push_back(cutvar("DeltaDeltaEta", pairset.DeltaDeltaEta(pair),
                            m_pairSetDeltaDeltaEtaCut,
                            m_monitoring->m_deltaDeltaEta));
   allcuts.push_back(cutvar("PhiCurvature", pairset.PhiCurvature(pair),
                            m_pairSetPhiCurvatureCut,
                            m_monitoring->m_phiCurvature));
   allcuts.push_back(cutvar("EtaCurvature", pairset.EtaCurvature(pair),
                            m_pairSetEtaCurvatureCut,
                            m_monitoring->m_etaCurvature));
   if (pairset.pairList.size() > 1) {
     allcuts.push_back(cutvar(
         "DeltaPhiCurvature", pairset.DeltaPhiCurvature(pair),
         m_pairSetDeltaPhiCurvatureCut, m_monitoring->m_deltaPhiCurvature));
     allcuts.push_back(cutvar(
         "DeltaEtaCurvature", pairset.DeltaEtaCurvature(pair),
         m_pairSetDeltaEtaCurvatureCut, m_monitoring->m_deltaEtaCurvature));
   }
   allcuts.push_back(cutvar(
       "PhiInExtrapCurved", pairset.PhiInExtrapCurved(pair, m_rin),
       m_pairSetPhiExtrapCurvedCut[0], m_monitoring->m_phiInExtrapCurved));
   allcuts.push_back(cutvar(
       "PhiOutExtrapCurved", pairset.PhiOutExtrapCurved(pair, m_rout),
       m_pairSetPhiExtrapCurvedCut[1], m_monitoring->m_phiOutExtrapCurved));
  
   // count number of cuts passed
   unsigned passedCuts = std::count_if(allcuts.begin(), allcuts.end(),
                                       [](cutvar& cut) { return cut.passed(); });
   bool passedAll = (passedCuts == allcuts.size());
  
   // monitoring
   bool passedAllButOne = (passedCuts == allcuts.size() - 1);
   for (cutvar& cut: allcuts) {
     // the last value computes if an n-1 histogram should be filled
     m_monitoring->fillPairSetFilterCut(cut.m_histset, cut.m_val, pair,
                                         pairset.lastpair(),
                                         (passedAll || (passedAllButOne && !cut.passed())));
   }
  
   if (verbose)
   {
     std::string s = "";
     for (cutvar &cut : allcuts)
     {
       s += cut.m_name + " : (" + cut.passed() + ", " + cut.m_val + "),  ";
     }
     ATH_MSG_DEBUG("PairSet test " << passedAll << " " << s);
     ATH_MSG_DEBUG("Hits: \n   " << *pairset.lastpair().first << "\n   "
                                << *pairset.lastpair().second << "\n   "
                                << *pair.first << "\n   "
                                << *pair.second);
   }
  
   return passedAll;
 }

◆ pairPassesFilter()

bool FPGATrackSimGenScanTool::pairPassesFilter ( const HitPair & pair )

protected

Definition at line 542 of file FPGATrackSimGenScanTool.cxx.

                                                                   {
   m_monitoring->fillPairFilterCuts(pair);
   int lyr = std::min(pair.first->hitptr->getLayer(),pair.second->hitptr->getLayer());
   return (std::abs(pair.dPhi()) < m_pairFilterDeltaPhiCut[lyr]) &&
         (std::abs(pair.dEta()) < m_pairFilterDeltaEtaCut[lyr]) &&
         (std::abs(pair.PhiInExtrap(m_rin)) < m_pairFilterPhiExtrapCut[0]) &&
         (std::abs(pair.PhiOutExtrap(m_rout)) < m_pairFilterPhiExtrapCut[1]) &&
         (std::abs(pair.EtaInExtrap(m_rin)) < m_pairFilterEtaExtrapCut[0]) &&
         (std::abs(pair.EtaOutExtrap(m_rout)) < m_pairFilterEtaExtrapCut[1]);
 }

◆ pairThenGroupFilter()

StatusCode FPGATrackSimGenScanTool::pairThenGroupFilter	(	const BinEntry &	bindata,
		const FPGATrackSimGenScanBinningBase::IdxSet &	bin,
		std::vector< HitPairSet > &	output_pairset
	)

protected

Definition at line 316 of file FPGATrackSimGenScanTool.cxx.

 {
   ATH_MSG_VERBOSE("In pairThenGroupFilter");
  
   // Organize Hits by Layer
   std::vector<std::vector<const StoredHit *>> hitsByLayer(m_nLayers);
   ATH_CHECK(sortHitsByLayer(bindata, hitsByLayer));
   
   // This is monitoring for each bin over threshold
   // It's here so it can get the hitsByLayer
   m_monitoring->fillBinLevelOutput(idx, bindata, hitsByLayer);
  
   // Make Pairs
   HitPairSet pairs;
   ATH_CHECK(makePairs(hitsByLayer, pairs));
   
   // Filter Pairs
   HitPairSet filteredpairs;
   ATH_CHECK(filterPairs(pairs, filteredpairs));
  
   // Require road is still over threshold
   bool passedPairFilter = (filteredpairs.lyrCnt() >= m_threshold);
   m_monitoring->pairFilterCheck(pairs, filteredpairs, passedPairFilter);
  
   // if passed Pair Filter proceed to group the filtered pairs into pairsets
   if (passedPairFilter)
   {
     // Pair Set Grouping
     std::vector<HitPairSet> pairsets;
     ATH_CHECK(groupPairs(filteredpairs, pairsets, false));
  
     // loop over pairsets and find those that are over thresold
     for (const FPGATrackSimGenScanTool::HitPairSet& pairset : pairsets)
     {
       // if over threshold add it to the output
       if (pairset.lyrCnt() >= m_threshold)
       {
         if (m_applyPairSetFilter) {
           output_pairsets.push_back(pairset);
         }
       }
     }
   }
  
   // set outputs if not all filters applied
   if (!m_applyPairFilter) {
     // output is just the filtered pairs
     output_pairsets.push_back(pairs);
   }
   else if (passedPairFilter && !m_applyPairSetFilter)
   {
     // output is just the filtered pairs
     output_pairsets.push_back(filteredpairs);
   }
  
   return StatusCode::SUCCESS;
 }

◆ sortHitsByLayer()

StatusCode FPGATrackSimGenScanTool::sortHitsByLayer	(	const BinEntry &	bindata,
		std::vector< std::vector< const StoredHit * >> &	hitsByLayer
	)

protected

Definition at line 489 of file FPGATrackSimGenScanTool.cxx.

 {
   ATH_MSG_VERBOSE("In fillHitsByLayer");
  
   for (const FPGATrackSimGenScanTool::StoredHit& hit : bindata.hits)
   {
     hitsByLayer[hit.hitptr->getLayer()].push_back(&hit);    
   }
  
   return StatusCode::SUCCESS;
 }

◆ updateState()

void FPGATrackSimGenScanTool::updateState	(	const IntermediateState &	inputstate,
		IntermediateState &	outputstate,
		unsigned	lyridx,
		const std::vector< const StoredHit * > &	newhits
	)

protected

Definition at line 378 of file FPGATrackSimGenScanTool.cxx.

 {
   unsigned int allowed_missed_hits = m_nLayers - m_threshold;
  
   std::vector<bool> pairset_used(inputstate.pairsets.size(),false);
   
   for (auto &newhit : newhits) {
  
     // don't make new pairs with hits that the new hit is already paired with in a group
     std::set<const StoredHit *> vetoList;
  
     // try adding hit to existing pair sets
     for (auto &pairset : inputstate.pairsets) {
       HitPair nextpair(pairset.lastpair().second, newhit, m_reversePairDir);
       if (pairMatchesPairSet(pairset, nextpair, false)) {
         HitPairSet newset(pairset);
         newset.addPair(nextpair);
         outputstate.pairsets.push_back(newset);
         // put inpair hits in list of hits not to pair again with the new hits
         for (auto vetohit : pairset.hitlist) {
           vetoList.insert(vetohit);
         }
       }
     }
  
     // make new pairsets with unpaired hits
     for (auto prevhit : inputstate.unpairedHits) {
       if (vetoList.count(prevhit) == 0) {
         HitPair newpair(prevhit, newhit, m_reversePairDir);
         if (pairPassesFilter(newpair)) {
           HitPairSet newset;
           newset.addPair(newpair);
           outputstate.pairsets.push_back(newset);
         }
       }
     }
  
     // if this can be the start of a the start of a track  and still
     // have enough hits to make a track, add it to the unpaired hits list
     if (lyridx <= allowed_missed_hits) {
       outputstate.unpairedHits.push_back(newhit);
     }
   }
  
   // Add groups to output without new hit if they have enough hits to skip
   // this layer. Note expected hits at this point is lyridx+1, since we start
   // counting lyridx from zero. Logic is then keep the pairset if
   // expected hits <= hits in set + allows misses
   for (auto &pairset : inputstate.pairsets) {
     if (lyridx < (pairset.hitlist.size() + allowed_missed_hits)) {
       outputstate.pairsets.push_back(pairset);
     }
   }
  
   // Add hits to unpaired list if hits are still allowed to start a track
   // ---------------------------------------------------------------------
   // If you start a new track with a pair whose second element is
   // layer N (layer numbering starting from zero), then you'll have missed N-1
   // layers Minus 1 because the first hit was one of the N layers already
   // passed.
   //
   // The next pass will be layer N=lyridx+1 where lyridx is the current value
   // at this point in the code. You will have then missed lyridx layers, so...
   // E.g. if you allow one missed layer then this stops putting hits in the
   // unpairedHits list if lyridx>1, so tracks must start with layer 0 or 1,
   // which makes sense
   if (lyridx > allowed_missed_hits) {
     // make no new track starts
     outputstate.unpairedHits.clear();
   } else {
     // copy in any previous unpairedHits as well
     for (auto prevhit : inputstate.unpairedHits) {
       outputstate.unpairedHits.push_back(prevhit);
     }
   }
 }

Friends And Related Function Documentation

◆ FPGATrackSimGenScanMonitoring

friend class FPGATrackSimGenScanMonitoring

friend

Definition at line 89 of file FPGATrackSimGenScanTool.h.

◆ operator<<

std::ostream& operator<<	(	std::ostream &	os,
		const StoredHit &	hit
	)

friend

Definition at line 43 of file FPGATrackSimGenScanTool.cxx.

 {
   os << "lyr: " << hit.layer << " ";
   os << "(" << hit.hitptr->getR() << ", " << hit.hitptr->getGPhi() << ", " << hit.hitptr->getZ() << ") ";
   os << "[" << hit.phiShift << ", " << hit.etaShift << "]";
   return os;
 }

Member Data Documentation

◆ m_applyPairFilter

Gaudi::Property<bool> FPGATrackSimGenScanTool::m_applyPairFilter {this, "applyPairFilter", {}, "Apply Pair Filter"}

protected

Definition at line 121 of file FPGATrackSimGenScanTool.h.

◆ m_applyPairSetFilter

Gaudi::Property<bool> FPGATrackSimGenScanTool::m_applyPairSetFilter {this, "applyPairSetFilter", {}, "Apply PairSet Filter"}

protected

Definition at line 128 of file FPGATrackSimGenScanTool.h.

◆ m_binFilter

Gaudi::Property<std::string> FPGATrackSimGenScanTool::m_binFilter {this, "binFilter", {"PairThenGroup"}, "which bin filter to run, current options: PairThenGroup, IncrementalBuild"}

protected

Definition at line 119 of file FPGATrackSimGenScanTool.h.

◆ m_binning

ToolHandle<FPGATrackSimGenScanBinningBase> FPGATrackSimGenScanTool::m_binning {this, "Binning", "FPGATrackSimGenScanBinningBase", "Gen Scan Binning Tool"}

protected

Definition at line 99 of file FPGATrackSimGenScanTool.h.

◆ m_d0FractionalPadding

Gaudi::Property<double> FPGATrackSimGenScanTool::m_d0FractionalPadding {this, "d0FractionalPadding", {}, "Fractional padding used when calculating the valid range of bins"}

protected

Definition at line 111 of file FPGATrackSimGenScanTool.h.

◆ m_etaFractionalPadding

Gaudi::Property<double> FPGATrackSimGenScanTool::m_etaFractionalPadding {this, "etaFractionalPadding", {}, "Fractional padding used when calculating the valid range of bins"}

protected

Definition at line 113 of file FPGATrackSimGenScanTool.h.

◆ m_EvtSel

ServiceHandle<IFPGATrackSimEventSelectionSvc> FPGATrackSimGenScanTool::m_EvtSel {this, "FPGATrackSimEventSelectionSvc", "FPGATrackSimEventSelectionSvc"}

protected

Definition at line 95 of file FPGATrackSimGenScanTool.h.

◆ m_evtsProcessed

int FPGATrackSimGenScanTool::m_evtsProcessed = 0

protected

Definition at line 306 of file FPGATrackSimGenScanTool.h.

◆ m_FPGATrackSimBankSvc

ServiceHandle<IFPGATrackSimBankSvc> FPGATrackSimGenScanTool::m_FPGATrackSimBankSvc {this, "FPGATrackSimBankSvc", "FPGATrackSimBankSvc"}

protected

Definition at line 96 of file FPGATrackSimGenScanTool.h.

◆ m_FPGATrackSimMapping

ServiceHandle<IFPGATrackSimMappingSvc> FPGATrackSimGenScanTool::m_FPGATrackSimMapping {this, "FPGATrackSimMappingSvc", "FPGATrackSimMappingSvc"}

protected

Definition at line 97 of file FPGATrackSimGenScanTool.h.

◆ m_image

FPGATrackSimGenScanArray<BinEntry> FPGATrackSimGenScanTool::m_image

protected

Definition at line 314 of file FPGATrackSimGenScanTool.h.

◆ m_monitoring

ToolHandle<FPGATrackSimGenScanMonitoring> FPGATrackSimGenScanTool::m_monitoring {this, "Monitoring", "FPGATrackSimGenScanMonitoring", "Monitoring Tool"}

protected

Definition at line 98 of file FPGATrackSimGenScanTool.h.

◆ m_nLayers

unsigned FPGATrackSimGenScanTool::m_nLayers = 0

protected

Definition at line 307 of file FPGATrackSimGenScanTool.h.

◆ m_pairFilterDeltaEtaCut

Gaudi::Property<std::vector<double> > FPGATrackSimGenScanTool::m_pairFilterDeltaEtaCut {this, "pairFilterDeltaEtaCut", {}, "Pair Filter Delta Eta Cut Value (list one per layer)"}

protected

Definition at line 124 of file FPGATrackSimGenScanTool.h.

◆ m_pairFilterDeltaPhiCut

Gaudi::Property<std::vector<double> > FPGATrackSimGenScanTool::m_pairFilterDeltaPhiCut {this, "pairFilterDeltaPhiCut", {}, "Pair Filter Delta Phi Cut Value (list one per layer)"}

protected

Definition at line 123 of file FPGATrackSimGenScanTool.h.

◆ m_pairFilterEtaExtrapCut

Gaudi::Property<std::vector<double> > FPGATrackSimGenScanTool::m_pairFilterEtaExtrapCut {this, "pairFilterEtaExtrapCut", {}, "Pair Filter Eta Extrap Cut Value(in/out pair)"}

protected

Definition at line 126 of file FPGATrackSimGenScanTool.h.

◆ m_pairFilterPhiExtrapCut

Gaudi::Property<std::vector<double> > FPGATrackSimGenScanTool::m_pairFilterPhiExtrapCut {this, "pairFilterPhiExtrapCut", {}, "Pair Filter Phi Extrap Cut Value (in/out pair)"}

protected

Definition at line 125 of file FPGATrackSimGenScanTool.h.

◆ m_pairingLayers

std::vector<unsigned int> FPGATrackSimGenScanTool::m_pairingLayers

protected

Definition at line 308 of file FPGATrackSimGenScanTool.h.

◆ m_pairSetDeltaDeltaEtaCut

Gaudi::Property<double> FPGATrackSimGenScanTool::m_pairSetDeltaDeltaEtaCut {this, "pairSetDeltaDeltaEtaCut", {}, "Pair Set Delta Eta Cut Value"}

protected

Definition at line 132 of file FPGATrackSimGenScanTool.h.

◆ m_pairSetDeltaDeltaPhiCut

Gaudi::Property<double> FPGATrackSimGenScanTool::m_pairSetDeltaDeltaPhiCut {this, "pairSetDeltaDeltaPhiCut", {}, "Pair Set Delta Delta Phi Cut Value"}

protected

Definition at line 131 of file FPGATrackSimGenScanTool.h.

◆ m_pairSetDeltaEtaCurvatureCut

Gaudi::Property<double> FPGATrackSimGenScanTool::m_pairSetDeltaEtaCurvatureCut {this, "pairSetDeltaEtaCurvatureCut", {}, "Pair Set Delta Eta Curvature Cut Value"}

protected

Definition at line 136 of file FPGATrackSimGenScanTool.h.

◆ m_pairSetDeltaPhiCurvatureCut

Gaudi::Property<double> FPGATrackSimGenScanTool::m_pairSetDeltaPhiCurvatureCut {this, "pairSetDeltaPhiCurvatureCut", {}, "Pair Set Delta Phi Curvature Cut Value"}

protected

Definition at line 135 of file FPGATrackSimGenScanTool.h.

◆ m_pairSetEtaCurvatureCut

Gaudi::Property<double> FPGATrackSimGenScanTool::m_pairSetEtaCurvatureCut {this, "pairSetEtaCurvatureCut", {}, "Pair Set Eta Cut Value"}

protected

Definition at line 134 of file FPGATrackSimGenScanTool.h.

◆ m_pairSetMatchEtaCut

Gaudi::Property<double> FPGATrackSimGenScanTool::m_pairSetMatchEtaCut {this, "pairSetMatchEtaCut", {}, "Pair Set Match Eta Cut Value"}

protected

Definition at line 130 of file FPGATrackSimGenScanTool.h.

◆ m_pairSetMatchPhiCut

Gaudi::Property<double> FPGATrackSimGenScanTool::m_pairSetMatchPhiCut {this, "pairSetMatchPhiCut", {}, "Pair Set Match Phi Cut Value"}

protected

Definition at line 129 of file FPGATrackSimGenScanTool.h.

◆ m_pairSetPhiCurvatureCut

Gaudi::Property<double> FPGATrackSimGenScanTool::m_pairSetPhiCurvatureCut {this, "pairSetPhiCurvatureCut", {}, "Pair Set Phi Cut Value"}

protected

Definition at line 133 of file FPGATrackSimGenScanTool.h.

◆ m_pairSetPhiExtrapCurvedCut

Gaudi::Property<std::vector<double> > FPGATrackSimGenScanTool::m_pairSetPhiExtrapCurvedCut {this, "pairSetPhiExtrapCurvedCut", {}, "Pair Set Phi Extrap Curved Cut Value(in/out pair)"}

protected

Definition at line 137 of file FPGATrackSimGenScanTool.h.

◆ m_parBins

Gaudi::Property<std::vector<unsigned> > FPGATrackSimGenScanTool::m_parBins {this, "parBins", {}, "Vector of number of bins for each parameter (expect 5)"}

protected

Definition at line 106 of file FPGATrackSimGenScanTool.h.

◆ m_parMax

Gaudi::Property<std::vector<float> > FPGATrackSimGenScanTool::m_parMax {this, "parMax", {}, "Vector of maximum bounds of parameters (expect 5"}

protected

Definition at line 105 of file FPGATrackSimGenScanTool.h.

◆ m_parMin

Gaudi::Property<std::vector<float> > FPGATrackSimGenScanTool::m_parMin {this, "parMin", {}, "Vector of minimum bounds of parameters (expect 5"}

protected

Definition at line 104 of file FPGATrackSimGenScanTool.h.

◆ m_parSet

Gaudi::Property<std::string> FPGATrackSimGenScanTool::m_parSet {this, "parSet", {}, "String name of parameter set"}

protected

Definition at line 103 of file FPGATrackSimGenScanTool.h.

◆ m_phiFractionalPadding

Gaudi::Property<double> FPGATrackSimGenScanTool::m_phiFractionalPadding {this, "phiFractionalPadding", {}, "Fractional padding used when calculating the valid range of bins"}

protected

Definition at line 114 of file FPGATrackSimGenScanTool.h.

◆ m_qOverPtFractionalPadding

Gaudi::Property<double> FPGATrackSimGenScanTool::m_qOverPtFractionalPadding {this, "qOverPtFractionalPadding", {}, "Fractional padding used when calculating the valid range of bins"}

protected

Definition at line 115 of file FPGATrackSimGenScanTool.h.

◆ m_reversePairDir

Gaudi::Property<bool> FPGATrackSimGenScanTool::m_reversePairDir {this, "reversePairDir", {}, "Build Pairs starting at last layer and work in"}

protected

Definition at line 122 of file FPGATrackSimGenScanTool.h.

◆ m_rin

Gaudi::Property<double> FPGATrackSimGenScanTool::m_rin {this, "rin", {-1.0}, "Radius of inner layer for extrapolations and keylayer definition"}

protected

Definition at line 108 of file FPGATrackSimGenScanTool.h.

◆ m_roads

std::vector<FPGATrackSimRoad> FPGATrackSimGenScanTool::m_roads {}

protected

Definition at line 323 of file FPGATrackSimGenScanTool.h.

◆ m_rout

Gaudi::Property<double> FPGATrackSimGenScanTool::m_rout {this, "rout", {-1.0}, "Radius of outer layer for extrapolations and keylayer definition"}

protected

Definition at line 109 of file FPGATrackSimGenScanTool.h.

◆ m_threshold

Gaudi::Property<unsigned> FPGATrackSimGenScanTool::m_threshold {this, "threshold", {}, "Minimum value to accept as a road (inclusive)"}

protected

Definition at line 117 of file FPGATrackSimGenScanTool.h.

◆ m_validBin

FPGATrackSimGenScanArray<int> FPGATrackSimGenScanTool::m_validBin

protected

Definition at line 317 of file FPGATrackSimGenScanTool.h.

◆ m_validScan

FPGATrackSimGenScanArray<int> FPGATrackSimGenScanTool::m_validScan

protected

Definition at line 319 of file FPGATrackSimGenScanTool.h.

◆ m_validSlice

FPGATrackSimGenScanArray<int> FPGATrackSimGenScanTool::m_validSlice

protected

Definition at line 318 of file FPGATrackSimGenScanTool.h.

◆ m_validSliceAndScan

FPGATrackSimGenScanArray<int> FPGATrackSimGenScanTool::m_validSliceAndScan

protected

Definition at line 320 of file FPGATrackSimGenScanTool.h.

◆ m_z0FractionalPadding

Gaudi::Property<double> FPGATrackSimGenScanTool::m_z0FractionalPadding {this, "z0FractionalPadding", {}, "Fractional padding used when calculating the valid range of bins"}

protected

Definition at line 112 of file FPGATrackSimGenScanTool.h.

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

Classes

Public Member Functions

Protected Member Functions

Protected Attributes

Friends

Detailed Description

Constructor & Destructor Documentation

◆ FPGATrackSimGenScanTool()

Member Function Documentation

◆ addRoad()

◆ computeValidBins()

◆ fillImage()

◆ filterPairs()

◆ getRoads()

◆ getSubRegion()

◆ groupPairs()

◆ incrementalBuildFilter()

◆ initialize()

◆ makePairs()

◆ pairMatchesPairSet()

◆ pairPassesFilter()

◆ pairThenGroupFilter()

◆ sortHitsByLayer()

◆ updateState()

Friends And Related Function Documentation

◆ FPGATrackSimGenScanMonitoring

◆ operator<<

Member Data Documentation

◆ m_applyPairFilter

◆ m_applyPairSetFilter

◆ m_binFilter

◆ m_binning

◆ m_d0FractionalPadding

◆ m_etaFractionalPadding

◆ m_EvtSel

◆ m_evtsProcessed

◆ m_FPGATrackSimBankSvc

◆ m_FPGATrackSimMapping

◆ m_image

◆ m_monitoring

◆ m_nLayers

◆ m_pairFilterDeltaEtaCut

◆ m_pairFilterDeltaPhiCut

◆ m_pairFilterEtaExtrapCut

◆ m_pairFilterPhiExtrapCut

◆ m_pairingLayers

◆ m_pairSetDeltaDeltaEtaCut

◆ m_pairSetDeltaDeltaPhiCut

◆ m_pairSetDeltaEtaCurvatureCut

◆ m_pairSetDeltaPhiCurvatureCut

◆ m_pairSetEtaCurvatureCut

◆ m_pairSetMatchEtaCut

◆ m_pairSetMatchPhiCut

◆ m_pairSetPhiCurvatureCut

◆ m_pairSetPhiExtrapCurvedCut

◆ m_parBins

◆ m_parMax

◆ m_parMin

◆ m_parSet

◆ m_phiFractionalPadding

◆ m_qOverPtFractionalPadding

◆ m_reversePairDir

◆ m_rin

◆ m_roads

◆ m_rout

◆ m_threshold

◆ m_validBin

◆ m_validScan

◆ m_validSlice

◆ m_validSliceAndScan

◆ m_z0FractionalPadding