trackerTFP::ZHoughTransform Class Reference

#include <ZHoughTransform.h>

Public Member Functions
void	consume (const tt::StreamsStub &streams)
void	produce (tt::StreamsStub &accepted, tt::StreamsStub &lost)
	ZHoughTransform (const edm::ParameterSet &iConfig, const tt::Setup *setup, const DataFormats *dataFormats, int region)
	~ZHoughTransform ()

Private Member Functions
void	fill (int channel, const std::deque< StubZHT *> &input, std::vector< std::deque< StubZHT *>> &output)
void	merge (std::deque< StubZHT *> &stubs, tt::StreamStub &stream) const
template<class T >
T *	pop_front (std::deque< T *> &ts) const
void	slb (std::vector< std::deque< StubZHT *>> &inputs, std::deque< StubZHT *> &accepted, tt::StreamStub &lost) const

Private Attributes
const DataFormats *	dataFormats_
bool	enableTruncation_
std::vector< std::vector< StubZHT * > >	input_
int	region_
const tt::Setup *	setup_
int	stage_
std::vector< StubZHT >	stubsZHT_

Detailed Description

Definition at line 14 of file ZHoughTransform.h.

Constructor & Destructor Documentation

ZHoughTransform()

trackerTFP::ZHoughTransform::ZHoughTransform	(	const edm::ParameterSet &	iConfig,
		const tt::Setup *	setup,
		const DataFormats *	dataFormats,
		int	region
	)

Definition at line 18 of file ZHoughTransform.cc.

References trackerTFP::mht.

      : enableTruncation_(iConfig.getParameter<bool>("EnableTruncation")),
        setup_(setup),
        dataFormats_(dataFormats),
        region_(region),
        input_(dataFormats->numChannel(Process::mht)),
        stage_(0) {}

~ZHoughTransform()

trackerTFP::ZHoughTransform::~ZHoughTransform ( )

inline

Definition at line 20 of file ZHoughTransform.h.

{}

Member Function Documentation

consume()

void trackerTFP::ZHoughTransform::consume

(

const tt::StreamsStub &

streams

)

Definition at line 30 of file ZHoughTransform.cc.

References dataFormats_, amptDefault_cfi::frame, input_, trackerTFP::mht, trackerTFP::DataFormats::numChannel(), hltrates_dqm_sourceclient-live_cfg::offset, region_, setup_, cms::cuda::stream, HLT_2022v15_cff::streams, stubsZHT_, validateGeometry_cfg::valid, tt::Setup::zhtNumCells(), and tt::Setup::zhtNumStages().

                                                          {
    auto valid = [](int& sum, const FrameStub& frame) { return sum += (frame.first.isNonnull() ? 1 : 0); };
    const int offset = region_ * dataFormats_->numChannel(Process::mht);
    int nStubsMHT(0);
    for (int channel = 0; channel < dataFormats_->numChannel(Process::mht); channel++) {
      const StreamStub& stream = streams[offset + channel];
      nStubsMHT += accumulate(stream.begin(), stream.end(), 0, valid);
    }
    stubsZHT_.reserve(nStubsMHT * (setup_->zhtNumCells() * setup_->zhtNumStages()));
    for (int channel = 0; channel < dataFormats_->numChannel(Process::mht); channel++) {
      const StreamStub& stream = streams[offset + channel];
      vector<StubZHT*>& stubs = input_[channel];
      stubs.reserve(stream.size());
      // Store input stubs in vector, so rest of ZHT algo can work with pointers to them (saves CPU)
      for (const FrameStub& frame : stream) {
        StubZHT* stub = nullptr;
        if (frame.first.isNonnull()) {
          StubMHT stubMHT(frame, dataFormats_);
          stubsZHT_.emplace_back(stubMHT);
          stub = &stubsZHT_.back();
        }
        stubs.push_back(stub);
      }
    }
  }

fill()

void trackerTFP::ZHoughTransform::fill ( int  channel, const std::deque< StubZHT *> &  input, std::vector< std::deque< StubZHT *>> &  output  )

private

Definition at line 85 of file ZHoughTransform.cc.

References funct::abs(), trackerTFP::DataFormat::base(), trackerTFP::begin, cells, tt::Setup::chosenRofPhi(), tt::Setup::chosenRofZ(), trackerTFP::cot, ztail::d, dataFormats_, change_name::diff, HLT_2022v15_cff::distance, tt::Setup::dZ(), trackerTFP::DataFormats::format(), l1ctLayer2EG_cff::id, createfilelist::int, hgcalTopologyTester_cfi::layers, tt::Setup::mhtMinLayers(), GetRecoTauVFromDQM_MC_cff::next, funct::pow(), trackerTFP::r, alignCSCRings::s, tt::Setup::sectorCot(), EgammaValidation_Wenu_cff::sel, setup_, findQualityFiles::size, stage_, cms::cuda::stream, HLT_2022v15_cff::streams, stubsZHT_, HcalDetIdTransform::transform(), trackerTFP::zht, tt::Setup::zhtNumBinsZT(), tt::Setup::zhtNumCells(), tt::Setup::zhtNumStages(), and trackerTFP::zT.

Referenced by produce().

                                                                                                        {
    if (stubs.empty())
      return;
    const double baseZT =
        dataFormats_->format(Variable::zT, Process::zht).base() * pow(2, setup_->zhtNumStages() - stage_);
    const double baseCot =
        dataFormats_->format(Variable::cot, Process::zht).base() * pow(2, setup_->zhtNumStages() - stage_);
    int id;
    auto different = [&id](StubZHT* stub) { return !stub || id != stub->trackId(); };
    for (auto it = stubs.begin(); it != stubs.end();) {
      if (!*it) {
        const auto begin = find_if(it, stubs.end(), [](StubZHT* stub) { return stub; });
        const int nGaps = distance(it, begin);
        for (deque<StubZHT*>& stream : streams)
          stream.insert(stream.end(), nGaps, nullptr);
        it = begin;
        continue;
      }
      const auto start = it;
      const double cotGlobal = (*start)->cotf() + setup_->sectorCot((*start)->sectorEta());
      id = (*it)->trackId();
      it = find_if(it, stubs.end(), different);
      const int size = distance(start, it);
      // create finer track candidates stub container
      vector<vector<StubZHT*>> mhtCells(setup_->zhtNumCells());
      for (vector<StubZHT*>& mhtCell : mhtCells)
        mhtCell.reserve(size);
      // fill finer track candidates stub container
      for (auto stub = start; stub != it; stub++) {
        const double r = (*stub)->r() + setup_->chosenRofPhi() - setup_->chosenRofZ();
        const double chi = (*stub)->chi();
        const double dChi = setup_->dZ((*stub)->ttStubRef(), cotGlobal);
        // identify finer track candidates for this stub
        // 0 and 1 belong to the ZHT cells with smaller cot; 0 and 2 belong to those with smaller zT
        vector<int> cells;
        cells.reserve(setup_->zhtNumCells());
        const bool compA = 2. * abs(chi) < baseZT + dChi;
        const bool compB = 2. * abs(chi) < abs(r) * baseCot + dChi;
        const bool compC = 2. * abs(chi) < dChi;
        if (chi >= 0. && r >= 0.) {
          cells.push_back(1);
          if (compA)
            cells.push_back(3);
          if (compB)
            cells.push_back(0);
          if (compC)
            cells.push_back(2);
        }
        if (chi >= 0. && r < 0.) {
          cells.push_back(3);
          if (compA)
            cells.push_back(1);
          if (compB)
            cells.push_back(2);
          if (compC)
            cells.push_back(0);
        }
        if (chi < 0. && r >= 0.) {
          cells.push_back(2);
          if (compA)
            cells.push_back(0);
          if (compB)
            cells.push_back(3);
          if (compC)
            cells.push_back(1);
        }
        if (chi < 0. && r < 0.) {
          cells.push_back(0);
          if (compA)
            cells.push_back(2);
          if (compB)
            cells.push_back(1);
          if (compC)
            cells.push_back(3);
        }
        for (int cell : cells) {
          const double cot = (cell / setup_->zhtNumBinsZT() - .5) * baseCot / 2.;
          const double zT = (cell % setup_->zhtNumBinsZT() - .5) * baseZT / 2.;
          stubsZHT_.emplace_back(**stub, zT, cot, cell);
          mhtCells[cell].push_back(&stubsZHT_.back());
        }
      }
      // perform pattern recognition
      for (int sel = 0; sel < setup_->zhtNumCells(); sel++) {
        deque<StubZHT*>& stream = streams[channel * setup_->zhtNumCells() + sel];
        vector<StubZHT*>& mhtCell = mhtCells[sel];
        set<int> layers;
        auto toLayer = [](StubZHT* stub) { return stub->layer(); };
        transform(mhtCell.begin(), mhtCell.end(), inserter(layers, layers.begin()), toLayer);
        if ((int)layers.size() < setup_->mhtMinLayers())
          mhtCell.clear();
        for (StubZHT* stub : mhtCell)
          stream.push_back(stub);
        stream.insert(stream.end(), size - (int)mhtCell.size(), nullptr);
      }
    }
    for (int sel = 0; sel < setup_->zhtNumCells(); sel++) {
      deque<StubZHT*>& stream = streams[channel * setup_->zhtNumCells() + sel];
      // remove all gaps between end and last stub
      for (auto it = stream.end(); it != stream.begin();)
        it = (*--it) ? stream.begin() : stream.erase(it);
      // read out fine track cannot start before rough track has read in completely, add gaps to take this into account
      int pos(0);
      for (auto it = stream.begin(); it != stream.end();) {
        if (!(*it)) {
          it = stream.erase(it);
          continue;
        }
        id = (*it)->trackId();
        const int s = distance(it, find_if(it, stream.end(), different));
        const int d = distance(stream.begin(), it);
        pos += s;
        if (d < pos) {
          const int diff = pos - d;
          it = stream.insert(it, diff, nullptr);
          it = next(it, diff);
        } else
          it = stream.erase(remove(next(stream.begin(), pos), it, nullptr), it);
        it = next(it, s);
      }
      // adjust stream start so that first output stub is in first place in case of quickest track
      if (!stream.empty())
        stream.erase(stream.begin(), next(stream.begin(), setup_->mhtMinLayers()));
    }
  }

merge()

void trackerTFP::ZHoughTransform::merge ( std::deque< StubZHT *> &  stubs, tt::StreamStub &  stream  ) const

private

Definition at line 266 of file ZHoughTransform.cc.

References HLT_2022v15_cff::candidates, trackerTFP::cot, HLT_2022v15_cff::distance, trackerTFP::Stub< Ts >::frame(), l1ctLayer2EG_cff::id, createfilelist::int, visualization-live-secondInstance_cfg::m, SiStripPI::max, SiStripPI::min, funct::pow(), alignCSCRings::s, setup_, findQualityFiles::size, cms::cuda::stream, HLT_2022v15_cff::track, tracks, mps_merge::weight, tt::Setup::zhtNumCells(), tt::Setup::zhtNumStages(), and trackerTFP::zT.

Referenced by produce().

                                                                              {
    stubs.erase(remove(stubs.begin(), stubs.end(), nullptr), stubs.end());
    /*stream.reserve(stubs.size());
    transform(stubs.begin(), stubs.end(), back_inserter(stream), [](StubZHT* stub){ return stub->frame(); });
    return;*/
    map<int, set<pair<int, int>>> candidates;
    const int weight = setup_->zhtNumCells() * pow(2, setup_->zhtNumStages());
    for (const StubZHT* stub : stubs)
      candidates[stub->trackId() / weight].emplace(stub->cot(), stub->zT());
    vector<deque<FrameStub>> tracks(candidates.size());
    for (auto it = stubs.begin(); it != stubs.end();) {
      const auto start = it;
      const int id = (*it)->trackId();
      const int candId = id / weight;
      const auto m = candidates.find(candId);
      pair<int, int> cotp(9e9, -9e9);
      pair<int, int> zTp(9e9, -9e9);
      for (const pair<int, int>& para : m->second) {
        cotp = {min(cotp.first, para.first), max(cotp.second, para.first)};
        zTp = {min(zTp.first, para.second), max(zTp.second, para.second)};
      }
      const int cot = (cotp.first + cotp.second) / 2;
      const int zT = (cotp.first + cotp.second) / 2;
      const int pos = distance(candidates.begin(), m);
      deque<FrameStub>& track = tracks[pos];
      auto different = [id](const StubZHT* stub) { return id != stub->trackId(); };
      it = find_if(it, stubs.end(), different);
      for (auto s = start; s != it; s++) {
        if (find_if(track.begin(), track.end(), [s](const FrameStub& stub) {
              return (*s)->ttStubRef() == stub.first;
            }) != track.end())
          continue;
        const StubZHT stub(**s, cot, zT);
        track.push_back(stub.frame());
      }
    }
    const int size = accumulate(tracks.begin(), tracks.end(), 0, [](int& sum, const deque<FrameStub>& stubs) {
      return sum += (int)stubs.size();
    });
    stream.reserve(size);
    for (deque<FrameStub>& track : tracks)
      for (const FrameStub& stub : track)
        stream.push_back(stub);
  }

pop_front()

template<class T >

T * trackerTFP::ZHoughTransform::pop_front ( std::deque< T *> &  ts ) const

private

Definition at line 313 of file ZHoughTransform.cc.

References submitPVValidationJobs::t.

Referenced by slb().

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

produce()

void trackerTFP::ZHoughTransform::produce	(	tt::StreamsStub &	accepted,
		tt::StreamsStub &	lost
	)

Definition at line 57 of file ZHoughTransform.cc.

References trackerTFP::begin, dataFormats_, fill(), input_, dqmdumpme::k, merge(), trackerTFP::mht, trackerTFP::DataFormats::numChannel(), region_, setup_, slb(), stage_, cms::cuda::stream, HLT_2022v15_cff::streams, edm::swap(), createJobs::tmp, tt::Setup::zhtNumCells(), and tt::Setup::zhtNumStages().

                                                                        {
    vector<deque<StubZHT*>> streams(dataFormats_->numChannel(Process::mht));
    for (int channel = 0; channel < dataFormats_->numChannel(Process::mht); channel++)
      streams[channel] = deque<StubZHT*>(input_[channel].begin(), input_[channel].end());
    vector<deque<StubZHT*>> stubsCells(dataFormats_->numChannel(Process::mht) * setup_->zhtNumCells());
    for (stage_ = 0; stage_ < setup_->zhtNumStages(); stage_++) {
      // fill ZHT cells
      for (int channel = 0; channel < dataFormats_->numChannel(Process::mht); channel++)
        fill(channel, streams[channel], stubsCells);
      // perform static load balancing
      for (int channel = 0; channel < dataFormats_->numChannel(Process::mht); channel++) {
        vector<deque<StubZHT*>> tmp(setup_->zhtNumCells());
        // gather streams to mux together: same ZHT cell of 4 adjacent ZHT input streams
        for (int k = 0; k < setup_->zhtNumCells(); k++)
          //swap(tmp[k], stubsCells[(channel / setup_->zhtNumCells()) * dataFormats_->numChannel(Process::mht) + channel % setup_->zhtNumCells() + k * setup_->zhtNumCells()]);
          swap(tmp[k], stubsCells[channel * setup_->zhtNumCells() + k]);
        slb(tmp, streams[channel], lost[channel]);
      }
    }
    // fill output product
    for (int channel = 0; channel < dataFormats_->numChannel(Process::mht); channel++) {
      deque<StubZHT*>& stubs = streams[channel];
      StreamStub& stream = accepted[region_ * dataFormats_->numChannel(Process::mht) + channel];
      merge(stubs, stream);
    }
  }

slb()

void trackerTFP::ZHoughTransform::slb ( std::vector< std::deque< StubZHT *>> &  inputs, std::deque< StubZHT *> &  accepted, tt::StreamStub &  lost  ) const

private

Definition at line 212 of file ZHoughTransform.cc.

References ztail::d, relativeConstraints::empty, remoteMonitoring_LED_IterMethod_cfg::enable, enableTruncation_, PixelMapPlotter::inputs, remoteMonitoring_LASER_era2018_cfg::limit, GetRecoTauVFromDQM_MC_cff::next, tt::Setup::numFrames(), or, pop_front(), setup_, validateGeometry_cfg::valid, and tt::Setup::zhtNumCells().

Referenced by produce().

                                                                                                              {
    accepted.clear();
    if (all_of(inputs.begin(), inputs.end(), [](const deque<StubZHT*>& stubs) { return stubs.empty(); }))
      return;
    // input fifos
    vector<deque<StubZHT*>> stacks(setup_->zhtNumCells());
    // helper for handshake
    TTBV empty(-1, setup_->zhtNumCells(), true);
    TTBV enable(0, setup_->zhtNumCells());
    // 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<StubZHT*>& d) { return d.empty(); }) or
           !all_of(stacks.begin(), stacks.end(), [](const deque<StubZHT*>& d) { return d.empty(); })) {
      // store stub in fifo
      for (int channel = 0; channel < setup_->zhtNumCells(); channel++) {
        StubZHT* stub = pop_front(inputs[channel]);
        if (stub)
          stacks[channel].push_back(stub);
      }
      // identify empty fifos
      for (int channel = 0; channel < setup_->zhtNumCells(); channel++)
        empty[channel] = stacks[channel].empty();
      // chose new fifo to read from if current fifo got empty
      const int iEnableOld = enable.plEncode();
      if (enable.none() || empty[iEnableOld]) {
        enable.reset();
        const int iNotEmpty = empty.plEncode(false);
        if (iNotEmpty < setup_->zhtNumCells())
          enable.set(iNotEmpty);
      }
      // read from chosen fifo
      const int iEnable = enable.plEncode();
      if (enable.any())
        accepted.push_back(pop_front(stacks[iEnable]));
      else
        // gap if no fifo has been chosen
        accepted.push_back(nullptr);
    }
    // perform truncation if desired
    if (enableTruncation_ && (int)accepted.size() > setup_->numFrames()) {
      const auto limit = next(accepted.begin(), setup_->numFrames());
      auto valid = [](int& sum, StubZHT* stub) { return sum += stub ? 1 : 0; };
      const int nLost = accumulate(limit, accepted.end(), 0, valid);
      lost.reserve(nLost);
      for (auto it = limit; it != accepted.end(); it++)
        if (*it)
          lost.emplace_back((*it)->frame());
      accepted.erase(limit, accepted.end());
    }
    // cosmetics -- remove gaps at the end of stream
    for (auto it = accepted.end(); it != accepted.begin();)
      it = (*--it) == nullptr ? accepted.erase(it) : accepted.begin();
  }

Member Data Documentation

dataFormats_

const DataFormats* trackerTFP::ZHoughTransform::dataFormats_

private

Definition at line 43 of file ZHoughTransform.h.

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

enableTruncation_

bool trackerTFP::ZHoughTransform::enableTruncation_

private

Definition at line 39 of file ZHoughTransform.h.

Referenced by slb().

input_

std::vector<std::vector<StubZHT*> > trackerTFP::ZHoughTransform::input_

private

Definition at line 49 of file ZHoughTransform.h.

Referenced by consume(), and produce().

region_

int trackerTFP::ZHoughTransform::region_

private

Definition at line 45 of file ZHoughTransform.h.

Referenced by consume(), and produce().

setup_

const tt::Setup* trackerTFP::ZHoughTransform::setup_

private

Definition at line 41 of file ZHoughTransform.h.

Referenced by consume(), fill(), merge(), produce(), upgradeWorkflowComponents.UpgradeWorkflow::setup(), and slb().

stage_

int trackerTFP::ZHoughTransform::stage_

private

Definition at line 51 of file ZHoughTransform.h.

Referenced by fill(), and produce().

stubsZHT_

std::vector<StubZHT> trackerTFP::ZHoughTransform::stubsZHT_

private

Definition at line 47 of file ZHoughTransform.h.

Referenced by consume(), and fill().