#include <FPGATrackSimGenScanTool.h>

Inheritance diagram for FPGATrackSimGenScanTool:

Collaboration diagram for FPGATrackSimGenScanTool:

Classes
class	HitPair

struct	HitPairSet

struct	IntermediateState

Public Types
using	StoredHit = FPGATrackSimBinUtil::StoredHit

using	BinEntry = FPGATrackSimBinnedHits::BinEntry

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

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
StatusCode	pairThenGroupFilter (const BinEntry &bindata, 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, 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 FPGATrackSimBinUtil::IdxSet &idx)

bool	fitRoad (std::vector< const StoredHit * > const &hits, const FPGATrackSimBinUtil::IdxSet &idx, FPGATrackSimTrackPars &trackpars, double &chi2) const

std::vector< unsigned >	PickHitsToUse (layer_bitmask_t) const

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

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

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

ToolHandle< FPGATrackSimBinnedHits >	m_binnedhits {this, "BinnedHits", "FPGATrackSimBinnedHits", "Binned Hits Class"}

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< 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_binningOnly {this, "binningOnly", {false}, "Turn off road building to test the binning only"}

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)"}

Gaudi::Property< double >	m_phiWeight {this, "phiChi2Weight", 1.0, "Weight for phi component of chi2 in genscan fit"}

Gaudi::Property< double >	m_etaWeight {this, "etaChi2Weight", 1.0, "Weight for eta component of chi2 in genscan fit"}

Gaudi::Property< bool >	m_inBinFiltering {this, "inBinFiltering", true, "Filter roads that appear to be outside their bin"}

Gaudi::Property< int >	m_keepHitsStrategy {this, "keepHitsStrategy", -1, "If this is less than 0, do nothing. If 1, pick 3 hits furthest apart. If 2, pick 3 inner hits. If 3, pick 3 outer hits. If 4, drop only middle hit for 5/5 otherwise keep all 4 hits for 4/5"}

int	m_evtsProcessed = 0

std::vector< unsigned int >	m_pairingLayers

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

Friends
class	FPGATrackSimGenScanMonitoring

Detailed Description

Definition at line 74 of file FPGATrackSimGenScanTool.h.

Member Typedef Documentation

◆ BinEntry

using FPGATrackSimGenScanTool::BinEntry = FPGATrackSimBinnedHits::BinEntry

Definition at line 78 of file FPGATrackSimGenScanTool.h.

◆ StoredHit

using FPGATrackSimGenScanTool::StoredHit = FPGATrackSimBinUtil::StoredHit

Definition at line 77 of file FPGATrackSimGenScanTool.h.

Constructor & Destructor Documentation

◆ FPGATrackSimGenScanTool()

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

Definition at line 61 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 FPGATrackSimBinUtil::IdxSet &	idx
	)

protected

Definition at line 612 of file FPGATrackSimGenScanTool.cxx.

 {
   layer_bitmask_t hitLayers = 0;
   std::vector<std::vector<std::shared_ptr<const FPGATrackSimHit>>>
       sorted_hits(m_binnedhits->getNLayers(),std::vector<std::shared_ptr<const FPGATrackSimHit>>());
   for (const FPGATrackSimBinUtil::StoredHit* hit : hits)
   {
     hitLayers |= 1 << hit->layer;
     sorted_hits[hit->layer].push_back(hit->hitptr);
   }
  
   // "Fit" the track.
   FPGATrackSimTrackPars fittedpars;
   double chi2;
   bool inBin = fitRoad(hits, idx, fittedpars, chi2);
   if (!inBin && m_inBinFiltering) return;
  
   m_roads.emplace_back(std::make_unique<FPGATrackSimRoad>());
   FPGATrackSimRoad *r = m_roads.back().get();
  
   r->setRoadID(m_roads.size() - 1);
   //    r.setPID(y * m_imageSize_y + x);
   r->setHits(std::move(sorted_hits));
  
   FPGATrackSimBinUtil::ParSet binCenterPars = m_binnedhits->getBinTool().lastStep()->binCenter(idx);
   FPGATrackSimTrackPars trackpars = m_binnedhits->getBinTool().binDesc()->parSetToTrackPars(binCenterPars);
   r->setX(trackpars[FPGATrackSimTrackPars::IPHI]);
   r->setY(trackpars[FPGATrackSimTrackPars::IHIP]);
   r->setXBin(idx[3]);
   r->setYBin(idx[4]);
   r->setHitLayers(hitLayers);
   r->setSubRegion(0);
  
   // Store the fitted information on the track.
   r->setFitParams(fittedpars);
   r->setFitChi2(chi2);
 }

◆ filterPairs()

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

protected

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

◆ fitRoad()

bool FPGATrackSimGenScanTool::fitRoad	(	std::vector< const StoredHit * > const &	hits,
		const FPGATrackSimBinUtil::IdxSet &	idx,
		FPGATrackSimTrackPars &	trackpars,
		double &	chi2
	)		const

protected

Definition at line 751 of file FPGATrackSimGenScanTool.cxx.

 {
  
   double N =hits.size();
   double sum_Phi  = 0;
   double sum_Phi2  = 0;
   double sum_PhiR  = 0;
   double sum_PhiR2  = 0;
   double sum_Eta  = 0;
   double sum_Eta2  = 0;
   double sum_EtaR  = 0;
   double sum_R  = 0;
   double sum_R2  = 0;
   double sum_R3  = 0;
   double sum_R4  = 0;
  
   for (const FPGATrackSimBinUtil::StoredHit* hit : hits)
   {
     // these are just relevant sums of variables (moments) needed for the chi2 calculation
     // Calculate r^2, r^3, and r^4, we'll sum these up later below
     double r = hit->hitptr->getR();
     double r2 = r*r;
     double r3 = r2*r;
     double r4 = r3*r;
     double dphi = hit->phiShift;
     double dphi2 = dphi*dphi;
     double deta = hit->etaShift;
     double deta2 = deta*deta;
  
     sum_Phi += dphi;
     sum_Phi2 += dphi2;
     sum_PhiR += dphi*r;
     sum_PhiR2 += dphi*r2;
     sum_Eta += deta;
     sum_Eta2 += deta2;
     sum_EtaR += deta*r;
     sum_R += r;
     sum_R2 += r2;
     sum_R3 += r3;
     sum_R4 += r4;
   }
  
   // phi var calculation
   // phi(r) = phivars[0] + phivars[1]*r + phivars[2]*r^2
   // math below is calculated by analytically minimizing the chi2
   // and solving for the phivars.
   // the terms below which recur in the phivar expression are just organized
   // by the power of r (i.e. the dimension), but otherwise have no deep meaning
   double r6_t0 = (-sum_R2 * sum_R4 + sum_R3*sum_R3);
   double r5_t0 = (sum_R*sum_R4 - sum_R2*sum_R3);
   double r4_t0 = (-sum_R * sum_R3 + sum_R2*sum_R2);
   double r4_t1 = (-N*sum_R4 + sum_R2*sum_R2);
   double r3_t0 = (N*sum_R3 - sum_R*sum_R2);
   double r2_t0 = (-N*sum_R2 + sum_R*sum_R);
  
   // all three phi var expresions use the same demoninator
   const double denom_phi = N * r6_t0 + sum_R * r5_t0 + sum_R2 * r4_t0;
   if (nearZero(denom_phi)){
     ATH_MSG_ERROR("Divide by zero (phi) trapped in FPGATrackSimGenScanTool::fitRoad");
     return false;
   }
  
   // phivar expresions from analytic chi2 minimization
   std::vector<double> phivars(3);
   phivars[0] = (sum_Phi*r6_t0 + sum_PhiR*r5_t0 + sum_PhiR2*r4_t0)/denom_phi;
   phivars[1] = (sum_Phi*r5_t0 + sum_PhiR*r4_t1 + sum_PhiR2*r3_t0)/denom_phi;
   phivars[2] = (sum_Phi*r4_t0 + sum_PhiR*r3_t0 + sum_PhiR2*r2_t0)/denom_phi;
  
   // eta vars
   // same as phi but with not curvature (r^2) term
   const double denom_eta = N*sum_R2 - sum_R*sum_R;
   if (nearZero(denom_eta)){
     ATH_MSG_ERROR("Divide by zero (eta) trapped in FPGATrackSimGenScanTool::fitRoad");
     return false;
   }
  
   std::vector<double> etavars(2);
   etavars[0] = (-sum_R*sum_EtaR + sum_R2*sum_Eta)/denom_eta;
   etavars[1] = (N*sum_EtaR - sum_R*sum_Eta)/denom_eta;
  
   // bin center
   FPGATrackSimBinUtil::ParSet parset = m_binnedhits->getBinTool().lastStep()->binCenter(idx);
   double parshift[FPGATrackSimTrackPars::NPARS];
   parshift[0] = etavars[0] + etavars[1]*m_rin; // z at r in
   parshift[1]= etavars[0] + etavars[1]*m_rout; // z at r out
   parshift[2]= -(phivars[0]/m_rin + phivars[1] + phivars[2]*m_rin) ; // phi at r in
   parshift[3]= -(phivars[0]/m_rout + phivars[1] + phivars[2]*m_rout) ; // phi at r out
   double y = (m_rout-m_rin); // midpoint between rin and rout from rin
   parshift[4]= -phivars[2]/4.0*y*y ; // xm
  
   bool inBin = true;
   const auto& lastStep = m_binnedhits->getBinTool().lastStep();
   for (int par = 0; par < FPGATrackSimTrackPars::NPARS; par++ ){
     parset[par]+=parshift[par];
     inBin = inBin && (std::abs(parshift[par]) < lastStep->binWidth(par)/2.0);
   }
  
   double ec0 = etavars[0];
   double ec1 = etavars[1];
   double eta_chi2 =  sum_Eta2 - 2*ec0*sum_Eta - 2*ec1*sum_EtaR + N*ec0*ec0 + 2*ec0*ec1*sum_R + ec1*ec1*sum_R2;
  
   double pc0 = phivars[0];
   double pc1 = phivars[1];
   double pc2 = phivars[2];
  
   double phi_chi2 = sum_Phi2 - 2*pc0*sum_Phi - 2*pc1*sum_PhiR - 2*pc2*sum_PhiR2 + N*pc0*pc0 + 2*pc0*pc1*sum_R + 2*pc0*pc2*sum_R2 + 2*pc1*pc2*sum_R3 + pc1*pc1*sum_R2 + pc2*pc2*sum_R4;
  
   for (const FPGATrackSimBinUtil::StoredHit* hit : hits)
   {
     double r = hit->hitptr->getR();
     ATH_MSG_VERBOSE("Fitted r= " << r << "    phishift " << hit->phiShift << " =?= " << pc0+pc1*r+pc2*r*r <<  "    etashift " << hit->etaShift << " =?= " << ec0+ec1*r);
   }
  
   ATH_MSG_DEBUG("Bin Info parset " << idx << " " << m_binnedhits->getBinTool().lastStep()->binCenter(idx));
   ATH_MSG_DEBUG("Fitted parset inBin="<< inBin << " nhits=" << hits.size() << " "  << parset  <<  " chi2 " <<  eta_chi2 << "," << phi_chi2);
  
   // Return by reference the "fitted" track parameters. shift q/pt dimension (GeV/MeV)
   trackpars = m_binnedhits->getBinTool().binDesc()->parSetToTrackPars(parset);
   trackpars[FPGATrackSimTrackPars::IHIP] = trackpars[FPGATrackSimTrackPars::IHIP] / 1000;
   ATH_MSG_VERBOSE("Fitted track pars" << trackpars);
  
   // and the summed chi2, which is assuming (right now) an even weighting between the two components.
   chi2 = std::sqrt(m_etaWeight * eta_chi2 * eta_chi2 + m_phiWeight * phi_chi2 * phi_chi2);
  
   return inBin;
 }

◆ 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 133 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));
  
   // do the binning...
   ATH_CHECK(m_binnedhits->fill(hits));
   m_monitoring->fillBinningSummary(hits);
  
   // scan over image building pairs for bins over threshold
   for (FPGATrackSimBinArray<BinEntry>::ConstIterator &bin : m_binnedhits->lastStepBinnedHits())
   {
     // apply threshold
     if (bin.data().lyrCnt() < m_threshold) continue;
     ATH_MSG_DEBUG("Bin passes threshold " << bin.data().lyrCnt() << " "
                                           << bin.idx());  
  
     // Monitor contents of bins passing threshold
     m_monitoring->fillBinLevelOutput(bin.idx(), bin.data());
     if (m_binningOnly) continue;
       
     // 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(), pairsets));
     } else if (m_binFilter=="IncrementalBuild") {
       ATH_CHECK(incrementalBuildFilter(bin.data(), 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());
         ATH_MSG_DEBUG("Output road size=" <<pairset.hitlist.size());
  
         // debug statement if more than one road found in bin
         // not necessarily a problem
         if (pairsets.size() >1) {
           std::string s = "";
           for (const FPGATrackSimBinUtil::StoredHit* const hit : pairset.hitlist)
           {
             s += "(" + std::to_string(hit->layer) + "," + std::to_string(hit->hitptr->getR()) + "), ";
           }        
           ATH_MSG_DEBUG("Duplicate Group " << s);
         }
       }  
   }
  
   // copy roads to output vector
   roads.reserve(m_roads.size());
  
   if (m_keepHitsStrategy > 0) {
     for (std::unique_ptr<FPGATrackSimRoad>& r : m_roads) {
       const std::vector<std::vector<std::shared_ptr<const FPGATrackSimHit>>>& theseHits = r->getAllHits();
       layer_bitmask_t hitmask = r->getHitLayers();
       std::vector<unsigned> toUse = PickHitsToUse(hitmask);
  
       std::vector<std::vector<std::shared_ptr<const FPGATrackSimHit>>> vec(5); // even if not all layers have hits, they need to be in the vector as empty vectors
       for (size_t ihit = 0; ihit < toUse.size(); ++ihit) {
         unsigned int layer = toUse[ihit];
         if (layer >= theseHits.size() || theseHits[layer].empty()) {
           ATH_MSG_ERROR("Hit index out of range in keepHitsStrategy: layer=" << layer << ", hits.size()=" << theseHits.size());
           return StatusCode::FAILURE;
         }
         vec[ihit].push_back(theseHits[layer][0]);
       }
       r->setHits(std::move(vec));
     }
   }
  
   
   for (auto & r : m_roads) roads.push_back(std::move(r));
   ATH_MSG_DEBUG("Roads = " << roads.size());
  
   // clear previous event
   // (reusing saves having to reallocate memory for each event)
   m_binnedhits->resetBins();
  
   m_evtsProcessed++;
   return StatusCode::SUCCESS;
 }

◆ getSubRegion()

virtual int FPGATrackSimGenScanTool::getSubRegion ( ) const

inlineoverridevirtual

Definition at line 90 of file FPGATrackSimGenScanTool.h.

90 {return 0;}

◆ groupPairs()

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

protected

Definition at line 477 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(int(pair.second->layer) - int(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(std::move(newpairset));
     }
   }
   
   return StatusCode::SUCCESS;
  
 }

◆ incrementalBuildFilter()

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

protected

Definition at line 371 of file FPGATrackSimGenScanTool.cxx.

 {
   ATH_MSG_VERBOSE("In buildGroupsWithPairs");
  
   // Organize Hits by Layer
   std::vector<std::vector<const StoredHit *>> hitsByLayer(m_binnedhits->getNLayers());
   ATH_CHECK(sortHitsByLayer(bindata, hitsByLayer));
   
   // This is monitoring for each bin over threshold
   // It's here so it can get the hitsByLayer
   m_monitoring->fillHitsByLayer(hitsByLayer);
  
   std::vector<IntermediateState> states{m_binnedhits->getNLayers()+1};
   for (unsigned lyridx = 0; lyridx < m_binnedhits->getNLayers(); 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_binnedhits->getNLayers()].pairsets;
  
   m_monitoring->fillBuildGroupsWithPairs(states,m_binnedhits->getNLayers()-m_threshold);
   
   return StatusCode::SUCCESS;
 }

◆ initialize()

StatusCode FPGATrackSimGenScanTool::initialize ( )

overridevirtual

Definition at line 68 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_FPGATrackSimMapping.retrieve());
   ATH_MSG_INFO("Map specifies :" << m_binnedhits->getNLayers());
   ATH_CHECK(m_binnedhits.retrieve());
   ATH_CHECK(m_monitoring.retrieve());
   ATH_MSG_INFO("Monitoring Dir :" << m_monitoring->dir());
  
   // Setup layer configuration if not already set from layerMap
   if (m_binnedhits->getNLayers()==0){
     auto nLogicalLayers = m_FPGATrackSimMapping->PlaneMap_1st(getSubRegion())->getNLogiLayers();
     if (nLogicalLayers == 0){
       ATH_MSG_ERROR("Number of logical layers is zero in FPGATrackSimGenScanTool::initialize");
       return StatusCode::FAILURE;
     }
     m_binnedhits->setNLayers(nLogicalLayers);
   }
   // This is the layers they get paired with previous layers
   for (unsigned lyr = 0; lyr < m_binnedhits->getNLayers(); ++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 (std::ssize(m_pairFilterDeltaPhiCut) != static_cast<int>(m_binnedhits->getNLayers()) - 1)
     ATH_MSG_FATAL("initialize() pairFilterDeltaPhiCut must have size nLayers-1=" << m_binnedhits->getNLayers() - 1 << " found " << m_pairFilterDeltaPhiCut.size());
   else if (m_pairFilterDeltaEtaCut.size() != m_binnedhits->getNLayers() - 1)
     ATH_MSG_FATAL("initialize() pairFilterDeltaEtaCut must have size nLayers-1=" << m_binnedhits->getNLayers() - 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;
  
   
   // register histograms
   ATH_CHECK(m_monitoring->registerHistograms(m_binnedhits.get()));
  
   // write out the firmware LUTs
   m_binnedhits->getBinTool().writeLUTs();
  
   return StatusCode::SUCCESS;
 }

◆ makePairs()

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

protected

Definition at line 417 of file FPGATrackSimGenScanTool.cxx.

 {
   ATH_MSG_VERBOSE("In makePairs");
  
   std::vector<const StoredHit *> const *  lastlyr = 0;
   std::vector<const StoredHit *> const *  lastlastlyr = 0;
  
   // order here is designed so lower radius hits come first
   for (unsigned lyr : m_pairingLayers) {
     for (const StoredHit *const &ptr1 :
          hitsByLayer[lyr]) {
       if (lastlyr) {
         for (const StoredHit *const &ptr2 : *lastlyr) {
           pairs.addPair(HitPair(ptr2, ptr1,m_reversePairDir));
         }
         // Add Pairs that skip one layer
         if (lastlastlyr) {
           for (const 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 525 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 452 of file FPGATrackSimGenScanTool.cxx.

                                                                   {
   m_monitoring->fillPairFilterCuts(pair,m_rin,m_rout);
   int lyr = std::min(pair.first->layer,pair.second->layer);
   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,
		std::vector< HitPairSet > &	output_pairset
	)

protected

Definition at line 227 of file FPGATrackSimGenScanTool.cxx.

 {
   ATH_MSG_VERBOSE("In pairThenGroupFilter");
  
   // Organize Hits by Layer
   std::vector<std::vector<const StoredHit *>> hitsByLayer(m_binnedhits->getNLayers());
   ATH_CHECK(sortHitsByLayer(bindata, hitsByLayer));
   
   // This is monitoring for each bin over threshold
   // It's here so it can get the hitsByLayer
   m_monitoring->fillHitsByLayer(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(std::move(pairs));
   }
   else if (passedPairFilter && !m_applyPairSetFilter)
   {
     // output is just the filtered pairs
     output_pairsets.push_back(std::move(filteredpairs));
   }
  
   return StatusCode::SUCCESS;
 }

◆ PickHitsToUse()

std::vector< unsigned > FPGATrackSimGenScanTool::PickHitsToUse ( layer_bitmask_t hitmask ) const

protected

Definition at line 878 of file FPGATrackSimGenScanTool.cxx.

 {
   std::vector<unsigned> toUse;
   switch (m_keepHitsStrategy) {
     case 1: // try and pick hits furthest apart, use only 3
       {
         if (hitmask == 0x1f) { // miss no hits
           toUse = {0,2,4};
         }
         else if (hitmask == 0x1e) { // miss inner layer, ie layer 0
           toUse = {1,3,4};
         }
         else if (hitmask == 0x1d) { // miss layer 1
           toUse = {0,2,4};
         }
         else if (hitmask == 0x1b) { // miss layer 2
           toUse = {0,3,4};
         }
         else if (hitmask == 0x17) { // miss layer 3
           toUse = {0,2,4};
         }
         else if (hitmask == 0x0f) { // miss layer 4
           toUse = {0,2,3};
         }
       }
       break;
     case 2: // pick inner hits, use only 3
       {
         if (hitmask == 0x1f) { // miss no hits
           toUse = {0,1,2};
         }
         else if (hitmask == 0x1e) { // miss inner layer, ie layer 0
           toUse = {1,2,3};
         }
         else if (hitmask == 0x1d) { // miss layer 1
           toUse = {0,2,3};
         }
         else if (hitmask == 0x1b) { // miss layer 2
           toUse = {0,1,3};
         }
         else if (hitmask == 0x17) { // miss layer 3
           toUse = {0,1,2};
         }
         else if (hitmask == 0x0f) { // miss layer 4
           toUse = {0,1,2};
         }
       }
       break;
     case 3: // pick outer hits, use only 3
       {
         if (hitmask == 0x1f) { // miss no hits
           toUse = {2,3,4};
         }
         else if (hitmask == 0x1e) { // miss inner layer, ie layer 0
           toUse = {2,3,4};
         }
         else if (hitmask == 0x1d) { // miss layer 1
           toUse = {2,3,4};
         }
         else if (hitmask == 0x1b) { // miss layer 2
           toUse = {1,3,4};
         }
         else if (hitmask == 0x17) { // miss layer 3
           toUse = {1,2,4};
         }
         else if (hitmask == 0x0f) { // miss layer 4
           toUse = {1,2,3};
         }
       }
       break;
     case 4: // keep 4 hits, choose middle one to drop if necessary
       {
         if (hitmask == 0x1f) { // miss no hits
           toUse = {0,1,2,3};
         }
         else if (hitmask == 0x1e) { // miss inner layer, ie layer 0
           toUse = {1,2,3,4};
         }
         else if (hitmask == 0x1d) { // miss layer 1
           toUse = {0,2,3,4};
         }
         else if (hitmask == 0x1b) { // miss layer 2
           toUse = {0,1,3,4};
         }
         else if (hitmask == 0x17) { // miss layer 3
           toUse = {0,1,2,4};
         }
         else if (hitmask == 0x0f) { // miss layer 4
           toUse = {0,1,2,3};
         }
       }
       break;
   }
   return toUse;
 }

◆ sortHitsByLayer()

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

protected

Definition at line 400 of file FPGATrackSimGenScanTool.cxx.

 {
   ATH_MSG_DEBUG("In fillHitsByLayer");
  
   for (const FPGATrackSimBinUtil::StoredHit &hit : bindata.hits) {    
     hitsByLayer.at(hit.layer).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 287 of file FPGATrackSimGenScanTool.cxx.

 {
   unsigned int allowed_missed_hits = m_binnedhits->getNLayers() - 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 (unsigned ps_idx = 0; ps_idx < inputstate.pairsets.size(); ++ps_idx) {
       auto &pairset = inputstate.pairsets[ps_idx];
       HitPair nextpair(pairset.lastpair().second, newhit, m_reversePairDir);
       if (pairMatchesPairSet(pairset, nextpair, false) || (m_applyPairSetFilter==false)) {
         HitPairSet newset(pairset);
         newset.addPair(nextpair);
         pairset_used[ps_idx]=true;
         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) || (m_applyPairFilter == false)) {
           HitPairSet newset;
           newset.addPair(newpair);
           outputstate.pairsets.push_back(std::move(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 (unsigned ps_idx = 0; ps_idx < inputstate.pairsets.size(); ++ps_idx) {
     auto &pairset = inputstate.pairsets[ps_idx];
     if ((!pairset_used[ps_idx])&&(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 92 of file FPGATrackSimGenScanTool.h.

Member Data Documentation

◆ m_applyPairFilter

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

protected

Definition at line 114 of file FPGATrackSimGenScanTool.h.

◆ m_applyPairSetFilter

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

protected

Definition at line 121 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 111 of file FPGATrackSimGenScanTool.h.

◆ m_binnedhits

ToolHandle<FPGATrackSimBinnedHits> FPGATrackSimGenScanTool::m_binnedhits {this, "BinnedHits", "FPGATrackSimBinnedHits", "Binned Hits Class"}

protected

Definition at line 101 of file FPGATrackSimGenScanTool.h.

◆ m_binningOnly

Gaudi::Property<bool> FPGATrackSimGenScanTool::m_binningOnly {this, "binningOnly", {false}, "Turn off road building to test the binning only"}

protected

Definition at line 113 of file FPGATrackSimGenScanTool.h.

◆ m_etaWeight

Gaudi::Property<double> FPGATrackSimGenScanTool::m_etaWeight {this, "etaChi2Weight", 1.0, "Weight for eta component of chi2 in genscan fit"}

protected

Definition at line 132 of file FPGATrackSimGenScanTool.h.

◆ m_EvtSel

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

protected

Definition at line 98 of file FPGATrackSimGenScanTool.h.

◆ m_evtsProcessed

int FPGATrackSimGenScanTool::m_evtsProcessed = 0

protected

Definition at line 268 of file FPGATrackSimGenScanTool.h.

◆ m_FPGATrackSimMapping

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

protected

Definition at line 99 of file FPGATrackSimGenScanTool.h.

◆ m_inBinFiltering

Gaudi::Property<bool> FPGATrackSimGenScanTool::m_inBinFiltering {this, "inBinFiltering", true, "Filter roads that appear to be outside their bin"}

protected

Definition at line 133 of file FPGATrackSimGenScanTool.h.

◆ m_keepHitsStrategy

Gaudi::Property<int> FPGATrackSimGenScanTool::m_keepHitsStrategy {this, "keepHitsStrategy", -1, "If this is less than 0, do nothing. If 1, pick 3 hits furthest apart. If 2, pick 3 inner hits. If 3, pick 3 outer hits. If 4, drop only middle hit for 5/5 otherwise keep all 4 hits for 4/5"}

protected

Definition at line 134 of file FPGATrackSimGenScanTool.h.

◆ m_monitoring

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

protected

Definition at line 100 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 117 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 116 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 119 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 118 of file FPGATrackSimGenScanTool.h.

◆ m_pairingLayers

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

protected

Definition at line 269 of file FPGATrackSimGenScanTool.h.

◆ m_pairSetDeltaDeltaEtaCut

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

protected

Definition at line 125 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 124 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 129 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 128 of file FPGATrackSimGenScanTool.h.

◆ m_pairSetEtaCurvatureCut

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

protected

Definition at line 127 of file FPGATrackSimGenScanTool.h.

◆ m_pairSetMatchEtaCut

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

protected

Definition at line 123 of file FPGATrackSimGenScanTool.h.

◆ m_pairSetMatchPhiCut

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

protected

Definition at line 122 of file FPGATrackSimGenScanTool.h.

◆ m_pairSetPhiCurvatureCut

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

protected

Definition at line 126 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 130 of file FPGATrackSimGenScanTool.h.

◆ m_phiWeight

Gaudi::Property<double> FPGATrackSimGenScanTool::m_phiWeight {this, "phiChi2Weight", 1.0, "Weight for phi component of chi2 in genscan fit"}

protected

Definition at line 131 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 115 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 105 of file FPGATrackSimGenScanTool.h.

◆ m_roads

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

protected

Definition at line 272 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 106 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 109 of file FPGATrackSimGenScanTool.h.

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

Classes

Public Types

Public Member Functions

Protected Member Functions

Protected Attributes

Friends

Detailed Description

Member Typedef Documentation

◆ BinEntry

◆ StoredHit

Constructor & Destructor Documentation

◆ FPGATrackSimGenScanTool()

Member Function Documentation

◆ addRoad()

◆ filterPairs()

◆ fitRoad()

◆ getRoads()

◆ getSubRegion()

◆ groupPairs()

◆ incrementalBuildFilter()

◆ initialize()

◆ makePairs()

◆ pairMatchesPairSet()

◆ pairPassesFilter()

◆ pairThenGroupFilter()

◆ PickHitsToUse()

◆ sortHitsByLayer()

◆ updateState()

Friends And Related Function Documentation

◆ FPGATrackSimGenScanMonitoring

Member Data Documentation

◆ m_applyPairFilter

◆ m_applyPairSetFilter

◆ m_binFilter

◆ m_binnedhits

◆ m_binningOnly

◆ m_etaWeight

◆ m_EvtSel

◆ m_evtsProcessed

◆ m_FPGATrackSimMapping

◆ m_inBinFiltering

◆ m_keepHitsStrategy

◆ m_monitoring

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

◆ m_reversePairDir

◆ m_rin

◆ m_roads

◆ m_rout

◆ m_threshold