#include <FPGATrackSimKeyLayerBinDesc.h>

Inheritance diagram for FPGATrackSimKeyLayerBinDesc:

Collaboration diagram for FPGATrackSimKeyLayerBinDesc:

Classes
struct	etaLUTConsts

struct	phiLUTConsts

Public Member Functions
virtual StatusCode	initialize () override

virtual const std::string &	parNames (unsigned i) const override

virtual const FPGATrackSimBinUtil::ParSet	trackParsToParSet (const FPGATrackSimTrackPars &pars) const override

virtual const FPGATrackSimTrackPars	parSetToTrackPars (const FPGATrackSimBinUtil::ParSet &parset) const override

virtual double	phiResidual (const FPGATrackSimBinUtil::ParSet &parset, FPGATrackSimHit const *hit) const override

virtual double	etaResidual (const FPGATrackSimBinUtil::ParSet &parset, FPGATrackSimHit const *hit) const override

bool	stepIsRPhi (const FPGATrackSimBinStep &step) const

bool	stepIsREta (const FPGATrackSimBinStep &step) const

virtual bool	hitInBin (const FPGATrackSimBinStep &step, const FPGATrackSimBinUtil::IdxSet &idx, FPGATrackSimBinUtil::StoredHit &storedhit) const override

phiLUTConsts	getPhiLUTConsts (const FPGATrackSimBinStep &step, const std::vector< unsigned > &idx) const

etaLUTConsts	getEtaLUTConsts (const FPGATrackSimBinStep &step, const std::vector< unsigned > &idx) const

virtual void	writeLUTs (const FPGATrackSimBinStep &step) const override

Private Member Functions
FPGATrackSimBinUtil::ParSet	keyparsToParSet (const FPGATrackSimKeyLayerTool::KeyLyrPars &keypars) const

FPGATrackSimKeyLayerTool::KeyLyrPars	parSetToKeyPars (const FPGATrackSimBinUtil::ParSet &parset) const

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

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

Gaudi::Property< bool >	m_approxMath {this, "approxMath", {false}, "Use approximate math to emulate possible firmware"}

Gaudi::Property< double >	m_d0pad {this, "D0Pad", 0.0, "Extra phi padding from d0 resolution"}

Gaudi::Property< double >	m_phipad {this, "PhiPad", 0.0, "Extra phi padding from phi resolution"}

Gaudi::Property< double >	m_qptpad {this, "QPtPad", 0.0, "Extra phi padding from q/pT resolution"}

Gaudi::Property< double >	m_z0pad {this, "Z0Pad", 0.0, "Extra eta padding from z0 resolution"}

Gaudi::Property< double >	m_etapad {this, "EtaPad", 0.0, "Extra eta padding from eta resolution"}

Gaudi::Property< unsigned >	m_region {this, "region", 0, "Region number, needed to write out lookup tables for test vectors"}

Gaudi::Property< std::vector< double > >	m_slPerEtaMod

Gaudi::Property< double >	m_phiOffset {this, "PhiOffset", 0.0, "Phi offset between local and global parameters (avoids phi wrap around effects in region code)"}

Gaudi::Property< unsigned >	m_fieldCorRegion { this, "fieldCorRegion", 2, "region for fieldCorrection"}

Gaudi::Property< bool >	m_fieldCorrection {this, "fieldCorrection", true, "Use magnetic field correction for Hough transform"}

FPGATrackSimKeyLayerTool	m_keylyrtool

const std::vector< std::string >	m_parNames {"zR1", "zR2", "phiR1", "phiR2", "xm"}

const std::vector< unsigned >	m_phipars {2, 3, 4}

const std::vector< unsigned >	m_etapars {0, 1}

Detailed Description

Definition at line 42 of file FPGATrackSimKeyLayerBinDesc.h.

Member Function Documentation

◆ etaResidual()

virtual double FPGATrackSimKeyLayerBinDesc::etaResidual	(	const FPGATrackSimBinUtil::ParSet &	parset,
		FPGATrackSimHit const *	hit
	)		const

inlineoverridevirtual

Definition at line 81 of file FPGATrackSimKeyLayerBinDesc.h.

                                                                                                                    {
       return hit->getZ()- m_keylyrtool.zExpected(parSetToKeyPars(parset),hit->getR());
     }

◆ getEtaLUTConsts()

FPGATrackSimKeyLayerBinDesc::etaLUTConsts FPGATrackSimKeyLayerBinDesc::getEtaLUTConsts	(	const FPGATrackSimBinStep &	step,
		const std::vector< unsigned > &	idx
	)		const

Definition at line 209 of file FPGATrackSimKeyLayerBinDesc.cxx.

                                                                                                                                                           {
   etaLUTConsts retv;
  
   double r_in = m_keylyrtool.R1();
   double r_out = m_keylyrtool.R2();
   retv.r_in = r_in;
   retv.r_out= r_out;
  
   double z_in = step.binCenter(0, idx[0]);
   double z_out = step.binCenter(1, idx[1]);
   double dz_dr = (z_out - z_in) / (r_out - r_in);
  
   retv.z_in = z_in;
   retv.dz_dr = dz_dr;
  
   double w_in = step.binWidth(0) / 2.0;
   double w_out = step.binWidth(1) / 2.0;
   double dw_dr = (w_out - w_in) / (r_out - r_in);
   retv.w_in = w_in;
   retv.dw_dr = dw_dr;
  
   return retv;
 }

◆ getPhiLUTConsts()

FPGATrackSimKeyLayerBinDesc::phiLUTConsts FPGATrackSimKeyLayerBinDesc::getPhiLUTConsts	(	const FPGATrackSimBinStep &	step,
		const std::vector< unsigned > &	idx
	)		const

Definition at line 175 of file FPGATrackSimKeyLayerBinDesc.cxx.

                                                                                                                                                           {
   phiLUTConsts retv;
  
   FPGATrackSimKeyLayerTool::KeyLyrPars keypars;
   keypars.phi1 = step.binCenter(2,idx[0]);
   keypars.phi2 = step.binCenter(3,idx[1]);
   keypars.xm = step.binCenter(4, idx[2]);
  
   auto rotated_coords = m_keylyrtool.getRotatedConfig(keypars);
  
   retv.y = rotated_coords.y;
   retv.x1p = rotated_coords.xy1p.first;
   retv.y1p = rotated_coords.xy1p.second;
   retv.cosb = rotated_coords.rotang.first;
   retv.sinb = rotated_coords.rotang.second;
   retv.x_m = keypars.xm;
   retv.x_factor = 4.0 * keypars.xm / (rotated_coords.y * rotated_coords.y);
  
   double r_in = m_keylyrtool.R1();
   double r_out = m_keylyrtool.R2();
   retv.r_in = r_in;
   retv.r_out= r_out;
  
   double w_in = r_in * step.binWidth(2) / 2.0;
   double w_out = r_out * step.binWidth(3) / 2.0;
   double w_x = step.binWidth(4) / 2.0;
  
   retv.w_x = 4.0 * w_x / ((r_out - r_in) * (r_out - r_in));
   retv.w_in = w_in;
   retv.dw_dr = (w_out - w_in) / (r_out - r_in);
  
   return retv;
 }

◆ hitInBin()

bool FPGATrackSimKeyLayerBinDesc::hitInBin	(	const FPGATrackSimBinStep &	step,
		const FPGATrackSimBinUtil::IdxSet &	idx,
		FPGATrackSimBinUtil::StoredHit &	storedhit
	)		const

overridevirtual

Definition at line 41 of file FPGATrackSimKeyLayerBinDesc.cxx.

 {
     double r1 = m_keylyrtool.R1();
     double r2 = m_keylyrtool.R2();
     double hitr= storedhit.hitptr->getR();
  
     bool passesPhi = true;
     bool passesEta = true;
  
     FPGATrackSimTrackPars trackpars = parSetToTrackPars(step.binCenter(idx));
  
     bool isTruthBin = ((m_truthbin.size()>step.stepNum())&&(m_truthbin[step.stepNum()]==idx));
     
     if (stepIsRPhi(step)) {
         // distance of hit from bin center
         storedhit.phiShift =
             phiResidual(step.binCenter(idx), storedhit.hitptr.get());
  
         // Get expected curvature shift from bin center    
         auto half_xm_bin_pars = parSetToKeyPars(step.binCenter(idx));
         half_xm_bin_pars.xm = step.binWidth(4)/2.0; // 4 = xm par
         double xshift =
             m_keylyrtool.xExpected(half_xm_bin_pars, storedhit.hitptr->getR(), remainder(storedhit.hitptr->getGPhi()+m_phiOffset,2*M_PI));
         double xrange = std::abs(xshift) + r1 * step.binWidth(2) / 2.0
                         + ((r2*step.binWidth(3) - r1*step.binWidth(2)) / (r2 - r1) * (hitr - r1))/2.0;
  
         if (xrange < 0) {
           ATH_MSG_ERROR("Negative xrange: " << std::abs(xshift) << " " << r1 * step.binWidth(2) / 2.0 << " " 
             << ((r2*step.binWidth(3) - r1*step.binWidth(2)) / (r2 - r1) * (hitr - r1))/2.0);
         }
  
         double padding = 0.0;
         double stripLength = 25.0;
         if (storedhit.hitptr->getDetType() == SiliconTech::strip) {
           if (!storedhit.hitptr->isBarrel()) {
               // varying strip lengths per eta mod in endcap
               int etamod = storedhit.hitptr->getEtaModule();
               stripLength = m_slPerEtaMod[etamod]/2.0;
           }
           padding += stripLength*std::abs(FPGATrackSimBinUtil::GeomHelpers::dPhiHitTrkFromPars(hitr,trackpars));
         }
         // add phiShift resolution padding, 1000.0 is the GeV to MeV conversion
         padding += m_d0pad + hitr*m_phipad + hitr*m_qptpad*1000.0*FPGATrackSimBinUtil::GeomHelpers::dPhidQOverPt(hitr);
         passesPhi = std::abs(storedhit.phiShift) < (xrange+padding);
         ATH_MSG_VERBOSE("Phi qpt pad: " << storedhit.phiShift << " " << hitr*m_qptpad*1000.0*FPGATrackSimBinUtil::GeomHelpers::dPhidQOverPt(hitr) << " " << m_qptpad);
         if (isTruthBin && !passesPhi) ATH_MSG_DEBUG("Hit fails Phi cut, lyr=" << storedhit.hitptr->getPhysLayer() << " "
                         << storedhit.phiShift << " " << xrange + padding << " " <<xrange << " "<< padding
                         << " " << m_d0pad << " "  << hitr*m_phipad  << " "  << hitr*m_qptpad*FPGATrackSimBinUtil::GeomHelpers::dPhidQOverPt(hitr)
                         << " "  << ((storedhit.hitptr->getDetType() == SiliconTech::strip) ?  (stripLength*std::abs(FPGATrackSimBinUtil::GeomHelpers::dPhiHitTrkFromPars(hitr,trackpars))) : 99999)
                         << " " << hitr << " " << trackpars);
  
         // Firmware x-check
         phiLUTConsts phiconsts = getPhiLUTConsts(step,step.stepIdx(idx));
         double fw_phiShift = phiconsts.phiShift(remainder(storedhit.hitptr->getGPhi() + m_phiOffset,2*M_PI),  hitr);
         double fw_phiWindow = phiconsts.phiWindow( hitr);        
         ATH_MSG_VERBOSE("FW x-check: phiShift orig: " << storedhit.phiShift << " fwcalc: " << fw_phiShift << " diff: " << storedhit.phiShift-fw_phiShift);
         ATH_MSG_VERBOSE("FW " << phiconsts.w_in << " " << phiconsts.dw_dr*(hitr-phiconsts.r_in) << " " <<  phiconsts.w_x*(hitr-phiconsts.r_in)*(phiconsts.r_out-hitr) 
         << "    Orig: " <<  r1 * step.binWidth(2) / 2.0 << " " << ((r2*step.binWidth(3) - r1*step.binWidth(2)) / (r2 - r1) * (hitr - r1))/2.0 << " " << std::abs(xshift));
         ATH_MSG_VERBOSE("FW x-check: phiWindow orig: " << xrange << " fwcalc: " << fw_phiWindow << " diff: " << xrange-fw_phiWindow);
         
     }
  
     if (stepIsREta(step)) {
         // distance of hit from bin center
         storedhit.etaShift = etaResidual(step.binCenter(idx),storedhit.hitptr.get());
     
         double width_z_in  = step.binWidth(0)/2.0;
         double width_z_out = step.binWidth(1)/2.0;
         double zrange = width_z_in + (width_z_out-width_z_in) * std::abs((hitr-r1))/(r2-r1);
  
         // pad for strip length or imprecise SP.
         double padding = 0;
         double stripLength = 25.0; //barrel strip length
         if (storedhit.hitptr->getDetType() == SiliconTech::strip) {
           if (!storedhit.hitptr->isBarrel()) {
               // varying strip lengths per eta mod in endcap
               int etamod = storedhit.hitptr->getEtaModule();
               stripLength = m_slPerEtaMod[etamod]/2.0;
           }
           // length of longest correspinding to endcap or barrel strip
           padding += stripLength;
         }
         // add etaShift resolution padding
         padding += (m_z0pad + std::abs(hitr*m_etapad*FPGATrackSimBinUtil::GeomHelpers::dZdEta(trackpars.eta)));
         passesEta = std::abs(storedhit.etaShift) < (zrange+padding);
         if (isTruthBin && !passesEta) ATH_MSG_DEBUG("Hit fails Eta cut , lyr=" << storedhit.hitptr->getPhysLayer() << " r=" << hitr << " " 
                         << storedhit.etaShift << " " << zrange + padding << " " <<zrange << " "<< padding << " " << hitr << " " << trackpars);        
  
         // Firmware x-check
         etaLUTConsts etaconsts = getEtaLUTConsts(step,step.stepIdx(idx));
         double fw_etaShift = etaconsts.etaShift(storedhit.hitptr->getZ(),  hitr);
         double fw_etaWindow = etaconsts.etaWindow( hitr);
         ATH_MSG_VERBOSE("FW x-check: etaShift orig: " << storedhit.etaShift << " fwcalc: " << fw_etaShift << " diff: " << storedhit.etaShift-fw_etaShift);
         ATH_MSG_VERBOSE("FW x-check: etaWindow orig: " << zrange << " fwcalc: " << fw_etaWindow << " diff: " << zrange-fw_etaWindow);
         
  
     }
    
     
     if (isTruthBin && !(passesPhi && passesEta)) ATH_MSG_DEBUG("Hit in truth bin fails cuts: " << " passesPhi=" << passesPhi << " passesEta=" << passesEta);
  
     return passesPhi && passesEta;
 }

◆ initialize()

StatusCode FPGATrackSimKeyLayerBinDesc::initialize ( )

overridevirtual

Definition at line 25 of file FPGATrackSimKeyLayerBinDesc.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());
     }
   }
  
   m_keylyrtool.setR1(m_rin);
   m_keylyrtool.setR2(m_rout);
  
   return StatusCode::SUCCESS;
 }

◆ keyparsToParSet()

FPGATrackSimBinUtil::ParSet FPGATrackSimKeyLayerBinDesc::keyparsToParSet ( const FPGATrackSimKeyLayerTool::KeyLyrPars & keypars ) const

inlineprivate

Definition at line 158 of file FPGATrackSimKeyLayerBinDesc.h.

                                                                                                        {
       return FPGATrackSimBinUtil::ParSet({keypars.z1,keypars.z2,keypars.phi1,keypars.phi2,keypars.xm});
     }

◆ parNames()

virtual const std::string& FPGATrackSimKeyLayerBinDesc::parNames ( unsigned i ) const

inlineoverridevirtual

Definition at line 50 of file FPGATrackSimKeyLayerBinDesc.h.

50 { return m_parNames[i]; }

◆ parSetToKeyPars()

FPGATrackSimKeyLayerTool::KeyLyrPars FPGATrackSimKeyLayerBinDesc::parSetToKeyPars ( const FPGATrackSimBinUtil::ParSet & parset ) const

inlineprivate

Definition at line 161 of file FPGATrackSimKeyLayerBinDesc.h.

                                                                                                       {
       return FPGATrackSimKeyLayerTool::KeyLyrPars(parset);
     }

◆ parSetToTrackPars()

virtual const FPGATrackSimTrackPars FPGATrackSimKeyLayerBinDesc::parSetToTrackPars ( const FPGATrackSimBinUtil::ParSet & parset ) const

inlineoverridevirtual

Definition at line 67 of file FPGATrackSimKeyLayerBinDesc.h.

                                                                                                                   {
       FPGATrackSimKeyLayerTool::KeyLyrPars keypars = parSetToKeyPars(parset);
       keypars.phi1=remainder(keypars.phi1-m_phiOffset,2*M_PI);
       keypars.phi2=remainder(keypars.phi2-m_phiOffset,2*M_PI);      
       return m_keylyrtool.keyParsToTrackPars(keypars);
     }

◆ phiResidual()

virtual double FPGATrackSimKeyLayerBinDesc::phiResidual	(	const FPGATrackSimBinUtil::ParSet &	parset,
		FPGATrackSimHit const *	hit
	)		const

inlineoverridevirtual

Definition at line 77 of file FPGATrackSimKeyLayerBinDesc.h.

                                                                                                                    {
         return m_keylyrtool.deltaX(parSetToKeyPars(parset), hit->getR(), hit->getGPhi() + m_phiOffset);
     }

◆ stepIsREta()

bool FPGATrackSimKeyLayerBinDesc::stepIsREta ( const FPGATrackSimBinStep & step ) const

Definition at line 159 of file FPGATrackSimKeyLayerBinDesc.cxx.

                                            {
   for (const unsigned &steppar : step.stepPars()) {
     for (const unsigned &etapar : m_etapars) {
       if (steppar == etapar)
         return true;
     }
   }
   return false;
 }

◆ stepIsRPhi()

bool FPGATrackSimKeyLayerBinDesc::stepIsRPhi ( const FPGATrackSimBinStep & step ) const

Definition at line 148 of file FPGATrackSimKeyLayerBinDesc.cxx.

                                            {
   for (const unsigned &steppar : step.stepPars()) {
     for (const unsigned &phipar : m_phipars) {
       if (steppar == phipar)
         return true;
     }
   }
   return false;
 }

◆ trackParsToParSet()

virtual const FPGATrackSimBinUtil::ParSet FPGATrackSimKeyLayerBinDesc::trackParsToParSet ( const FPGATrackSimTrackPars & pars ) const

inlineoverridevirtual

Definition at line 54 of file FPGATrackSimKeyLayerBinDesc.h.

                                                                         {   
       FPGATrackSimKeyLayerTool::KeyLyrPars keypars = m_keylyrtool.trackParsToKeyPars(pars);
       if (m_fieldCorrection) {
         keypars.phi1+=fieldCorrection(m_fieldCorRegion, pars.qOverPt/1000.0 ,m_keylyrtool.R1());
         keypars.phi2+=fieldCorrection(m_fieldCorRegion, pars.qOverPt/1000.0 ,m_keylyrtool.R2());
       }
       keypars.phi1=remainder(keypars.phi1+m_phiOffset,2*M_PI);
       keypars.phi2=remainder(keypars.phi2+m_phiOffset,2*M_PI);
       return keyparsToParSet(keypars);
     }

◆ writeLUTs()

void FPGATrackSimKeyLayerBinDesc::writeLUTs ( const FPGATrackSimBinStep & step ) const

overridevirtual

Definition at line 256 of file FPGATrackSimKeyLayerBinDesc.cxx.

                                                                                  {
   double r_in = m_keylyrtool.R1();
   double r_out = m_keylyrtool.R2();
  
   ATH_MSG_INFO("Writing constants for step:" << step.stepName() << " isRPhi="<< stepIsRPhi(step) << " isREta="<< stepIsREta(step));
   
   // write the keylayer definition
   if (step.isFirstStep()) {
     std::string keylayerName = "reg_" + std::to_string(m_region.value()) + "_KeyLayer";
     FPGATrackSimBinUtil::StreamManager sm(keylayerName);
     sm.writeVar("r_in",r_in);
     sm.writeVar("r_out",r_out);
   }
  
   if (stepIsRPhi(step)) {
  
     std::string stepName = "reg_" + std::to_string(m_region.value()) + "_" + step.stepName();
     FPGATrackSimBinUtil::StreamManager sm(stepName);
     int nbins = 0;
     for (FPGATrackSimBinArray<int>::ConstIterator &bin : step.validBinsLocal()) {
       if (!bin.data())
         continue;      
       phiLUTConsts phiconsts = getPhiLUTConsts(step,bin.idx());
  
       sm.writeVar("phi_bin", bin.idx());
   
       sm.writeVar("y", phiconsts.y);
       sm.writeVar("x1p", phiconsts.x1p);
       sm.writeVar("y1p", phiconsts.y1p);
       sm.writeVar("cosb", phiconsts.cosb);
       sm.writeVar("sinb", phiconsts.sinb);
  
       sm.writeVar("x_m", phiconsts.x_m);
       sm.writeVar("x_factor", phiconsts.x_factor);
  
       if (nbins == 0) {
         sm.writeVar("w_x", phiconsts.w_x);
         sm.writeVar("w_in", phiconsts.w_in);
         sm.writeVar("dw_dr", phiconsts.dw_dr);
       }
  
       nbins++;
     }    
  
     sm.writeVar("nbins", nbins);
   }
  
   if (stepIsREta(step)) {
  
     std::string stepName = "reg_" + std::to_string(m_region.value()) + "_" + step.stepName();
     FPGATrackSimBinUtil::StreamManager sm(stepName);
  
     int nbins = 0;
     for (FPGATrackSimBinArray<int>::ConstIterator &bin : step.validBinsLocal()) {
       if (!bin.data())
         continue;
  
       etaLUTConsts etaconsts = getEtaLUTConsts(step,bin.idx());
  
       // write just this steps idxs
       sm.writeVar("z_bin", bin.idx());      
       sm.writeVar("z_in", etaconsts.z_in);
       sm.writeVar("dz_dr", etaconsts.dz_dr);
     
       if (nbins==0) {
         sm.writeVar("w_in", etaconsts.w_in);
         sm.writeVar("dw_dr", etaconsts.dw_dr);
       };
       
       nbins++;
     }
     sm.writeVar("nbins", nbins);
       
   }
  
 }

Member Data Documentation

◆ m_approxMath

Gaudi::Property<bool> FPGATrackSimKeyLayerBinDesc::m_approxMath {this, "approxMath", {false}, "Use approximate math to emulate possible firmware"}

private

Definition at line 136 of file FPGATrackSimKeyLayerBinDesc.h.

◆ m_d0pad

Gaudi::Property<double> FPGATrackSimKeyLayerBinDesc::m_d0pad {this, "D0Pad", 0.0, "Extra phi padding from d0 resolution"}

private

Definition at line 137 of file FPGATrackSimKeyLayerBinDesc.h.

◆ m_etapad

Gaudi::Property<double> FPGATrackSimKeyLayerBinDesc::m_etapad {this, "EtaPad", 0.0, "Extra eta padding from eta resolution"}

private

Definition at line 141 of file FPGATrackSimKeyLayerBinDesc.h.

◆ m_etapars

const std::vector<unsigned> FPGATrackSimKeyLayerBinDesc::m_etapars {0, 1}

private

Definition at line 170 of file FPGATrackSimKeyLayerBinDesc.h.

◆ m_fieldCorrection

Gaudi::Property<bool> FPGATrackSimKeyLayerBinDesc::m_fieldCorrection {this, "fieldCorrection", true, "Use magnetic field correction for Hough transform"}

private

Definition at line 154 of file FPGATrackSimKeyLayerBinDesc.h.

◆ m_fieldCorRegion

Gaudi::Property<unsigned> FPGATrackSimKeyLayerBinDesc::m_fieldCorRegion { this, "fieldCorRegion", 2, "region for fieldCorrection"}

private

Definition at line 153 of file FPGATrackSimKeyLayerBinDesc.h.

◆ m_keylyrtool

FPGATrackSimKeyLayerTool FPGATrackSimKeyLayerBinDesc::m_keylyrtool

private

Definition at line 166 of file FPGATrackSimKeyLayerBinDesc.h.

◆ m_parNames

const std::vector<std::string> FPGATrackSimKeyLayerBinDesc::m_parNames {"zR1", "zR2", "phiR1", "phiR2", "xm"}

private

Definition at line 167 of file FPGATrackSimKeyLayerBinDesc.h.

◆ m_phiOffset

Gaudi::Property<double> FPGATrackSimKeyLayerBinDesc::m_phiOffset {this, "PhiOffset", 0.0, "Phi offset between local and global parameters (avoids phi wrap around effects in region code)"}

private

Definition at line 151 of file FPGATrackSimKeyLayerBinDesc.h.

◆ m_phipad

Gaudi::Property<double> FPGATrackSimKeyLayerBinDesc::m_phipad {this, "PhiPad", 0.0, "Extra phi padding from phi resolution"}

private

Definition at line 138 of file FPGATrackSimKeyLayerBinDesc.h.

◆ m_phipars

const std::vector<unsigned> FPGATrackSimKeyLayerBinDesc::m_phipars {2, 3, 4}

private

Definition at line 169 of file FPGATrackSimKeyLayerBinDesc.h.

◆ m_qptpad

Gaudi::Property<double> FPGATrackSimKeyLayerBinDesc::m_qptpad {this, "QPtPad", 0.0, "Extra phi padding from q/pT resolution"}

private

Definition at line 139 of file FPGATrackSimKeyLayerBinDesc.h.

◆ m_region

Gaudi::Property<unsigned> FPGATrackSimKeyLayerBinDesc::m_region {this, "region", 0, "Region number, needed to write out lookup tables for test vectors"}

private

Definition at line 142 of file FPGATrackSimKeyLayerBinDesc.h.

◆ m_rin

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

private

Definition at line 134 of file FPGATrackSimKeyLayerBinDesc.h.

◆ m_rout

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

private

Definition at line 135 of file FPGATrackSimKeyLayerBinDesc.h.

◆ m_slPerEtaMod

Gaudi::Property<std::vector<double> > FPGATrackSimKeyLayerBinDesc::m_slPerEtaMod

private

Initial value:

{
    this,
        "slPerEtaMod",
        std::vector<double>{19.0, 24.0, 29.0, 32.0, 18.1, 27.1, 24.1, 15.1, 30.8,
                            30.8, 26.2, 32.2, 32.2, 26.2, 54.6, 54.6, 40.2, 60.2},
        "Strip length per eta eta mod"
    }

Definition at line 143 of file FPGATrackSimKeyLayerBinDesc.h.

◆ m_z0pad

Gaudi::Property<double> FPGATrackSimKeyLayerBinDesc::m_z0pad {this, "Z0Pad", 0.0, "Extra eta padding from z0 resolution"}

private

Definition at line 140 of file FPGATrackSimKeyLayerBinDesc.h.

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

Classes

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Member Function Documentation

◆ etaResidual()

◆ getEtaLUTConsts()

◆ getPhiLUTConsts()

◆ hitInBin()

◆ initialize()

◆ keyparsToParSet()

◆ parNames()

◆ parSetToKeyPars()

◆ parSetToTrackPars()

◆ phiResidual()

◆ stepIsREta()

◆ stepIsRPhi()

◆ trackParsToParSet()

◆ writeLUTs()

Member Data Documentation

◆ m_approxMath

◆ m_d0pad

◆ m_etapad

◆ m_etapars

◆ m_fieldCorrection

◆ m_fieldCorRegion

◆ m_keylyrtool

◆ m_parNames

◆ m_phiOffset

◆ m_phipad

◆ m_phipars

◆ m_qptpad

◆ m_region

◆ m_rin

◆ m_rout

◆ m_slPerEtaMod

◆ m_z0pad