FPGATrackSimKeyLayerBinDesc Class Reference

#include <FPGATrackSimKeyLayerBinDesc.h>

Inheritance diagram for FPGATrackSimKeyLayerBinDesc:

Collaboration diagram for FPGATrackSimKeyLayerBinDesc:

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
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< std::vector< double > >	m_slPerEtaMod
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 76 of file FPGATrackSimKeyLayerBinDesc.h.

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

hitInBin()

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

overridevirtual

Definition at line 40 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.get());
        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_DEBUG("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);
    }
 
    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);        
    }
   
    
    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 24 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 116 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.

{ return m_parNames[i]; }

parSetToKeyPars()

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

inlineprivate

Definition at line 119 of file FPGATrackSimKeyLayerBinDesc.h.

                                                                                                      {
      return FPGATrackSimKeyLayerTool::KeyLyrPars(parset);
    }

parSetToTrackPars()

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

inlineoverridevirtual

Definition at line 65 of file FPGATrackSimKeyLayerBinDesc.h.

                                                                                                                  {
      return m_keylyrtool.keyParsToTrackPars(parSetToKeyPars(parset));
    }

phiResidual()

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

inlineoverridevirtual

Definition at line 72 of file FPGATrackSimKeyLayerBinDesc.h.

                                                                                                                   {
        return m_keylyrtool.deltaX(parSetToKeyPars(parset), hit);
    }

stepIsREta()

bool FPGATrackSimKeyLayerBinDesc::stepIsREta

(

const FPGATrackSimBinStep &

step

)

const

Definition at line 139 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 128 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());
      }
      return keyparsToParSet(keypars);
    }

writeLUTs()

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

overridevirtual

Definition at line 155 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()) {
    FPGATrackSimBinUtil::StreamManager sm("KeyLayer");
    sm.writeVar("r_in",r_in);
    sm.writeVar("r_out",r_out);
  }
 
  if (stepIsRPhi(step)) {
 
    FPGATrackSimBinUtil::StreamManager sm(step.stepName());
    int nbins = 0;
    for (FPGATrackSimBinArray<int>::ConstIterator &bin : step.validBinsLocal()) {
      if (!bin.data())
        continue;      
 
      sm.writeVar("phi_bin", bin.idx());
 
      FPGATrackSimKeyLayerTool::KeyLyrPars keypars;
      keypars.phi1 = step.binCenter(2,bin.idx()[0]);
      keypars.phi2 = step.binCenter(3,bin.idx()[1]);
      keypars.xm = step.binCenter(4, bin.idx()[2]);
 
      auto rotated_coords = m_keylyrtool.getRotatedConfig(keypars);
 
      sm.writeVar("y", rotated_coords.y);
      sm.writeVar("x1p", rotated_coords.xy1p.first);
      sm.writeVar("y1p", rotated_coords.xy1p.second);
      sm.writeVar("cosb", rotated_coords.rotang.first);
      sm.writeVar("sinb", rotated_coords.rotang.second);
 
      sm.writeVar("x_m", keypars.xm);
      sm.writeVar("x_factor", 4.0 * keypars.xm / (rotated_coords.y * rotated_coords.y));
 
      nbins++;
    }
 
    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;
    double dw_dr = (w_out - w_in) / (r_out - r_in);
 
    sm.writeVar("w_x", 4.0 * w_x / ((r_out - r_in) * (r_out - r_in)));
    sm.writeVar("w_in", w_in);
    sm.writeVar("dw_dr", dw_dr);
 
    sm.writeVar("nbins", nbins);
  }
 
  if (stepIsREta(step)) {
 
    FPGATrackSimBinUtil::StreamManager sm(step.stepName());
 
    int nbins = 0;
    for (FPGATrackSimBinArray<int>::ConstIterator &bin : step.validBinsLocal()) {
      if (!bin.data())
        continue;
 
      // write just this steps idxs
      sm.writeVar("z_bin", bin.idx());
 
      double z_in = step.binCenter(0, bin.idx()[0]);
      double z_out = step.binCenter(1, bin.idx()[1]);
      double dz_dr = (z_out - z_in) / (r_out - r_in);
      
      sm.writeVar("z_in", z_in);
      sm.writeVar("dz_dr", dz_dr);
    
      nbins++;
    }
    sm.writeVar("nbins", nbins);
 
    // same for all bins
    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);
    sm.writeVar("w_in", w_in);
    sm.writeVar("dw_dr", dw_dr);
 
  }
 
    
 
 
}

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 96 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 97 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 101 of file FPGATrackSimKeyLayerBinDesc.h.

m_etapars

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

private

Definition at line 128 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 112 of file FPGATrackSimKeyLayerBinDesc.h.

m_fieldCorRegion

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

private

Definition at line 111 of file FPGATrackSimKeyLayerBinDesc.h.

m_keylyrtool

FPGATrackSimKeyLayerTool FPGATrackSimKeyLayerBinDesc::m_keylyrtool

private

Definition at line 124 of file FPGATrackSimKeyLayerBinDesc.h.

m_parNames

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

private

Definition at line 125 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 98 of file FPGATrackSimKeyLayerBinDesc.h.

m_phipars

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

private

Definition at line 127 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 99 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 94 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 95 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 102 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 100 of file FPGATrackSimKeyLayerBinDesc.h.

---

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

• FPGATrackSimKeyLayerBinDesc.h
• FPGATrackSimKeyLayerBinDesc.cxx