tmtt::SimpleLR4 Class Reference

#include <SimpleLR4.h>

Inheritance diagram for tmtt::SimpleLR4:

Public Member Functions
L1fittedTrack	fit (const L1track3D &l1track3D) override
	SimpleLR4 (const Settings *settings)
	~SimpleLR4 () override=default
Public Member Functions inherited from tmtt::TrackFitGeneric
	TrackFitGeneric (const Settings *settings, const std::string &fitterName="")
virtual	~TrackFitGeneric ()=default

Protected Attributes
float	chi2cut_
float	chi2Mult_
float	chosenRofPhi_
bool	debug_
float	denominatorMult_
bool	digitize_
unsigned int	dividerBitsChi2_
unsigned int	dividerBitsHelix_
unsigned int	dividerBitsHelixZ_
float	invPtToDPhi_
unsigned int	minStubLayersRed_
float	numeratorLambdaMult_
float	numeratorPhiMult_
float	numeratorPtMult_
float	numeratorZ0Mult_
float	phiMult_
float	phiNonantWidth_
float	phiSectorCentre_
float	phiSectorWidth_
float	phiTMult_
float	qOverPtMult_
float	resMult_
float	rTMult_
unsigned int	shiftingBitsDenRPhi_
unsigned int	shiftingBitsDenRZ_
unsigned int	shiftingBitsLambda_
unsigned int	shiftingBitsPhi_
unsigned int	shiftingBitsPt_
unsigned int	shiftingBitsz0_
float	tanLambdaMult_
float	z0Mult_
float	zMult_
Protected Attributes inherited from tmtt::TrackFitGeneric
const std::string	fitterName_
const Settings *	settings_

Detailed Description

Definition at line 20 of file SimpleLR4.h.

Constructor & Destructor Documentation

SimpleLR4()

tmtt::SimpleLR4::SimpleLR4

(

const Settings *

settings

)

Definition at line 21 of file SimpleLR4.cc.

References chi2cut_, chi2Mult_, tmtt::Settings::chosenRofPhi(), chosenRofPhi_, debug_, denominatorMult_, digitize_, tmtt::Settings::digitizeSLR(), tmtt::Settings::dividerBitsHelix(), dividerBitsHelix_, tmtt::Settings::dividerBitsHelixZ(), dividerBitsHelixZ_, tmtt::Settings::enableDigitize(), nano_mu_digi_cff::float, M_PI, numeratorLambdaMult_, numeratorPhiMult_, numeratorPtMult_, numeratorZ0Mult_, tmtt::Settings::numPhiNonants(), tmtt::Settings::numPhiSectors(), phiMult_, phiNonantWidth_, tmtt::Settings::phiSBits(), phiSectorWidth_, tmtt::Settings::phiSRange(), phiTMult_, funct::pow(), qOverPtMult_, resMult_, tmtt::Settings::rtBits(), rTMult_, tmtt::Settings::rtRange(), tmtt::TrackFitGeneric::settings_, tmtt::Settings::ShiftingBitsDenRPhi(), shiftingBitsDenRPhi_, tmtt::Settings::ShiftingBitsDenRZ(), shiftingBitsDenRZ_, tmtt::Settings::ShiftingBitsLambda(), shiftingBitsLambda_, tmtt::Settings::ShiftingBitsPhi(), shiftingBitsPhi_, tmtt::Settings::ShiftingBitsPt(), shiftingBitsPt_, tmtt::Settings::ShiftingBitsZ0(), shiftingBitsz0_, tmtt::Settings::slr_chi2cut(), tmtt::Settings::slr_chisquaredBits(), tmtt::Settings::slr_chisquaredRange(), tmtt::Settings::slr_oneOver2rBits(), tmtt::Settings::slr_oneOver2rRange(), tmtt::Settings::slr_phi0Bits(), tmtt::Settings::slr_phi0Range(), tmtt::Settings::slr_tanlambdaBits(), tmtt::Settings::slr_tanlambdaRange(), tmtt::Settings::slr_z0Bits(), tmtt::Settings::slr_z0Range(), tanLambdaMult_, z0Mult_, tmtt::Settings::zBits(), zMult_, and tmtt::Settings::zRange().

                                               : TrackFitGeneric(settings) {
    // Initialize digitization parameters
    phiMult_ = pow(2., settings_->phiSBits()) / settings_->phiSRange();
    rTMult_ = pow(2., settings_->rtBits()) / settings_->rtRange();
    zMult_ = pow(2., settings_->zBits()) / settings_->zRange();
    z0Mult_ = pow(2., settings_->slr_z0Bits()) / settings_->slr_z0Range();
    phiTMult_ = pow(2., settings_->slr_phi0Bits()) / settings_->slr_phi0Range();

    qOverPtMult_ = pow(2., settings_->slr_oneOver2rBits()) / settings_->slr_oneOver2rRange();
    tanLambdaMult_ = pow(2., settings_->slr_tanlambdaBits()) / settings_->slr_tanlambdaRange();
    chi2Mult_ = pow(2., settings_->slr_chisquaredBits()) / settings_->slr_chisquaredRange();

    numeratorPtMult_ = rTMult_ * phiMult_;
    numeratorPhiMult_ = rTMult_ * rTMult_ * phiMult_;
    numeratorZ0Mult_ = rTMult_ * rTMult_ * z0Mult_;
    numeratorLambdaMult_ = rTMult_ * z0Mult_;
    denominatorMult_ = rTMult_ * rTMult_;
    resMult_ = rTMult_ * qOverPtMult_;

    dividerBitsHelix_ = settings_->dividerBitsHelix();
    dividerBitsHelixZ_ = settings_->dividerBitsHelixZ();
    shiftingBitsDenRPhi_ = settings_->ShiftingBitsDenRPhi();
    shiftingBitsDenRZ_ = settings_->ShiftingBitsDenRZ();
    shiftingBitsPhi_ = settings_->ShiftingBitsPhi();
    shiftingBitsz0_ = settings_->ShiftingBitsZ0();
    shiftingBitsPt_ = settings_->ShiftingBitsPt();
    shiftingBitsLambda_ = settings_->ShiftingBitsLambda();
    digitize_ = settings_->digitizeSLR() and settings_->enableDigitize();

    phiSectorWidth_ = 2. * M_PI / float(settings_->numPhiSectors());
    phiNonantWidth_ = 2. * M_PI / float(settings_->numPhiNonants());

    chi2cut_ = settings_->slr_chi2cut();
    chosenRofPhi_ = settings_->chosenRofPhi();
    if (digitize_)
      chosenRofPhi_ = floor(chosenRofPhi_ * rTMult_) / rTMult_;

    debug_ = false;  // Enable debug printout.
  };

~SimpleLR4()

tmtt::SimpleLR4::~SimpleLR4 ( )

overridedefault

Member Function Documentation

fit()

L1fittedTrack tmtt::SimpleLR4::fit ( const L1track3D &  l1track3D )

overridevirtual

Reimplemented from tmtt::TrackFitGeneric.

Definition at line 65 of file SimpleLR4.cc.

References funct::abs(), tmtt::L1fittedTrack::cellLocationFit(), tmtt::L1track3D::cellLocationHT(), tmtt::L1fittedTrack::cellLocationHT(), nano_mu_local_reco_cff::chi2, chi2cut_, chi2Mult_, tmtt::Settings::chosenRofPhi(), ALPAKA_ACCELERATOR_NAMESPACE::brokenline::constexpr(), debug_, reco::deltaPhi(), bTagMiniDQMDeepCSV::denominator, denominatorMult_, tmtt::L1fittedTrack::digitaltrack(), digitize_, tmtt::L1fittedTrack::digitizeTrack(), dividerBitsHelix_, dividerBitsHelixZ_, tmtt::Settings::enableDigitize(), tmtt::L1track3D::eta(), tmtt::Utility::FIT, tmtt::Settings::houghMinPt(), tmtt::DigitalTrack::iDigi_phi0rel(), tmtt::DigitalStub::iDigi_PhiS(), tmtt::DigitalStub::iDigi_Rt(), tmtt::DigitalStub::iDigi_Z(), tmtt::L1track3D::iEtaReg(), createfilelist::int, tmtt::Settings::invPtToDphi(), invPtToDPhi_, tmtt::L1track3D::iPhiSec(), M_PI, tmtt::L1fittedTrack::matchedTP(), minStubLayersRed_, numeratorLambdaMult_, numeratorPhiMult_, numeratorPtMult_, numeratorZ0Mult_, tmtt::Utility::numLayerCut(), tmtt::L1fittedTrack::numLayers(), tmtt::Settings::numPhiSectors(), tmtt::DigitalTrack::oneOver2r(), tmtt::pair_compare(), tmtt::DigitalTrack::phi0(), tmtt::TP::phi0(), phiMult_, phiNonantWidth_, tmtt::DigitalStub::phiS(), tmtt::Settings::phiSBits(), phiSectorCentre_, phiSectorWidth_, phiTMult_, funct::pow(), tmtt::TP::qOverPt(), tmtt::L1track3D::qOverPt(), tmtt::L1fittedTrack::qOverPt(), qOverPtMult_, tmtt::Settings::ResidualCut(), resMult_, tmtt::DigitalStub::rt_SF_TF(), tmtt::TrackFitGeneric::settings_, shiftingBitsDenRPhi_, shiftingBitsDenRZ_, shiftingBitsLambda_, shiftingBitsPhi_, shiftingBitsPt_, shiftingBitsz0_, tmtt::Settings::slr_phi0Bits(), tmtt::L1track3D::stubs(), tanLambdaMult_, tolerance, PixelMapPlotter::vRes, tmtt::DigitalStub::z(), and z0Mult_.

Referenced by trackingPlots.Iteration::modules().

                                                         {
    if (debug_)
      PrintL1trk() << "=============== FITTING SimpleLR TRACK ====================";

    minStubLayersRed_ = Utility::numLayerCut(Utility::AlgoStep::FIT,
                                             settings_,
                                             l1track3D.iPhiSec(),
                                             l1track3D.iEtaReg(),
                                             std::abs(l1track3D.qOverPt()),
                                             l1track3D.eta());

    invPtToDPhi_ = -settings_->invPtToDphi();

    double phiCentreSec0 = -0.5 * phiNonantWidth_ + 0.5 * phiSectorWidth_;
    phiSectorCentre_ = phiSectorWidth_ * double(l1track3D.iPhiSec()) - phiCentreSec0;

    if (digitize_)
      phiSectorCentre_ = floor(phiSectorCentre_ * phiTMult_) / phiTMult_;

    // Inizialise track fit parameters
    double qOverPt = 0.;
    double phiT = 0.;
    double phi0 = 0.;
    double z0 = 0.;
    double zT = 0.;
    double tanLambda = 0.;

    // Inizialise Sums
    double SumRPhi = 0.;
    double SumR = 0.;
    double SumPhi = 0.;
    double SumR2 = 0.;
    double SumRZ = 0.;
    double SumZ = 0.;

    unsigned int numStubs = 0;
    // Calc helix parameters on Rphi Plane (STEP 1)
    // This loop calculates the sums needed to calculate the numerators and the denominator to compute the helix parameters in the R-Phi plane (q/pT, phiT)
    for (Stub* stub : l1track3D.stubs()) {
      numStubs++;

      if (digitize_) {
        const DigitalStub* digiStub = stub->digitalStub();

        SumRPhi = SumRPhi + digiStub->rt_SF_TF() * digiStub->phiS();
        SumR = SumR + digiStub->rt_SF_TF();
        SumPhi = SumPhi + digiStub->phiS();
        SumR2 = SumR2 + digiStub->rt_SF_TF() * digiStub->rt_SF_TF();
        if (debug_)
          PrintL1trk() << "Input stub (digi): phiS " << digiStub->iDigi_PhiS() << " rT " << digiStub->iDigi_Rt()
                       << " z " << digiStub->iDigi_Z();
      } else {
        float phi = 0;
        if (l1track3D.iPhiSec() == 0 and stub->phi() > 0) {
          phi = stub->phi() - 2 * M_PI;
        } else if (l1track3D.iPhiSec() == settings_->numPhiSectors() and stub->phi() < 0) {
          phi = stub->phi() + 2 * M_PI;
        } else {
          phi = stub->phi();
        }
        SumRPhi = SumRPhi + stub->r() * phi;
        SumR = SumR + stub->r();
        SumPhi = SumPhi + phi;
        SumR2 = SumR2 + stub->r() * stub->r();
        if (debug_)
          PrintL1trk() << "InputStub (float): phi " << phi << " r " << stub->r() << " z " << stub->z();
      }
    }

    double numeratorPt, digiNumeratorPt;
    double denominator, digiDenominator;
    double numeratorPhi, digiNumeratorPhi;
    double reciprocal, digiReciprocal;
    double numeratorZ0;
    double numeratorLambda;

    digiNumeratorPt = (numStubs * SumRPhi - SumR * SumPhi);
    digiDenominator = (numStubs * SumR2 - SumR * SumR);
    digiNumeratorPhi = (SumR2 * SumPhi - SumR * SumRPhi);

    if (!digitize_) {
      qOverPt = (numStubs * SumRPhi - SumR * SumPhi) / (numStubs * SumR2 - SumR * SumR);
      phi0 = (SumR2 * SumPhi - SumR * SumRPhi) / (numStubs * SumR2 - SumR * SumR);
    } else {
      digiNumeratorPt /= pow(2., shiftingBitsPt_);
      digiNumeratorPt = floor(digiNumeratorPt * numeratorPtMult_);
      numeratorPt = digiNumeratorPt / numeratorPtMult_;

      digiNumeratorPhi /= pow(2., shiftingBitsPhi_);
      digiNumeratorPhi = floor(digiNumeratorPhi * numeratorPhiMult_);
      numeratorPhi = digiNumeratorPhi / numeratorPhiMult_;

      digiDenominator /= pow(2., shiftingBitsDenRPhi_);
      digiDenominator = (floor(digiDenominator * denominatorMult_) + 0.5);
      denominator = digiDenominator / denominatorMult_;
      digiReciprocal = (pow(2., dividerBitsHelix_) - 1) / (denominator);  // To be moved
      digiReciprocal = floor(digiReciprocal / denominatorMult_);
      reciprocal = digiReciprocal * denominatorMult_;

      qOverPt = numeratorPt * reciprocal / pow(2., dividerBitsHelix_ + shiftingBitsDenRPhi_ - shiftingBitsPt_);
      phiT = numeratorPhi * reciprocal / pow(2., dividerBitsHelix_ + shiftingBitsDenRPhi_ - shiftingBitsPhi_);

      qOverPt = floor(qOverPt * qOverPtMult_) / (qOverPtMult_);
      phiT = floor(phiT * phiTMult_) / phiTMult_;
    }

    if (debug_) {
      if (digitize_) {
        PrintL1trk() << setw(10) << "Input helix (digi): qOverPt = " << qOverPt << " (" << floor(qOverPt * qOverPtMult_)
                     << "), phiT = " << phiT << " (" << floor(phiT * phiTMult_) << ") ";
      } else {
        PrintL1trk() << "Input Helix (float): qOverPt = " << qOverPt << " phi0 " << phi0;
      }
    }

    // ================== RESIDUAL CALCULATION ON RPHI ========================
    std::vector<std::pair<Stub*, double> > vRes;
    unsigned int psStubs = 0;
    for (Stub* stub : l1track3D.stubs()) {
      if (stub->psModule())
        psStubs++;
      double ResPhi;

      if (digitize_) {
        const DigitalStub* digiStub = stub->digitalStub();

        ResPhi =
            digiStub->iDigi_PhiS() * pow(2., shiftingBitsDenRPhi_ - shiftingBitsPt_) -
            floor(phiT * phiTMult_) *
                pow(2., shiftingBitsDenRPhi_ - shiftingBitsPt_ - settings_->slr_phi0Bits() + settings_->phiSBits()) -
            floor(qOverPt * qOverPtMult_) * digiStub->iDigi_Rt();

        ResPhi = floor(ResPhi) / resMult_;
      }

      else {
        ResPhi = reco::deltaPhi(stub->phi(), phi0 + qOverPt * stub->r());
      }

      double Res = std::abs(ResPhi);

      std::pair<Stub*, double> ResStubPair(stub, Res);
      vRes.push_back(ResStubPair);
      if (debug_) {
        if (stub->assocTP() != nullptr)
          PrintL1trk() << " Stub rphi residual " << Res << " TP " << stub->assocTP()->index();
        else
          PrintL1trk() << " Stub rphi residual " << Res << " TP nullptr";
      }
    }

    double largestResidual = 9999.;
    // Find largest residuals
    while (vRes.size() > minStubLayersRed_ and largestResidual > settings_->ResidualCut()) {
      std::vector<std::pair<Stub*, double> >::iterator maxResIt = max_element(vRes.begin(), vRes.end(), pair_compare);
      largestResidual = (*maxResIt).second;
      if (debug_)
        PrintL1trk() << "Largest Residual " << largestResidual;

      if (largestResidual > settings_->ResidualCut()) {
        if ((*maxResIt).first->psModule()) {
          if (psStubs > 2) {
            if (debug_)
              PrintL1trk() << "removing PS residual " << (*maxResIt).second;
            vRes.erase(maxResIt);
            psStubs--;
          } else {
            if (debug_)
              PrintL1trk() << "residual " << (*maxResIt).second << " set to -1. ";
            (*maxResIt).second = -1.;
          }
        } else {
          vRes.erase(maxResIt);
          if (debug_)
            PrintL1trk() << "removing residual " << (*maxResIt).second;
        }
      }
    }

    std::vector<Stub*> fitStubs;
    fitStubs.reserve(vRes.size());
    for (std::pair<Stub*, double> ResStubPair : vRes) {
      fitStubs.push_back(ResStubPair.first);
    }

    phiT = 0.;
    zT = 0.;

    SumRPhi = 0.;
    SumR = 0.;
    SumPhi = 0.;
    SumR2 = 0.;
    SumRZ = 0.;
    SumZ = 0.;
    double SumR_ps = 0.;
    double SumR2_ps = 0.;

    numStubs = 0;
    psStubs = 0;

    for (const Stub* stub : fitStubs) {
      if (stub->psModule())
        psStubs++;

      numStubs++;
      if (digitize_) {
        const DigitalStub* digiStub = stub->digitalStub();
        SumRPhi += digiStub->rt_SF_TF() * digiStub->phiS();
        SumR += digiStub->rt_SF_TF();
        SumPhi += digiStub->phiS();
        SumR2 += digiStub->rt_SF_TF() * digiStub->rt_SF_TF();
        if (stub->psModule()) {
          SumRZ += digiStub->rt_SF_TF() * digiStub->z();
          SumZ += digiStub->z();
          SumR_ps += digiStub->rt_SF_TF();
          SumR2_ps += digiStub->rt_SF_TF() * digiStub->rt_SF_TF();
        }
        if (debug_) {
          PrintL1trk() << "phiS " << digiStub->iDigi_PhiS() << " rT " << digiStub->iDigi_Rt() << " z "
                       << digiStub->iDigi_Z();
        }
      } else {
        float phi = 0;
        if (l1track3D.iPhiSec() == 0 and stub->phi() > 0) {
          phi = stub->phi() - 2 * M_PI;
        } else if (l1track3D.iPhiSec() == settings_->numPhiSectors() and stub->phi() < 0) {
          phi = stub->phi() + 2 * M_PI;
        } else {
          phi = stub->phi();
        }

        SumRPhi += stub->r() * phi;
        SumR += stub->r();
        SumPhi += phi;
        SumR2 += stub->r() * stub->r();
        if (stub->psModule()) {
          SumRZ += stub->r() * stub->z();
          SumZ += stub->z();
          SumR_ps += stub->r();
          SumR2_ps += stub->r() * stub->r();
        }
        if (debug_)
          PrintL1trk() << "phi " << phi << " r " << stub->r() << " z " << stub->z();
      }
    }

    numeratorZ0 = (SumR2_ps * SumZ - SumR_ps * SumRZ);
    numeratorLambda = (psStubs * SumRZ - SumR_ps * SumZ);
    numeratorPt = (numStubs * SumRPhi - SumR * SumPhi);
    denominator = (numStubs * SumR2 - SumR * SumR);
    double denominatorZ = (psStubs * SumR2_ps - SumR_ps * SumR_ps);
    numeratorPhi = (SumR2 * SumPhi - SumR * SumRPhi);
    double reciprocalZ;
    if (!digitize_) {
      z0 = numeratorZ0 / denominatorZ;
      tanLambda = numeratorLambda / denominatorZ;
      qOverPt = (numStubs * SumRPhi - SumR * SumPhi) / (numStubs * SumR2 - SumR * SumR);
      phi0 = (SumR2 * SumPhi - SumR * SumRPhi) / (numStubs * SumR2 - SumR * SumR);
    } else {
      numeratorPt /= pow(2., shiftingBitsPt_);
      numeratorPt = floor(numeratorPt * numeratorPtMult_) / numeratorPtMult_;

      numeratorPhi /= pow(2., shiftingBitsPhi_);
      numeratorPhi = floor(numeratorPhi * numeratorPhiMult_) / numeratorPhiMult_;

      numeratorLambda /= pow(2., shiftingBitsLambda_);
      numeratorLambda = floor(numeratorLambda * numeratorLambdaMult_) / numeratorLambdaMult_;

      numeratorZ0 /= pow(2., shiftingBitsz0_);
      numeratorZ0 = floor(numeratorZ0 * numeratorZ0Mult_) / numeratorZ0Mult_;

      denominator /= pow(2., shiftingBitsDenRPhi_);
      denominator = (floor(denominator * denominatorMult_) + 0.5) / denominatorMult_;
      reciprocal = (pow(2., dividerBitsHelix_) - 1) / (denominator);
      reciprocal = floor(reciprocal / denominatorMult_) * denominatorMult_;

      denominatorZ /= pow(2., shiftingBitsDenRZ_);
      denominatorZ = (floor(denominatorZ * denominatorMult_) + 0.5) / denominatorMult_;
      reciprocalZ = (pow(2., dividerBitsHelixZ_) - 1) / (denominatorZ);
      reciprocalZ = floor(reciprocalZ / denominatorMult_) * denominatorMult_;

      qOverPt = numeratorPt * reciprocal / pow(2., dividerBitsHelix_ + shiftingBitsDenRPhi_ - shiftingBitsPt_);
      phiT = numeratorPhi * reciprocal / pow(2., dividerBitsHelix_ + shiftingBitsDenRPhi_ - shiftingBitsPhi_);

      tanLambda =
          numeratorLambda * reciprocalZ / pow(2., dividerBitsHelixZ_ + shiftingBitsDenRZ_ - shiftingBitsLambda_);
      zT = numeratorZ0 * reciprocalZ / pow(2., dividerBitsHelixZ_ + shiftingBitsDenRZ_ - shiftingBitsz0_);

      phi0 = phiSectorCentre_ + phiT - qOverPt * settings_->chosenRofPhi();
      z0 = zT - tanLambda * settings_->chosenRofPhi();

      qOverPt = floor(qOverPt * qOverPtMult_) / qOverPtMult_;
      phiT = floor(phiT * phiTMult_) / phiTMult_;
    }

    if (debug_ and digitize_) {
      PrintL1trk() << "HT mbin " << int(l1track3D.cellLocationHT().first) - 16 << " cbin "
                   << int(l1track3D.cellLocationHT().second) - 32 << " iPhi " << l1track3D.iPhiSec() << " iEta "
                   << l1track3D.iEtaReg();
      PrintL1trk() << "Second Helix variables: numeratorPt = " << numeratorPt << ", numeratorPhi = " << numeratorPhi
                   << ", numeratorZ0 = " << numeratorZ0 << " numeratorLambda = " << numeratorLambda
                   << " denominator =  " << denominator << " reciprocal = " << reciprocal
                   << " denominatorZ =  " << denominatorZ << " reciprocalZ = " << reciprocalZ;
      PrintL1trk() << setw(10) << "Final Helix parameters: qOverPt = " << qOverPt << " ("
                   << floor(qOverPt * qOverPtMult_) << "), phiT = " << phiT << " (" << floor(phiT * phiTMult_)
                   << "), zT = " << zT << " (" << floor(zT * z0Mult_) << "), tanLambda = " << tanLambda << " ("
                   << floor(tanLambda * tanLambdaMult_) << ")"
                   << " z0 " << z0;
    } else if (debug_) {
      PrintL1trk() << setw(10) << "Final Helix parameters: qOverPt = " << qOverPt << ", phi0 = " << phi0
                   << ", z0 = " << z0 << ", tanLambda = " << tanLambda;
    }

    double chi2_phi = 0.;
    double chi2_z = 0.;

    for (const Stub* stub : fitStubs) {
      double ResPhi = 0.;
      double ResZ = 0.;
      if (digitize_) {
        const DigitalStub* digiStub = stub->digitalStub();
        ResPhi = digiStub->phiS() - phiT - qOverPt * digiStub->rt_SF_TF();
        ResZ = digiStub->z() - zT - tanLambda * digiStub->rt_SF_TF();
      } else {
        ResPhi = reco::deltaPhi(stub->phi(), phi0 + qOverPt * stub->r());
        ResZ = stub->z() - z0 - tanLambda * stub->r();
      }

      double RPhiSigma = 0.0002;
      float RZSigma = stub->sigmaZ() + std::abs(tanLambda) * stub->sigmaR();

      if (not stub->barrel())
        RPhiSigma = 0.0004;

      if (digitize_) {
        RPhiSigma = floor(RPhiSigma * phiMult_) / phiMult_;
      }

      ResPhi /= RPhiSigma;
      ResZ /= RZSigma;

      chi2_phi += std::abs(ResPhi * ResPhi);
      chi2_z += std::abs(ResZ * ResZ);
      if (debug_) {
        PrintL1trk() << "Stub ResPhi " << ResPhi * RPhiSigma << " ResSigma " << RPhiSigma << " Res " << ResPhi
                     << " chi2 " << chi2_phi;
        PrintL1trk() << "Stub ResZ " << ResZ * RZSigma << " ResSigma " << RZSigma << " Res " << ResZ << " chi2 "
                     << chi2_z;
      }
    }
    qOverPt /= invPtToDPhi_;

    bool accepted = false;

    //double chi2 = chi2_phi;  // Ignore r-z residuals due to poor 2S resolution?
    double chi2 = chi2_phi + chi2_z;
    if (digitize_)
      chi2 = floor(chi2 * chi2Mult_) / chi2Mult_;

    constexpr unsigned int nHelixPar = 4;
    float dof = 2 * fitStubs.size() - nHelixPar;
    float chi2dof = chi2 / dof;
    if (chi2 < chi2cut_)
      accepted = true;

    if (debug_)
      PrintL1trk() << "qOverPt " << qOverPt << " phiT " << phiT;

    // This condition can only happen if cfg param TrackFitCheat = True.
    if (fitStubs.size() < minStubLayersRed_)
      accepted = false;

    // Kinematic cuts -- NOT YET IN FIRMWARE!!!
    constexpr float tolerance = 0.1;
    if (std::abs(qOverPt) > 1. / (settings_->houghMinPt() - tolerance))
      accepted = false;
    if (std::abs(z0) > 20.)
      accepted = false;

    if (accepted) {
      // Create the L1fittedTrack object
      const unsigned int hitPattern = 0;  // FIX: Needs setting
      L1fittedTrack fitTrk(
          settings_, &l1track3D, fitStubs, hitPattern, qOverPt, 0., phi0, z0, tanLambda, chi2_phi, chi2_z, nHelixPar);

      if (settings_->enableDigitize())
        fitTrk.digitizeTrack("SimpleLR4");

      if (debug_ and digitize_) {
        PrintL1trk() << "Digitized parameters ";
        PrintL1trk() << "HT mbin " << int(l1track3D.cellLocationHT().first) - 16 << " cbin "
                     << int(l1track3D.cellLocationHT().second) - 32 << " iPhi " << l1track3D.iPhiSec() << " iEta "
                     << l1track3D.iEtaReg();
        PrintL1trk() << setw(10) << "First Helix parameters: qOverPt = " << fitTrk.qOverPt() << " oneOver2r "
                     << fitTrk.digitaltrack()->oneOver2r() << " ("
                     << floor(fitTrk.digitaltrack()->oneOver2r() * qOverPtMult_)
                     << "), phi0 = " << fitTrk.digitaltrack()->phi0() << " (" << fitTrk.digitaltrack()->iDigi_phi0rel()
                     << "), zT = " << zT << " (" << floor(zT * z0Mult_) << "), tanLambda = " << tanLambda << " ("
                     << floor(tanLambda * tanLambdaMult_) << ")";
      }

      if (debug_) {
        PrintL1trk() << "FitTrack helix parameters " << int(fitTrk.cellLocationFit().first) - 16 << ", "
                     << int(fitTrk.cellLocationFit().second) - 32 << " HT parameters "
                     << int(fitTrk.cellLocationHT().first) - 16 << ", " << int(fitTrk.cellLocationHT().second) - 32;

        if (fitTrk.matchedTP() != nullptr) {
          PrintL1trk() << "True track: chi2/ndf " << chi2dof;
          PrintL1trk() << "TP qOverPt " << fitTrk.matchedTP()->qOverPt() << " phi0 " << fitTrk.matchedTP()->phi0();
          if (!accepted)
            PrintL1trk() << "Track rejected " << chi2 << " chi2/ndof " << chi2dof;
        } else {
          PrintL1trk() << "Fake track!!! " << chi2 << " chi2/ndof " << chi2dof;
        }
        PrintL1trk() << "layers in track " << fitTrk.numLayers();
      }

      return fitTrk;

    } else {
      L1fittedTrack rejectedTrk;
      return rejectedTrk;
    }
  }

Member Data Documentation

chi2cut_

float tmtt::SimpleLR4::chi2cut_

protected

Definition at line 47 of file SimpleLR4.h.

Referenced by fit(), and SimpleLR4().

chi2Mult_

float tmtt::SimpleLR4::chi2Mult_

protected

Definition at line 45 of file SimpleLR4.h.

Referenced by fit(), and SimpleLR4().

chosenRofPhi_

float tmtt::SimpleLR4::chosenRofPhi_

protected

Definition at line 49 of file SimpleLR4.h.

Referenced by SimpleLR4().

debug_

bool tmtt::SimpleLR4::debug_

protected

Definition at line 63 of file SimpleLR4.h.

Referenced by fit(), and SimpleLR4().

denominatorMult_

float tmtt::SimpleLR4::denominatorMult_

protected

Definition at line 44 of file SimpleLR4.h.

Referenced by fit(), and SimpleLR4().

digitize_

bool tmtt::SimpleLR4::digitize_

protected

Definition at line 61 of file SimpleLR4.h.

Referenced by fit(), and SimpleLR4().

dividerBitsChi2_

unsigned int tmtt::SimpleLR4::dividerBitsChi2_

protected

Definition at line 54 of file SimpleLR4.h.

dividerBitsHelix_

unsigned int tmtt::SimpleLR4::dividerBitsHelix_

protected

Definition at line 52 of file SimpleLR4.h.

Referenced by fit(), and SimpleLR4().

dividerBitsHelixZ_

unsigned int tmtt::SimpleLR4::dividerBitsHelixZ_

protected

Definition at line 53 of file SimpleLR4.h.

Referenced by fit(), and SimpleLR4().

invPtToDPhi_

float tmtt::SimpleLR4::invPtToDPhi_

protected

Definition at line 48 of file SimpleLR4.h.

Referenced by fit().

minStubLayersRed_

unsigned int tmtt::SimpleLR4::minStubLayersRed_

protected

Definition at line 50 of file SimpleLR4.h.

Referenced by fit().

numeratorLambdaMult_

float tmtt::SimpleLR4::numeratorLambdaMult_

protected

Definition at line 42 of file SimpleLR4.h.

Referenced by fit(), and SimpleLR4().

numeratorPhiMult_

float tmtt::SimpleLR4::numeratorPhiMult_

protected

Definition at line 43 of file SimpleLR4.h.

Referenced by fit(), and SimpleLR4().

numeratorPtMult_

float tmtt::SimpleLR4::numeratorPtMult_

protected

Definition at line 40 of file SimpleLR4.h.

Referenced by fit(), and SimpleLR4().

numeratorZ0Mult_

float tmtt::SimpleLR4::numeratorZ0Mult_

protected

Definition at line 41 of file SimpleLR4.h.

Referenced by fit(), and SimpleLR4().

phiMult_

float tmtt::SimpleLR4::phiMult_

protected

Definition at line 33 of file SimpleLR4.h.

Referenced by fit(), and SimpleLR4().

phiNonantWidth_

float tmtt::SimpleLR4::phiNonantWidth_

protected

Definition at line 31 of file SimpleLR4.h.

Referenced by fit(), and SimpleLR4().

phiSectorCentre_

float tmtt::SimpleLR4::phiSectorCentre_

protected

Definition at line 30 of file SimpleLR4.h.

Referenced by fit().

phiSectorWidth_

float tmtt::SimpleLR4::phiSectorWidth_

protected

Definition at line 29 of file SimpleLR4.h.

Referenced by fit(), and SimpleLR4().

phiTMult_

float tmtt::SimpleLR4::phiTMult_

protected

Definition at line 37 of file SimpleLR4.h.

Referenced by fit(), and SimpleLR4().

qOverPtMult_

float tmtt::SimpleLR4::qOverPtMult_

protected

Definition at line 36 of file SimpleLR4.h.

Referenced by fit(), and SimpleLR4().

resMult_

float tmtt::SimpleLR4::resMult_

protected

Definition at line 46 of file SimpleLR4.h.

Referenced by fit(), and SimpleLR4().

rTMult_

float tmtt::SimpleLR4::rTMult_

protected

Definition at line 34 of file SimpleLR4.h.

Referenced by SimpleLR4().

shiftingBitsDenRPhi_

unsigned int tmtt::SimpleLR4::shiftingBitsDenRPhi_

protected

Definition at line 56 of file SimpleLR4.h.

Referenced by fit(), and SimpleLR4().

shiftingBitsDenRZ_

unsigned int tmtt::SimpleLR4::shiftingBitsDenRZ_

protected

Definition at line 57 of file SimpleLR4.h.

Referenced by fit(), and SimpleLR4().

shiftingBitsLambda_

unsigned int tmtt::SimpleLR4::shiftingBitsLambda_

protected

Definition at line 60 of file SimpleLR4.h.

Referenced by fit(), and SimpleLR4().

shiftingBitsPhi_

unsigned int tmtt::SimpleLR4::shiftingBitsPhi_

protected

Definition at line 55 of file SimpleLR4.h.

Referenced by fit(), and SimpleLR4().

shiftingBitsPt_

unsigned int tmtt::SimpleLR4::shiftingBitsPt_

protected

Definition at line 58 of file SimpleLR4.h.

Referenced by fit(), and SimpleLR4().

shiftingBitsz0_

unsigned int tmtt::SimpleLR4::shiftingBitsz0_

protected

Definition at line 59 of file SimpleLR4.h.

Referenced by fit(), and SimpleLR4().

tanLambdaMult_

float tmtt::SimpleLR4::tanLambdaMult_

protected

Definition at line 39 of file SimpleLR4.h.

Referenced by fit(), and SimpleLR4().

z0Mult_

float tmtt::SimpleLR4::z0Mult_

protected

Definition at line 38 of file SimpleLR4.h.

Referenced by fit(), and SimpleLR4().

zMult_

float tmtt::SimpleLR4::zMult_

protected

Definition at line 35 of file SimpleLR4.h.

Referenced by SimpleLR4().