trklet::KFin Class Reference

Class to emulate transformation of tracklet tracks and stubs into TMTT format. More...

#include <KFin.h>

Classes
struct	Stub
struct	Track

Public Member Functions
void	consume (const tt::StreamsTrack &streamsTrack, const tt::StreamsStub &streamsStub)
	KFin (const edm::ParameterSet &iConfig, const tt::Setup *setup_, const trackerTFP::DataFormats *dataFormats, const trackerTFP::LayerEncoding *layerEncoding, const ChannelAssignment *channelAssignment, const Settings *settings, int region)
void	produce (tt::StreamsStub &accpetedStubs, tt::StreamsTrack &acceptedTracks, tt::StreamsStub &lostStubs, tt::StreamsTrack &lostTracks)
	~KFin ()

Private Member Functions
double	digi (double val, double base) const
double	redigi (double val, double baseLow, double baseHigh, int widthMultiplier) const

Private Attributes
double	baseHcot_
double	baseHinv2R_
double	baseHphi_
double	baseHphiT_
double	baseHr_
double	baseHz_
double	baseHzT_
double	baseInvCot_
double	baseLcot_
double	baseLinv2R_
double	baseLphi_
double	baseLphiT_
double	baseLr_
double	baseLz_
double	baseLzT_
double	baseUcot_
double	baseUinv2R_
double	baseUphi_
double	baseUphiT_
double	baseUr_
double	baseUz_
double	baseUzT_
const ChannelAssignment *	channelAssignment_
const trackerTFP::DataFormats *	dataFormats_
bool	enableTruncation_
std::vector< std::vector< Track * > >	input_
const trackerTFP::LayerEncoding *	layerEncoding_
const int	region_
const Settings *	settings_
const tt::Setup *	setup_
std::vector< Stub >	stubs_
std::vector< Track >	tracks_
bool	useTTStubResiduals_

Detailed Description

Class to emulate transformation of tracklet tracks and stubs into TMTT format.

Author

Thomas Schuh

Date

2021, Dec

Definition at line 19 of file KFin.h.

Constructor & Destructor Documentation

KFin()

trklet::KFin::KFin	(	const edm::ParameterSet &	iConfig,
		const tt::Setup *	setup_,
		const trackerTFP::DataFormats *	dataFormats,
		const trackerTFP::LayerEncoding *	layerEncoding,
		const ChannelAssignment *	channelAssignment,
		const Settings *	settings,
		int	region
	)

Definition at line 14 of file KFin.cc.

References trackerTFP::DataFormats::base(), baseHcot_, baseHinv2R_, baseHphi_, baseHphiT_, baseHr_, baseHz_, baseHzT_, baseInvCot_, baseLcot_, baseLinv2R_, baseLphi_, baseLphiT_, baseLr_, baseLz_, baseLzT_, baseUcot_, baseUinv2R_, baseUphi_, baseUphiT_, baseUr_, baseUz_, baseUzT_, reco::ceil(), tt::Setup::hybridRangeR(), trklet::Settings::kphi1(), trklet::Settings::kr(), trklet::Settings::kz(), tt::Setup::outerRadius(), PVValHelper::phi, trklet::Settings::phi0_shift(), funct::pow(), alignCSCRings::r, trklet::Settings::rinv_shift(), settings_, setup_, trklet::Settings::t_shift(), tt::Setup::widthDSPbu(), detailsBasic3DVector::z, and trklet::Settings::z0_shift().

      : enableTruncation_(iConfig.getParameter<bool>("EnableTruncation")),
        useTTStubResiduals_(iConfig.getParameter<bool>("UseTTStubResiduals")),
        setup_(setup),
        dataFormats_(dataFormats),
        layerEncoding_(layerEncoding),
        channelAssignment_(channelAssignment),
        settings_(settings),
        region_(region),
        input_(channelAssignment_->numChannelsTrack()) {
    // unified tracklet digitisation granularity
    baseUinv2R_ = .5 * settings_->kphi1() / settings_->kr() * pow(2, settings_->rinv_shift());
    baseUphiT_ = settings_->kphi1() * pow(2, settings_->phi0_shift());
    baseUcot_ = settings_->kz() / settings_->kr() * pow(2, settings_->t_shift());
    baseUzT_ = settings_->kz() * pow(2, settings_->z0_shift());
    baseUr_ = settings_->kr();
    baseUphi_ = settings_->kphi1();
    baseUz_ = settings_->kz();
    // KF input format digitisation granularity (identical to TMTT)
    baseLinv2R_ = dataFormats->base(Variable::inv2R, Process::kfin);
    baseLphiT_ = dataFormats->base(Variable::phiT, Process::kfin);
    baseLcot_ = dataFormats->base(Variable::cot, Process::kfin);
    baseLzT_ = dataFormats->base(Variable::zT, Process::kfin);
    baseLr_ = dataFormats->base(Variable::r, Process::kfin);
    baseLphi_ = dataFormats->base(Variable::phi, Process::kfin);
    baseLz_ = dataFormats->base(Variable::z, Process::kfin);
    // Finer granularity (by powers of 2) than the TMTT one. Used to transform from Tracklet to TMTT base.
    baseHinv2R_ = baseLinv2R_ * pow(2, floor(log2(baseUinv2R_ / baseLinv2R_)));
    baseHphiT_ = baseLphiT_ * pow(2, floor(log2(baseUphiT_ / baseLphiT_)));
    baseHcot_ = baseLcot_ * pow(2, floor(log2(baseUcot_ / baseLcot_)));
    baseHzT_ = baseLzT_ * pow(2, floor(log2(baseUzT_ / baseLzT_)));
    baseHr_ = baseLr_ * pow(2, floor(log2(baseUr_ / baseLr_)));
    baseHphi_ = baseLphi_ * pow(2, floor(log2(baseUphi_ / baseLphi_)));
    baseHz_ = baseLz_ * pow(2, floor(log2(baseUz_ / baseLz_)));
    // calculate digitisation granularity used for inverted cot(theta)
    const int baseShiftInvCot = ceil(log2(setup_->outerRadius() / setup_->hybridRangeR())) - setup_->widthDSPbu();
    baseInvCot_ = pow(2, baseShiftInvCot);
  }

~KFin()

trklet::KFin::~KFin ( )

inline

Definition at line 28 of file KFin.h.

{}

Member Function Documentation

consume()

void trklet::KFin::consume	(	const tt::StreamsTrack &	streamsTrack,
		const tt::StreamsStub &	streamsStub
	)

Definition at line 60 of file KFin.cc.

References funct::abs(), Reference_intrackfit_cff::barrel, tt::Setup::barrel(), baseInvCot_, tt::Setup::baseRegion(), baseUcot_, baseUinv2R_, baseUphi_, baseUphiT_, baseUr_, baseUz_, baseUzT_, tt::Setup::beamWindowZ(), channelAssignment_, trackerTFP::DataFormats::chosenRofPhi(), tt::Setup::chosenRofZ(), trackerTFP::cot, dataFormats_, tt::deltaPhi(), digi(), enableTruncation_, dqmdumpme::first, amptDefault_cfi::frame, l1trig_cff::hwPhi, tt::Setup::hybridDiskZ(), tt::Setup::hybridLayerR(), tt::Setup::hybridMaxCot(), tt::Setup::hybridRangePhi(), tt::Setup::indexLayerId(), input, input_, createfilelist::int, edm::Ref< C, T, F >::isNull(), trklet::Settings::kphi(), trklet::Settings::kphi1(), trklet::Settings::kz(), trklet::ChannelAssignment::layerId(), tt::Setup::layerId(), remoteMonitoring_LASER_era2018_cfg::limit, tt::Setup::maxEta(), trklet::Settings::nbitst(), BeamSpotPI::nTracks, trklet::ChannelAssignment::numChannelsTrack(), tt::Setup::numFrames(), trklet::ChannelAssignment::numProjectionLayers(), trklet::ChannelAssignment::numSeedingLayers(), tt::Setup::offsetLayerDisks(), tt::Setup::offsetLayerId(), trklet::ChannelAssignment::offsetStub(), trklet::Settings::phiresidbits(), trackerTFP::phiT, funct::pow(), tt::Setup::psModule(), region_, trklet::Settings::rresidbits(), trklet::ChannelAssignment::seedingLayers(), settings_, setup_, tt::Setup::stubPos(), tt::Setup::stubR(), stubs_, tt::Setup::tiltedLayerLimitZ(), tt::Setup::trackletLayerId(), tracks_, funct::true, useTTStubResiduals_, TTBV::val(), validateGeometry_cfg::valid, tt::Setup::widthAddrBRAM18(), trklet::Settings::zresidbits(), and trackerTFP::zT.

                                                                                     {
    static const double maxCot = sinh(setup_->maxEta()) + setup_->beamWindowZ() / setup_->chosenRofZ();
    static const int unusedMSBcot = floor(log2(baseUcot_ * pow(2, settings_->nbitst()) / (2. * maxCot)));
    static const double baseCot =
        baseUcot_ * pow(2, settings_->nbitst() - unusedMSBcot - 1 - setup_->widthAddrBRAM18());
    const int offsetTrack = region_ * channelAssignment_->numChannelsTrack();
    // count tracks and stubs to reserve container
    int nTracks(0);
    int nStubs(0);
    for (int channel = 0; channel < channelAssignment_->numChannelsTrack(); channel++) {
      const int channelTrack = offsetTrack + channel;
      const int offsetStub = channelAssignment_->offsetStub(channelTrack);
      const StreamTrack& streamTrack = streamsTrack[channelTrack];
      input_[channel].reserve(streamTrack.size());
      for (int frame = 0; frame < (int)streamTrack.size(); frame++) {
        if (streamTrack[frame].first.isNull())
          continue;
        nTracks++;
        for (int layer = 0; layer < channelAssignment_->numProjectionLayers(channel); layer++)
          if (streamsStub[offsetStub + layer][frame].first.isNonnull())
            nStubs++;
      }
    }
    stubs_.reserve(nStubs + nTracks * channelAssignment_->numSeedingLayers());
    tracks_.reserve(nTracks);
    // store tracks and stubs
    for (int channel = 0; channel < channelAssignment_->numChannelsTrack(); channel++) {
      const int channelTrack = offsetTrack + channel;
      const int offsetStub = channelAssignment_->offsetStub(channelTrack);
      const StreamTrack& streamTrack = streamsTrack[channelTrack];
      vector<Track*>& input = input_[channel];
      for (int frame = 0; frame < (int)streamTrack.size(); frame++) {
        const TTTrackRef& ttTrackRef = streamTrack[frame].first;
        if (ttTrackRef.isNull()) {
          input.push_back(nullptr);
          continue;
        }
        //convert track parameter
        const double r2Inv = digi(-ttTrackRef->rInv() / 2., baseUinv2R_);
        const double phi0U =
            digi(tt::deltaPhi(ttTrackRef->phi() - region_ * setup_->baseRegion() + setup_->hybridRangePhi() / 2.),
                 baseUphiT_);
        const double phi0S = digi(phi0U - setup_->hybridRangePhi() / 2., baseUphiT_);
        const double cot = digi(ttTrackRef->tanL(), baseUcot_);
        const double z0 = digi(ttTrackRef->z0(), baseUzT_);
        const double phiT = digi(phi0S + r2Inv * digi(dataFormats_->chosenRofPhi(), baseUr_), baseUphiT_);
        const double zT = digi(z0 + cot * digi(setup_->chosenRofZ(), baseUr_), baseUzT_);
        // kill tracks outside of fiducial range
        if (abs(phiT) > setup_->baseRegion() / 2. || abs(zT) > setup_->hybridMaxCot() * setup_->chosenRofZ() ||
            abs(z0) > setup_->beamWindowZ()) {
          input.push_back(nullptr);
          continue;
        }
        // convert stubs
        vector<Stub*> stubs;
        stubs.reserve(channelAssignment_->numProjectionLayers(channel) + channelAssignment_->numSeedingLayers());
        for (int layer = 0; layer < channelAssignment_->numProjectionLayers(channel); layer++) {
          const FrameStub& frameStub = streamsStub[offsetStub + layer][frame];
          const TTStubRef& ttStubRef = frameStub.first;
          const int layerId = channelAssignment_->layerId(channel, layer);
          if (ttStubRef.isNull())
            continue;
          // parse residuals from tt::Frame and take r and layerId from tt::TTStubRef
          const bool barrel = setup_->barrel(ttStubRef);
          const int layerIdTracklet = setup_->trackletLayerId(ttStubRef);
          const double basePhi = barrel ? settings_->kphi1() : settings_->kphi(layerIdTracklet);
          const double baseRZ = barrel ? settings_->kz(layerIdTracklet) : settings_->kz();
          const int widthRZ = barrel ? settings_->zresidbits() : settings_->rresidbits();
          TTBV hw(frameStub.second);
          const TTBV hwRZ(hw, widthRZ, 0, true);
          hw >>= widthRZ;
          const TTBV hwPhi(hw, settings_->phiresidbits(), 0, true);
          hw >>= settings_->phiresidbits();
          const double r = digi(setup_->stubR(hw, ttStubRef) - dataFormats_->chosenRofPhi(), baseUr_);
          double phi = hwPhi.val(basePhi);
          if (basePhi > baseUphi_)
            phi += baseUphi_ / 2.;
          const double z = digi(hwRZ.val(baseRZ) * (barrel ? 1. : -cot), baseUz_);
          // determine module type
          bool psTilt;
          if (barrel) {
            const double posZ = (r + digi(dataFormats_->chosenRofPhi(), baseUr_)) * cot + z0 + z;
            const int indexLayerId = setup_->indexLayerId(ttStubRef);
            const double limit = setup_->tiltedLayerLimitZ(indexLayerId);
            psTilt = abs(posZ) < limit;
          } else
            psTilt = setup_->psModule(ttStubRef);
          if (useTTStubResiduals_) {
            const GlobalPoint gp = setup_->stubPos(ttStubRef);
            const double ttR = r;
            const double ttZ = gp.z() - (z0 + (ttR + dataFormats_->chosenRofPhi()) * cot);
            stubs_.emplace_back(ttStubRef, layerId, ttR, phi, ttZ, psTilt);
          } else
            stubs_.emplace_back(ttStubRef, layerId, r, phi, z, psTilt);
          stubs.push_back(&stubs_.back());
        }
        // create fake seed stubs, since TrackBuilder doesn't output these stubs, required by the KF.
        for (int layerId : channelAssignment_->seedingLayers(channel)) {
          const vector<TTStubRef>& ttStubRefs = ttTrackRef->getStubRefs();
          auto sameLayer = [this, layerId](const TTStubRef& ttStubRef) {
            return setup_->layerId(ttStubRef) == layerId;
          };
          const TTStubRef& ttStubRef = *find_if(ttStubRefs.begin(), ttStubRefs.end(), sameLayer);
          const bool barrel = setup_->barrel(ttStubRef);
          double r;
          if (barrel)
            r = digi(setup_->hybridLayerR(layerId - setup_->offsetLayerId()) - dataFormats_->chosenRofPhi(), baseUr_);
          else {
            r = (z0 +
                 digi(setup_->hybridDiskZ(layerId - setup_->offsetLayerId() - setup_->offsetLayerDisks()), baseUzT_)) *
                digi(1. / digi(abs(cot), baseCot), baseInvCot_);
            r = digi(r - digi(dataFormats_->chosenRofPhi(), baseUr_), baseUr_);
          }
          static constexpr double phi = 0.;
          static constexpr double z = 0.;
          // determine module type
          bool psTilt;
          if (barrel) {
            const double posZ =
                digi(digi(setup_->hybridLayerR(layerId - setup_->offsetLayerId()), baseUr_) * cot + z0, baseUz_);
            const int indexLayerId = setup_->indexLayerId(ttStubRef);
            const double limit = digi(setup_->tiltedLayerLimitZ(indexLayerId), baseUz_);
            psTilt = abs(posZ) < limit;
          } else
            psTilt = true;
          const GlobalPoint gp = setup_->stubPos(ttStubRef);
          const double ttR = gp.perp() - dataFormats_->chosenRofPhi();
          const double ttZ = gp.z() - (z0 + (ttR + dataFormats_->chosenRofPhi()) * cot);
          if (useTTStubResiduals_)
            stubs_.emplace_back(ttStubRef, layerId, ttR, phi, ttZ, psTilt);
          else
            stubs_.emplace_back(ttStubRef, layerId, r, phi, z, psTilt);
          stubs.push_back(&stubs_.back());
        }
        const bool valid = frame < setup_->numFrames() ? true : enableTruncation_;
        tracks_.emplace_back(ttTrackRef, valid, r2Inv, phiT, cot, zT, stubs);
        input.push_back(&tracks_.back());
      }
    }
  }

digi()

double trklet::KFin::digi ( double  val, double  base  ) const

inlineprivate

Definition at line 40 of file KFin.h.

References newFWLiteAna::base, MillePedeFileConverter_cfg::e, and heppy_batch::val.

Referenced by consume(), produce(), and redigi().

{ return (floor(val / base + 1.e-12) + .5) * base; }

produce()

void trklet::KFin::produce	(	tt::StreamsStub &	accpetedStubs,
		tt::StreamsTrack &	acceptedTracks,
		tt::StreamsStub &	lostStubs,
		tt::StreamsTrack &	lostTracks
	)

Definition at line 202 of file KFin.cc.

References funct::abs(), Reference_intrackfit_cff::barrel, tt::Setup::barrel(), baseHcot_, baseHinv2R_, baseHphi_, baseHphiT_, baseHr_, baseHz_, baseHzT_, baseLcot_, baseLinv2R_, baseLphi_, baseLphiT_, baseLr_, baseLz_, baseLzT_, tt::Setup::baseSector(), baseUcot_, baseUinv2R_, baseUphi_, baseUphiT_, baseUr_, baseUz_, baseUzT_, tt::Setup::beamWindowZ(), tt::Setup::boundarieEta(), reco::ceil(), channelAssignment_, trackerTFP::DataFormats::chosenRofPhi(), tt::Setup::chosenRofZ(), trackerTFP::cot, dataFormats_, digi(), HLT_2022v15_cff::dPhi, trklet::KFin::Stub::dPhi_, PVValHelper::dz, l1ctLayer1_cff::dZ, trklet::KFin::Stub::dZ_, cond::serialization::equal(), trackerTFP::DataFormats::format(), hfClusterShapes_cfi::hits, caHitNtupletGeneratorKernels::if(), input, input_, trackerTFP::DataFormat::inRange(), trackerTFP::inv2R, tt::Setup::kfMinLayers(), trklet::KFin::Stub::layer_, layerEncoding_, trackerTFP::LayerEncoding::layerIdKF(), tt::Setup::length2S(), tt::Setup::lengthPS(), isotracks_cff::lostTracks, tt::Setup::maxEta(), trackerTFP::LayerEncoding::maybePattern(), trklet::ChannelAssignment::numChannelsTrack(), tt::Setup::numLayers(), tt::Setup::numSectorsEta(), PVValHelper::phi, trklet::KFin::Stub::phi_, trackerTFP::phiT, tt::Setup::pitch2S(), tt::Setup::pitchPS(), funct::pow(), tt::Setup::psModule(), trklet::KFin::Stub::psTilt_, alignCSCRings::r, trklet::KFin::Stub::r_, redigi(), region_, alignCSCRings::s, tt::Setup::scattering(), tt::Setup::sectorCot(), trackerTFP::sectorEta, trackerTFP::sectorPhi, setup_, TTBV::str(), tt::Setup::tbInnerRadius(), tt::Setup::tiltApproxIntercept(), tt::Setup::tiltApproxSlope(), tt::Setup::tiltUncertaintyR(), trackerTFP::DataFormat::toUnsigned(), HLT_2022v15_cff::track, tracks_, trackerTFP::DataFormat::ttBV(), trklet::KFin::Stub::ttStubRef_, trklet::KFin::Stub::valid_, trackerTFP::DataFormats::width(), tt::Setup::widthAddrBRAM18(), tt::Setup::widthDSPbu(), detailsBasic3DVector::z, trklet::KFin::Stub::z_, and trackerTFP::zT.

                                               {
    static constexpr int usedMSBpitchOverRaddr = 1;
    static const double baseR =
        baseLr_ *
        pow(2, dataFormats_->width(Variable::r, Process::zht) - setup_->widthAddrBRAM18() + usedMSBpitchOverRaddr);
    static const double baseRinvR =
        baseLr_ * pow(2, dataFormats_->width(Variable::r, Process::zht) - setup_->widthAddrBRAM18());
    static const double basePhi = baseLinv2R_ * baseLr_;
    static const double baseInvR =
        pow(2., ceil(log2(baseLr_ / setup_->tbInnerRadius())) - setup_->widthDSPbu()) / baseLr_;
    static const double maxCot = sinh(setup_->maxEta()) + setup_->beamWindowZ() / setup_->chosenRofZ();
    static constexpr int usedMSBCotLutaddr = 3;
    static const double baseCotLut = pow(2., ceil(log2(maxCot)) - setup_->widthAddrBRAM18() + usedMSBCotLutaddr);
    // base transform into high precision TMTT format
    for (Track& track : tracks_) {
      track.inv2R_ = redigi(track.inv2R_, baseUinv2R_, baseHinv2R_, setup_->widthDSPbu());
      track.phiT_ = redigi(track.phiT_, baseUphiT_, baseHphiT_, setup_->widthDSPbu());
      track.cot_ = redigi(track.cot_, baseUcot_, baseHcot_, setup_->widthDSPbu());
      track.zT_ = redigi(track.zT_, baseUzT_, baseHzT_, setup_->widthDSPbu());
      for (Stub* stub : track.stubs_) {
        stub->r_ = redigi(stub->r_, baseUr_, baseHr_, setup_->widthDSPbu());
        stub->phi_ = redigi(stub->phi_, baseUphi_, baseHphi_, setup_->widthDSPbu());
        stub->z_ = redigi(stub->z_, baseUz_, baseHz_, setup_->widthDSPbu());
      }
    }
    // find sector
    for (Track& track : tracks_) {
      const int sectorPhi = track.phiT_ < 0. ? 0 : 1;
      track.phiT_ -= (sectorPhi - .5) * setup_->baseSector();
      int sectorEta(-1);
      for (; sectorEta < setup_->numSectorsEta(); sectorEta++)
        if (track.zT_ < digi(setup_->chosenRofZ() * sinh(setup_->boundarieEta(sectorEta + 1)), baseHzT_))
          break;
      if (sectorEta >= setup_->numSectorsEta() || sectorEta <= -1) {
        track.valid_ = false;
        continue;
      }
      track.cot_ = track.cot_ - digi(setup_->sectorCot(sectorEta), baseHcot_);
      track.zT_ = track.zT_ - digi(setup_->chosenRofZ() * setup_->sectorCot(sectorEta), baseHzT_);
      track.sector_ = sectorPhi * setup_->numSectorsEta() + sectorEta;
    }
    // base transform into TMTT format
    for (Track& track : tracks_) {
      if (!track.valid_)
        continue;
      // store track parameter shifts
      const double dinv2R = digi(track.inv2R_ - digi(track.inv2R_, baseLinv2R_), baseHinv2R_);
      const double dphiT = digi(track.phiT_ - digi(track.phiT_, baseLphiT_), baseHphiT_);
      const double dcot = digi(track.cot_ - digi(track.cot_, baseLcot_), baseHcot_);
      const double dzT = digi(track.zT_ - digi(track.zT_, baseLzT_), baseHzT_);
      // shift track parameter;
      track.inv2R_ = digi(track.inv2R_, baseLinv2R_);
      track.phiT_ = digi(track.phiT_, baseLphiT_);
      track.cot_ = digi(track.cot_, baseLcot_);
      track.zT_ = digi(track.zT_, baseLzT_);
      // range checks
      if (!dataFormats_->format(Variable::inv2R, Process::kfin).inRange(track.inv2R_, true))
        track.valid_ = false;
      if (!dataFormats_->format(Variable::phiT, Process::kfin).inRange(track.phiT_, true))
        track.valid_ = false;
      if (!dataFormats_->format(Variable::cot, Process::kfin).inRange(track.cot_, true))
        track.valid_ = false;
      if (!dataFormats_->format(Variable::zT, Process::kfin).inRange(track.zT_, true))
        track.valid_ = false;
      if (!track.valid_)
        continue;
      // adjust stub residuals by track parameter shifts
      for (Stub* stub : track.stubs_) {
        const double dphi = digi(dphiT + stub->r_ * dinv2R, baseHphi_);
        const double r = stub->r_ + digi(dataFormats_->chosenRofPhi() - setup_->chosenRofZ(), baseHr_);
        const double dz = digi(dzT + r * dcot, baseHz_);
        stub->phi_ = digi(stub->phi_ + dphi, baseLphi_);
        stub->z_ = digi(stub->z_ + dz, baseLz_);
        // range checks
        if (!dataFormats_->format(Variable::phi, Process::kfin).inRange(stub->phi_))
          stub->valid_ = false;
        if (!dataFormats_->format(Variable::z, Process::kfin).inRange(stub->z_))
          stub->valid_ = false;
      }
    }
    // encode layer id
    for (Track& track : tracks_) {
      if (!track.valid_)
        continue;
      const int sectorEta = track.sector_ % setup_->numSectorsEta();
      const int zT = dataFormats_->format(Variable::zT, Process::kfin).toUnsigned(track.zT_);
      const int cot = dataFormats_->format(Variable::cot, Process::kfin).toUnsigned(track.cot_);
      track.maybe_ = TTBV(0, setup_->numLayers());
      for (Stub* stub : track.stubs_) {
        if (!stub->valid_)
          continue;
        // replace layerId by encoded layerId
        stub->layer_ = layerEncoding_->layerIdKF(sectorEta, zT, cot, stub->layer_);
        // kill stubs from layers which can't be crossed by track
        if (stub->layer_ == -1)
          stub->valid_ = false;
        if (stub->valid_) {
          if (track.maybe_[stub->layer_]) {
            for (Stub* s : track.stubs_) {
              if (s == stub)
                break;
              if (s->layer_ == stub->layer_)
                s->valid_ = false;
            }
          } else
            track.maybe_.set(stub->layer_);
        }
      }
      // lookup maybe layers
      track.maybe_ &= layerEncoding_->maybePattern(sectorEta, zT, cot);
    }
    // kill tracks with not enough layer
    for (Track& track : tracks_) {
      if (!track.valid_)
        continue;
      TTBV hits(0, setup_->numLayers());
      for (const Stub* stub : track.stubs_)
        if (stub->valid_)
          hits.set(stub->layer_);
      if (hits.count() < setup_->kfMinLayers())
        track.valid_ = false;
    }
    // calculate stub uncertainties
    for (Track& track : tracks_) {
      if (!track.valid_)
        continue;
      const int sectorEta = track.sector_ % setup_->numSectorsEta();
      const double inv2R = abs(track.inv2R_);
      for (Stub* stub : track.stubs_) {
        if (!stub->valid_)
          continue;
        const bool barrel = setup_->barrel(stub->ttStubRef_);
        const bool ps = barrel ? setup_->psModule(stub->ttStubRef_) : stub->psTilt_;
        const bool tilt = barrel ? (ps && !stub->psTilt_) : false;
        const double length = ps ? setup_->lengthPS() : setup_->length2S();
        const double pitch = ps ? setup_->pitchPS() : setup_->pitch2S();
        const double pitchOverR = digi(pitch / (digi(stub->r_, baseR) + dataFormats_->chosenRofPhi()), basePhi);
        const double r = digi(stub->r_, baseRinvR) + dataFormats_->chosenRofPhi();
        const double sumdz = track.zT_ + stub->z_;
        const double dZ = digi(sumdz - digi(setup_->chosenRofZ(), baseLr_) * track.cot_, baseLcot_ * baseLr_);
        const double sumcot = track.cot_ + digi(setup_->sectorCot(sectorEta), baseHcot_);
        const double cot = digi(abs(dZ * digi(1. / r, baseInvR) + sumcot), baseCotLut);
        double lengthZ = length;
        double lengthR = 0.;
        if (!barrel) {
          lengthZ = length * cot;
          lengthR = length;
        } else if (tilt) {
          lengthZ = length * abs(setup_->tiltApproxSlope() * cot + setup_->tiltApproxIntercept());
          lengthR = setup_->tiltUncertaintyR();
        }
        const double scat = digi(setup_->scattering(), baseLr_);
        stub->dZ_ = lengthZ + baseLz_;
        stub->dPhi_ = (scat + digi(lengthR, baseLr_)) * inv2R + pitchOverR;
        stub->dPhi_ = digi(stub->dPhi_, baseLphi_) + baseLphi_;
      }
    }
    // fill products StreamsStub& accpetedStubs, StreamsTrack& acceptedTracks, StreamsStub& lostStubs, StreamsTrack& lostTracks
    auto frameTrack = [this](Track* track) {
      const TTBV maybe(track->maybe_);
      const TTBV sectorPhi(
          dataFormats_->format(Variable::sectorPhi, Process::kfin).ttBV(track->sector_ / setup_->numSectorsEta()));
      const TTBV sectorEta(
          dataFormats_->format(Variable::sectorEta, Process::kfin).ttBV(track->sector_ % setup_->numSectorsEta()));
      const TTBV inv2R(dataFormats_->format(Variable::inv2R, Process::kfin).ttBV(track->inv2R_));
      const TTBV phiT(dataFormats_->format(Variable::phiT, Process::kfin).ttBV(track->phiT_));
      const TTBV cot(dataFormats_->format(Variable::cot, Process::kfin).ttBV(track->cot_));
      const TTBV zT(dataFormats_->format(Variable::zT, Process::kfin).ttBV(track->zT_));
      return FrameTrack(track->ttTrackRef_,
                        Frame("1" + maybe.str() + sectorPhi.str() + sectorEta.str() + phiT.str() + inv2R.str() +
                              zT.str() + cot.str()));
    };
    auto frameStub = [this](Track* track, int layer) {
      auto equal = [layer](Stub* stub) { return stub->valid_ && stub->layer_ == layer; };
      const auto it = find_if(track->stubs_.begin(), track->stubs_.end(), equal);
      if (it == track->stubs_.end() || !(*it)->valid_)
        return FrameStub();
      Stub* stub = *it;
      const TTBV r(dataFormats_->format(Variable::r, Process::kfin).ttBV(stub->r_));
      const TTBV phi(dataFormats_->format(Variable::phi, Process::kfin).ttBV(stub->phi_));
      const TTBV z(dataFormats_->format(Variable::z, Process::kfin).ttBV(stub->z_));
      const TTBV dPhi(dataFormats_->format(Variable::dPhi, Process::kfin).ttBV(stub->dPhi_));
      const TTBV dZ(dataFormats_->format(Variable::dZ, Process::kfin).ttBV(stub->dZ_));
      return FrameStub(stub->ttStubRef_, Frame("1" + r.str() + phi.str() + z.str() + dPhi.str() + dZ.str()));
    };
    auto invalid = [](Track* track) { return track && !track->valid_; };
    auto acc = [invalid](int& sum, Track* track) { return sum += (invalid(track) ? 1 : 0); };
    const int offsetTrack = region_ * channelAssignment_->numChannelsTrack();
    for (int channel = 0; channel < channelAssignment_->numChannelsTrack(); channel++) {
      const int channelTrack = offsetTrack + channel;
      const int offsetStub = channelTrack * setup_->numLayers();
      vector<Track*>& input = input_[channel];
      // fill lost tracks and stubs without gaps
      const int lost = accumulate(input.begin(), input.end(), 0, acc);
      lostTracks[channelTrack].reserve(lost);
      for (int layer = 0; layer < setup_->numLayers(); layer++)
        lostStubs[offsetStub + layer].reserve(lost);
      for (Track* track : input) {
        if (!track || track->valid_)
          continue;
        lostTracks[channelTrack].emplace_back(frameTrack(track));
        for (int layer = 0; layer < setup_->numLayers(); layer++)
          lostStubs[offsetStub + layer].emplace_back(frameStub(track, layer));
      }
      // fill accepted tracks and stubs with gaps
      acceptedTracks[channelTrack].reserve(input.size());
      for (int layer = 0; layer < setup_->numLayers(); layer++)
        accpetedStubs[offsetStub + layer].reserve(input.size());
      for (Track* track : input) {
        if (!track || !track->valid_) {  // fill gap
          acceptedTracks[channelTrack].emplace_back(FrameTrack());
          for (int layer = 0; layer < setup_->numLayers(); layer++)
            accpetedStubs[offsetStub + layer].emplace_back(FrameStub());
          continue;
        }
        acceptedTracks[channelTrack].emplace_back(frameTrack(track));
        for (int layer = 0; layer < setup_->numLayers(); layer++)
          accpetedStubs[offsetStub + layer].emplace_back(frameStub(track, layer));
      }
    }
  }

redigi()

double trklet::KFin::redigi ( double  val, double  baseLow, double  baseHigh, int  widthMultiplier  ) const

private

Definition at line 428 of file KFin.cc.

References newFWLiteAna::base, digi(), funct::pow(), HcalDetIdTransform::transform(), and heppy_batch::val.

Referenced by produce().

                                                                                            {
    const double base = pow(2, 1 - widthMultiplier);
    const double transform = digi(baseLow / baseHigh, base);
    return (floor(val * transform / baseLow) + .5) * baseHigh;
  }

Member Data Documentation

baseHcot_

double trklet::KFin::baseHcot_

private

Definition at line 132 of file KFin.h.

Referenced by KFin(), and produce().

baseHinv2R_

double trklet::KFin::baseHinv2R_

private

Definition at line 130 of file KFin.h.

Referenced by KFin(), and produce().

baseHphi_

double trklet::KFin::baseHphi_

private

Definition at line 135 of file KFin.h.

Referenced by KFin(), and produce().

baseHphiT_

double trklet::KFin::baseHphiT_

private

Definition at line 131 of file KFin.h.

Referenced by KFin(), and produce().

baseHr_

double trklet::KFin::baseHr_

private

Definition at line 134 of file KFin.h.

Referenced by KFin(), and produce().

baseHz_

double trklet::KFin::baseHz_

private

Definition at line 136 of file KFin.h.

Referenced by KFin(), and produce().

baseHzT_

double trklet::KFin::baseHzT_

private

Definition at line 133 of file KFin.h.

Referenced by KFin(), and produce().

baseInvCot_

double trklet::KFin::baseInvCot_

private

Definition at line 138 of file KFin.h.

Referenced by consume(), and KFin().

baseLcot_

double trklet::KFin::baseLcot_

private

Definition at line 124 of file KFin.h.

Referenced by KFin(), and produce().

baseLinv2R_

double trklet::KFin::baseLinv2R_

private

Definition at line 122 of file KFin.h.

Referenced by KFin(), and produce().

baseLphi_

double trklet::KFin::baseLphi_

private

Definition at line 127 of file KFin.h.

Referenced by KFin(), and produce().

baseLphiT_

double trklet::KFin::baseLphiT_

private

Definition at line 123 of file KFin.h.

Referenced by KFin(), and produce().

baseLr_

double trklet::KFin::baseLr_

private

Definition at line 126 of file KFin.h.

Referenced by KFin(), and produce().

baseLz_

double trklet::KFin::baseLz_

private

Definition at line 128 of file KFin.h.

Referenced by KFin(), and produce().

baseLzT_

double trklet::KFin::baseLzT_

private

Definition at line 125 of file KFin.h.

Referenced by KFin(), and produce().

baseUcot_

double trklet::KFin::baseUcot_

private

Definition at line 116 of file KFin.h.

Referenced by consume(), KFin(), and produce().

baseUinv2R_

double trklet::KFin::baseUinv2R_

private

Definition at line 114 of file KFin.h.

Referenced by consume(), KFin(), and produce().

baseUphi_

double trklet::KFin::baseUphi_

private

Definition at line 119 of file KFin.h.

Referenced by consume(), KFin(), and produce().

baseUphiT_

double trklet::KFin::baseUphiT_

private

Definition at line 115 of file KFin.h.

Referenced by consume(), KFin(), and produce().

baseUr_

double trklet::KFin::baseUr_

private

Definition at line 118 of file KFin.h.

Referenced by consume(), KFin(), and produce().

baseUz_

double trklet::KFin::baseUz_

private

Definition at line 120 of file KFin.h.

Referenced by consume(), KFin(), and produce().

baseUzT_

double trklet::KFin::baseUzT_

private

Definition at line 117 of file KFin.h.

Referenced by consume(), KFin(), and produce().

channelAssignment_

const ChannelAssignment* trklet::KFin::channelAssignment_

private

Definition at line 102 of file KFin.h.

Referenced by consume(), and produce().

dataFormats_

const trackerTFP::DataFormats* trklet::KFin::dataFormats_

private

Definition at line 98 of file KFin.h.

Referenced by consume(), and produce().

enableTruncation_

bool trklet::KFin::enableTruncation_

private

Definition at line 92 of file KFin.h.

Referenced by consume().

input_

std::vector<std::vector<Track*> > trklet::KFin::input_

private

Definition at line 112 of file KFin.h.

Referenced by consume(), and produce().

layerEncoding_

const trackerTFP::LayerEncoding* trklet::KFin::layerEncoding_

private

Definition at line 100 of file KFin.h.

Referenced by produce().

region_

const int trklet::KFin::region_

private

Definition at line 106 of file KFin.h.

Referenced by consume(), and produce().

settings_

const Settings* trklet::KFin::settings_

private

Definition at line 104 of file KFin.h.

Referenced by consume(), and KFin().

setup_

const tt::Setup* trklet::KFin::setup_

private

Definition at line 96 of file KFin.h.

Referenced by consume(), KFin(), produce(), and upgradeWorkflowComponents.UpgradeWorkflow::setup().

stubs_

std::vector<Stub> trklet::KFin::stubs_

private

Definition at line 110 of file KFin.h.

Referenced by consume().

tracks_

std::vector<Track> trklet::KFin::tracks_

private

Definition at line 108 of file KFin.h.

Referenced by consume(), and produce().

useTTStubResiduals_

bool trklet::KFin::useTTStubResiduals_

private

Definition at line 94 of file KFin.h.

Referenced by consume().