trklet::DRin Class Reference

Class to emulate transformation of tracklet tracks and stubs into TMTT format and routing of seed type streams into inv2R streams. More...

#include <DRin.h>

Classes
struct	Stub
struct	Track

Public Member Functions
void	consume (const tt::StreamsTrack &streamsTrack, const tt::StreamsStub &streamsStub)
	DRin (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)
	~DRin ()

Private Member Functions
double	digi (double val, double base) const
template<class T >
T *	pop_front (std::deque< T *> &ts) 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 and routing of seed type streams into inv2R streams.

Author

Thomas Schuh

Date

2023, Jan

Definition at line 21 of file DRin.h.

Constructor & Destructor Documentation

DRin()

trklet::DRin::DRin	(	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 15 of file DRin.cc.

References baseInvCot_, reco::ceil(), trackerTFP::cot, tt::Setup::hybridRangeR(), trackerTFP::inv2R, trackerTFP::kfin, tt::Setup::outerRadius(), trackerTFP::phiT, funct::pow(), setup_, tt::Setup::widthDSPbu(), and trackerTFP::zT.

      : 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);
  }

~DRin()

trklet::DRin::~DRin ( )

inline

Definition at line 30 of file DRin.h.

{}

Member Function Documentation

consume()

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

Definition at line 61 of file DRin.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(), ALPAKA_ACCELERATOR_NAMESPACE::brokenline::constexpr(), trackerTFP::cot, dataFormats_, tt::deltaPhi(), digi(), tt::Setup::disk2SR(), enableTruncation_, dqmdumpme::first, amptDefault_cfi::frame, l1trig_cff::hwPhi, tt::Setup::hybridBaseR(), 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(), 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(), settings_, setup_, tt::Setup::stubPos(), SimL1Emulator_cff::stubs, stubs_, tt::Setup::tbWidthR(), tt::Setup::tiltedLayerLimitZ(), tt::Setup::trackletLayerId(), tracks_, funct::true, tt::Setup::type(), useTTStubResiduals_, TTBV::val(), validateGeometry_cfg::valid, tt::Setup::widthAddrBRAM18(), trklet::ChannelAssignment::widthSeedStubId(), trklet::Settings::zresidbits(), and trackerTFP::zT.

Referenced by trklet::ProducerDRin::produce().

                                                                                     {
    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;
          if (ttStubRef.isNull())
            continue;
          const int layerId = channelAssignment_->layerId(channel, layer);
          // 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 int indexLayerId = setup_->indexLayerId(ttStubRef);
          const SensorModule::Type type = setup_->type(ttStubRef);
          const int widthR = setup_->tbWidthR(type);
          const double baseR = setup_->hybridBaseR(type);
          const TTBV hwR(hw, widthR, 0, barrel);
          hw >>= widthR;
          double r = hwR.val(baseR) + (barrel ? setup_->hybridLayerR(indexLayerId) : 0.);
          if (type == SensorModule::Disk2S)
            r = setup_->disk2SR(indexLayerId, r);
          r = digi(r - 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_);
          const TTBV hwStubId(hw, channelAssignment_->widthSeedStubId(), 0, false);
          const int stubId = hwStubId.val();
          // 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, layerIdTracklet, false, stubId, ttR, phi, ttZ, psTilt);
          } else
            stubs_.emplace_back(ttStubRef, layerId, layerIdTracklet, false, stubId, 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 seedingLayer = 0; seedingLayer < channelAssignment_->numSeedingLayers(); seedingLayer++) {
          const int channelStub = channelAssignment_->numProjectionLayers(channel) + seedingLayer;
          const FrameStub& frameStub = streamsStub[offsetStub + channelStub][frame];
          const TTStubRef& ttStubRef = frameStub.first;
          if (ttStubRef.isNull())
            continue;
          const int layerId = channelAssignment_->layerId(channel, channelStub);
          const int layerIdTracklet = setup_->trackletLayerId(ttStubRef);
          const int stubId = TTBV(frameStub.second).val(channelAssignment_->widthSeedStubId());
          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, layerIdTracklet, true, stubId, ttR, phi, ttZ, psTilt);
          else
            stubs_.emplace_back(ttStubRef, layerId, layerIdTracklet, true, stubId, 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::DRin::digi ( double  val, double  base  ) const

inlineprivate

Definition at line 41 of file DRin.h.

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

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

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

pop_front()

template<class T >

T * trklet::DRin::pop_front ( std::deque< T *> &  ts ) const

private

Definition at line 443 of file DRin.cc.

References submitPVValidationJobs::t.

Referenced by produce().

                                        {
    T* t = nullptr;
    if (!ts.empty()) {
      t = ts.front();
      ts.pop_front();
    }
    return t;
  }

produce()

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

Definition at line 217 of file DRin.cc.

References baseHcot_, baseHinv2R_, baseHphi_, baseHphiT_, baseHr_, baseHz_, baseHzT_, baseLcot_, baseLinv2R_, baseLphi_, baseLphiT_, baseLz_, baseLzT_, tt::Setup::baseSector(), baseUcot_, baseUinv2R_, baseUphi_, baseUphiT_, baseUr_, baseUz_, baseUzT_, tt::Setup::boundarieEta(), channelAssignment_, trackerTFP::DataFormats::chosenRofPhi(), tt::Setup::chosenRofZ(), trackerTFP::cot, dataFormats_, trklet::ChannelAssignment::depthMemory(), digi(), PVValHelper::dz, enableTruncation_, cond::serialization::equal(), trackerTFP::DataFormats::format(), trackerTFP::hitPattern, hfClusterShapes_cfi::hits, ALPAKA_ACCELERATOR_NAMESPACE::caPixelDoublets::if(), input, input_, PixelMapPlotter::inputs, trackerTFP::DataFormat::inRange(), trackerTFP::inv2R, ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, tt::Setup::kfMinLayers(), trklet::DRin::Stub::layer_, trklet::DRin::Stub::layerDet_, layerEncoding_, trackerTFP::LayerEncoding::layerIdKF(), trklet::DRin::Stub::layerKF_, remoteMonitoring_LASER_era2018_cfg::limit, isotracks_cff::lostTracks, trackerTFP::LayerEncoding::maybePattern(), GetRecoTauVFromDQM_MC_cff::next, trklet::ChannelAssignment::nodeDR(), trklet::ChannelAssignment::numChannelsTrack(), tt::Setup::numFrames(), tt::Setup::numLayers(), trklet::ChannelAssignment::numNodesDR(), tt::Setup::numSectorsEta(), or, PVValHelper::phi, trklet::DRin::Stub::phi_, trackerTFP::phiT, pop_front(), trklet::DRin::Stub::psTilt_, alignCSCRings::r, trklet::DRin::Stub::r_, redigi(), region_, tt::Setup::sectorCot(), trackerTFP::sectorEta, trackerTFP::sectorPhi, setup_, svgfig::stack, trklet::DRin::Stub::stubId_, to_string(), trackerTFP::DataFormat::toUnsigned(), HLT_2024v14_cff::track, DiMuonV_cfg::tracks, tracks_, trackerTFP::DataFormat::ttBV(), trklet::DRin::Stub::ttStubRef_, trklet::DRin::Stub::valid_, tt::Setup::widthDSPbu(), trklet::ChannelAssignment::widthLayerId(), trklet::ChannelAssignment::widthSeedStubId(), detailsBasic3DVector::z, trklet::DRin::Stub::z_, and trackerTFP::zT.

Referenced by trklet::ProducerDRin::produce().

                                               {
    // 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_);
      for (Stub* stub : track.stubs_) {
        if (!stub->valid_)
          continue;
        // store encoded layerId
        stub->layerKF_ = layerEncoding_->layerIdKF(sectorEta, zT, cot, stub->layer_);
        // kill stubs from layers which can't be crossed by track
        if (stub->layerKF_ == -1)
          stub->valid_ = false;
      }
      TTBV hitPattern(0, setup_->numLayers());
      // kill multiple stubs from same kf layer
      for (Stub* stub : track.stubs_) {
        if (!stub->valid_)
          continue;
        if (hitPattern[stub->layerKF_])
          stub->valid_ = false;
        else
          hitPattern.set(stub->layerKF_);
      }
      // 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->layerKF_);
      if (hits.count() < setup_->kfMinLayers())
        track.valid_ = false;
    }
    // store helper
    auto frameTrack = [this](Track* track) {
      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" + sectorPhi.str() + sectorEta.str() + inv2R.str() + phiT.str() + zT.str() + cot.str()));
    };
    auto frameStub = [this](Track* track, int layer) {
      auto equal = [layer](Stub* stub) { return stub->valid_ && stub->layerKF_ == 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 layerId(stub->layerDet_, channelAssignment_->widthLayerId());
      const TTBV stubId(stub->stubId_, channelAssignment_->widthSeedStubId(), true);
      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_));
      return FrameStub(
          stub->ttStubRef_,
          Frame("1" + to_string(stub->psTilt_) + layerId.str() + stubId.str() + r.str() + phi.str() + z.str()));
    };
    // route tracks into pt bins and store result
    const int offsetTrack = region_ * channelAssignment_->numNodesDR();
    for (int nodeDR = 0; nodeDR < channelAssignment_->numNodesDR(); nodeDR++) {
      deque<Track*> accepted;
      deque<Track*> lost;
      vector<deque<Track*>> stacks(channelAssignment_->numChannelsTrack());
      vector<deque<Track*>> inputs(channelAssignment_->numChannelsTrack());
      for (int channel = 0; channel < channelAssignment_->numChannelsTrack(); channel++) {
        for (Track* track : input_[channel]) {
          const bool match = track && channelAssignment_->nodeDR(track->ttTrackRef_) == nodeDR;
          if (match && !track->valid_)
            lost.push_back(track);
          inputs[channel].push_back(match && track->valid_ ? track : nullptr);
        }
      }
      // remove all gaps between end and last track
      for (deque<Track*>& input : inputs)
        for (auto it = input.end(); it != input.begin();)
          it = (*--it) ? input.begin() : input.erase(it);
      // clock accurate firmware emulation, each while trip describes one clock tick, one stub in and one stub out per tick
      while (!all_of(inputs.begin(), inputs.end(), [](const deque<Track*>& tracks) { return tracks.empty(); }) or
             !all_of(stacks.begin(), stacks.end(), [](const deque<Track*>& tracks) { return tracks.empty(); })) {
        // fill input fifos
        for (int channel = 0; channel < channelAssignment_->numChannelsTrack(); channel++) {
          deque<Track*>& stack = stacks[channel];
          Track* track = pop_front(inputs[channel]);
          if (track) {
            if (enableTruncation_ && (int)stack.size() == channelAssignment_->depthMemory() - 1)
              lost.push_back(pop_front(stack));
            stack.push_back(track);
          }
        }
        // merge input fifos to one stream, prioritizing higher input channel over lower channel
        bool nothingToRoute(true);
        for (int channel = channelAssignment_->numChannelsTrack() - 1; channel >= 0; channel--) {
          Track* track = pop_front(stacks[channel]);
          if (track) {
            nothingToRoute = false;
            accepted.push_back(track);
            break;
          }
        }
        if (nothingToRoute)
          accepted.push_back(nullptr);
      }
      // truncate if desired
      if (enableTruncation_ && (int)accepted.size() > setup_->numFrames()) {
        const auto limit = next(accepted.begin(), setup_->numFrames());
        copy_if(limit, accepted.end(), back_inserter(lost), [](const Track* track) { return track; });
        accepted.erase(limit, accepted.end());
      }
      // remove all gaps between end and last track
      for (auto it = accepted.end(); it != accepted.begin();)
        it = (*--it) ? accepted.begin() : accepted.erase(it);
      // fill products StreamsStub& accpetedStubs, StreamsTrack& acceptedTracks, StreamsStub& lostStubs, StreamsTrack& lostTracks
      const int channelTrack = offsetTrack + nodeDR;
      const int offsetStub = channelTrack * setup_->numLayers();
      // fill lost tracks and stubs without gaps
      lostTracks[channelTrack].reserve(lost.size());
      for (int layer = 0; layer < setup_->numLayers(); layer++)
        lostStubs[offsetStub + layer].reserve(lost.size());
      for (Track* track : lost) {
        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(accepted.size());
      for (int layer = 0; layer < setup_->numLayers(); layer++)
        accpetedStubs[offsetStub + layer].reserve(accepted.size());
      for (Track* track : accepted) {
        if (!track) {  // 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::DRin::redigi ( double  val, double  baseLow, double  baseHigh, int  widthMultiplier  ) const

private

Definition at line 453 of file DRin.cc.

References edmMakeDummyCfis::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::DRin::baseHcot_

private

Definition at line 158 of file DRin.h.

Referenced by produce().

baseHinv2R_

double trklet::DRin::baseHinv2R_

private

Definition at line 156 of file DRin.h.

Referenced by produce().

baseHphi_

double trklet::DRin::baseHphi_

private

Definition at line 161 of file DRin.h.

Referenced by produce().

baseHphiT_

double trklet::DRin::baseHphiT_

private

Definition at line 157 of file DRin.h.

Referenced by produce().

baseHr_

double trklet::DRin::baseHr_

private

Definition at line 160 of file DRin.h.

Referenced by produce().

baseHz_

double trklet::DRin::baseHz_

private

Definition at line 162 of file DRin.h.

Referenced by produce().

baseHzT_

double trklet::DRin::baseHzT_

private

Definition at line 159 of file DRin.h.

Referenced by produce().

baseInvCot_

double trklet::DRin::baseInvCot_

private

Definition at line 164 of file DRin.h.

Referenced by consume(), and DRin().

baseLcot_

double trklet::DRin::baseLcot_

private

Definition at line 150 of file DRin.h.

Referenced by produce().

baseLinv2R_

double trklet::DRin::baseLinv2R_

private

Definition at line 148 of file DRin.h.

Referenced by produce().

baseLphi_

double trklet::DRin::baseLphi_

private

Definition at line 153 of file DRin.h.

Referenced by produce().

baseLphiT_

double trklet::DRin::baseLphiT_

private

Definition at line 149 of file DRin.h.

Referenced by produce().

baseLr_

double trklet::DRin::baseLr_

private

Definition at line 152 of file DRin.h.

baseLz_

double trklet::DRin::baseLz_

private

Definition at line 154 of file DRin.h.

Referenced by produce().

baseLzT_

double trklet::DRin::baseLzT_

private

Definition at line 151 of file DRin.h.

Referenced by produce().

baseUcot_

double trklet::DRin::baseUcot_

private

Definition at line 142 of file DRin.h.

Referenced by consume(), and produce().

baseUinv2R_

double trklet::DRin::baseUinv2R_

private

Definition at line 140 of file DRin.h.

Referenced by consume(), and produce().

baseUphi_

double trklet::DRin::baseUphi_

private

Definition at line 145 of file DRin.h.

Referenced by consume(), and produce().

baseUphiT_

double trklet::DRin::baseUphiT_

private

Definition at line 141 of file DRin.h.

Referenced by consume(), and produce().

baseUr_

double trklet::DRin::baseUr_

private

Definition at line 144 of file DRin.h.

Referenced by consume(), and produce().

baseUz_

double trklet::DRin::baseUz_

private

Definition at line 146 of file DRin.h.

Referenced by consume(), and produce().

baseUzT_

double trklet::DRin::baseUzT_

private

Definition at line 143 of file DRin.h.

Referenced by consume(), and produce().

channelAssignment_

const ChannelAssignment* trklet::DRin::channelAssignment_

private

Definition at line 128 of file DRin.h.

Referenced by consume(), and produce().

dataFormats_

const trackerTFP::DataFormats* trklet::DRin::dataFormats_

private

Definition at line 124 of file DRin.h.

Referenced by consume(), and produce().

enableTruncation_

bool trklet::DRin::enableTruncation_

private

Definition at line 118 of file DRin.h.

Referenced by consume(), and produce().

input_

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

private

Definition at line 138 of file DRin.h.

Referenced by consume(), and produce().

layerEncoding_

const trackerTFP::LayerEncoding* trklet::DRin::layerEncoding_

private

Definition at line 126 of file DRin.h.

Referenced by produce().

region_

const int trklet::DRin::region_

private

Definition at line 132 of file DRin.h.

Referenced by consume(), and produce().

settings_

const Settings* trklet::DRin::settings_

private

Definition at line 130 of file DRin.h.

Referenced by consume().

setup_

const tt::Setup* trklet::DRin::setup_

private

Definition at line 122 of file DRin.h.

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

stubs_

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

private

Definition at line 136 of file DRin.h.

Referenced by consume().

tracks_

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

private

Definition at line 134 of file DRin.h.

Referenced by consume(), and produce().

useTTStubResiduals_

bool trklet::DRin::useTTStubResiduals_

private

Definition at line 120 of file DRin.h.

Referenced by consume().