trackerTFP::HoughTransform Class Reference

#include <HoughTransform.h>

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

Private Member Functions
void	analyze ()
void	fillIn (int inv2R, std::deque< StubGP *> &inputSector, std::vector< StubHT *> &acceptedSector, std::vector< StubHT *> &lostSector)
template<class T >
T *	pop_front (std::deque< T *> &ts) const
void	put () const
void	readOut (const std::vector< StubHT *> &acceptedSector, const std::vector< StubHT *> &lostSector, std::deque< StubHT *> &acceptedAll, std::deque< StubHT *> &lostAll) const

Private Attributes
const DataFormats *	dataFormats_
bool	enableTruncation_
std::vector< std::vector< std::deque< StubGP * > > >	input_
DataFormat	inv2R_
DataFormat	phiT_
int	region_
const tt::Setup *	setup_
std::vector< StubGP >	stubsGP_
std::vector< StubHT >	stubsHT_

Detailed Description

Definition at line 15 of file HoughTransform.h.

Constructor & Destructor Documentation

HoughTransform()

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

Definition at line 18 of file HoughTransform.cc.

References trackerTFP::ht, trackerTFP::inv2R, and trackerTFP::phiT.

      : enableTruncation_(iConfig.getParameter<bool>("EnableTruncation")),
        setup_(setup),
        dataFormats_(dataFormats),
        inv2R_(dataFormats_->format(Variable::inv2R, Process::ht)),
        phiT_(dataFormats_->format(Variable::phiT, Process::ht)),
        region_(region),
        input_(dataFormats_->numChannel(Process::ht), vector<deque<StubGP*>>(dataFormats_->numChannel(Process::gp))) {}

~HoughTransform()

trackerTFP::HoughTransform::~HoughTransform ( )

inline

Definition at line 18 of file HoughTransform.h.

{}

Member Function Documentation

analyze()

void trackerTFP::HoughTransform::analyze ( )

private

consume()

void trackerTFP::HoughTransform::consume

(

const tt::StreamsStub &

streams

)

Definition at line 31 of file HoughTransform.cc.

References dataFormats_, amptDefault_cfi::frame, trackerTFP::gp, trackerTFP::ht, trackerTFP::StubGP::inInv2RBin(), input, input_, ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, trackerTFP::DataFormats::numChannel(), tt::Setup::numSectorsPhi(), hltrates_dqm_sourceclient-live_cfg::offset, push_back(), region_, nano_mu_digi_cff::sector, trackerTFP::sectorEta, trackerTFP::sectorPhi, setup_, cms::cuda::stream, HLT_2023v12_cff::streams, stubsGP_, stubsHT_, and trackerHitRTTI::vector.

                                                         {
    const int offset = region_ * dataFormats_->numChannel(Process::gp);
    auto validFrame = [](int sum, const FrameStub& frame) { return sum + (frame.first.isNonnull() ? 1 : 0); };
    int nStubsGP(0);
    for (int sector = 0; sector < dataFormats_->numChannel(Process::gp); sector++) {
      const StreamStub& stream = streams[offset + sector];
      nStubsGP += accumulate(stream.begin(), stream.end(), 0, validFrame);
    }
    stubsGP_.reserve(nStubsGP);
    for (int sector = 0; sector < dataFormats_->numChannel(Process::gp); sector++) {
      const int sectorPhi = sector % setup_->numSectorsPhi();
      const int sectorEta = sector / setup_->numSectorsPhi();
      for (const FrameStub& frame : streams[offset + sector]) {
        // Store input stubs in vector, so rest of HT algo can work with pointers to them (saves CPU)
        StubGP* stub = nullptr;
        if (frame.first.isNonnull()) {
          stubsGP_.emplace_back(frame, dataFormats_, sectorPhi, sectorEta);
          stub = &stubsGP_.back();
        }
        for (int binInv2R = 0; binInv2R < dataFormats_->numChannel(Process::ht); binInv2R++)
          input_[binInv2R][sector].push_back(stub && stub->inInv2RBin(binInv2R) ? stub : nullptr);
      }
    }
    // remove all gaps between end and last stub
    for (vector<deque<StubGP*>>& input : input_)
      for (deque<StubGP*>& stubs : input)
        for (auto it = stubs.end(); it != stubs.begin();)
          it = (*--it) ? stubs.begin() : stubs.erase(it);
    auto validStub = [](int sum, StubGP* stub) { return sum + (stub ? 1 : 0); };
    int nStubsHT(0);
    for (const vector<deque<StubGP*>>& binInv2R : input_)
      for (const deque<StubGP*>& sector : binInv2R)
        nStubsHT += accumulate(sector.begin(), sector.end(), 0, validStub);
    stubsHT_.reserve(nStubsHT);
  }

fillIn()

void trackerTFP::HoughTransform::fillIn ( int  inv2R, std::deque< StubGP *> &  inputSector, std::vector< StubHT *> &  acceptedSector, std::vector< StubHT *> &  lostSector  )

private

Definition at line 106 of file HoughTransform.cc.

References funct::abs(), trackerTFP::DataFormat::base(), enableTruncation_, trackerTFP::DataFormat::floating(), tt::Setup::htDepthMemory(), trackerTFP::DataFormat::inRange(), createfilelist::int, trackerTFP::DataFormat::integer(), trackerTFP::inv2R, inv2R_, remoteMonitoring_LASER_era2018_cfg::limit, SiStripPI::min, GetRecoTauVFromDQM_MC_cff::next, tt::Setup::numFrames(), trackerTFP::StubGP::phi(), trackerTFP::phiT, phiT_, pop_front(), trackerTFP::StubGP::r(), setup_, svgfig::stack, and stubsHT_.

Referenced by produce().

                                                           {
    // fifo, used to store stubs which belongs to a second possible track
    deque<StubHT*> stack;
    // clock accurate firmware emulation, each while trip describes one clock tick, one stub in and one stub out per tick
    while (!inputSector.empty() || !stack.empty()) {
      StubHT* stubHT = nullptr;
      StubGP* stubGP = pop_front(inputSector);
      if (stubGP) {
        const double phiT = stubGP->phi() - inv2R_.floating(inv2R) * stubGP->r();
        const int major = phiT_.integer(phiT);
        if (phiT_.inRange(major)) {
          // major candidate has pt > threshold (3 GeV)
          // stubHT records which HT bin this stub is added to
          stubsHT_.emplace_back(*stubGP, major, inv2R);
          stubHT = &stubsHT_.back();
        }
        const double chi = phiT - phiT_.floating(major);
        if (abs(stubGP->r() * inv2R_.base()) + 2. * abs(chi) >= phiT_.base()) {
          // stub belongs to two candidates
          const int minor = chi >= 0. ? major + 1 : major - 1;
          if (phiT_.inRange(minor)) {
            // second (minor) candidate has pt > threshold (3 GeV)
            stubsHT_.emplace_back(*stubGP, minor, inv2R);
            if (enableTruncation_ && (int)stack.size() == setup_->htDepthMemory() - 1)
              // buffer overflow
              lostSector.push_back(pop_front(stack));
            // store minor stub in fifo
            stack.push_back(&stubsHT_.back());
          }
        }
      }
      // take a minor stub if no major stub available
      acceptedSector.push_back(stubHT ? stubHT : pop_front(stack));
    }
    // truncate to many input stubs
    const auto limit = enableTruncation_
                           ? next(acceptedSector.begin(), min(setup_->numFrames(), (int)acceptedSector.size()))
                           : acceptedSector.end();
    copy_if(limit, acceptedSector.end(), back_inserter(lostSector), [](StubHT* stub) { return stub; });
    acceptedSector.erase(limit, acceptedSector.end());
  }

pop_front()

template<class T >

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

private

Definition at line 205 of file HoughTransform.cc.

References submitPVValidationJobs::t.

Referenced by fillIn().

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

produce()

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

Definition at line 68 of file HoughTransform.cc.

References dataFormats_, enableTruncation_, fillIn(), trackerTFP::ht, input_, createfilelist::int, trackerTFP::inv2R, inv2R_, remoteMonitoring_LASER_era2018_cfg::limit, SiStripPI::min, GetRecoTauVFromDQM_MC_cff::next, trackerTFP::DataFormats::numChannel(), tt::Setup::numFrames(), hltrates_dqm_sourceclient-live_cfg::offset, put(), readOut(), region_, setup_, cms::cuda::stream, and trackerTFP::DataFormat::toSigned().

                                                                       {
    for (int binInv2R = 0; binInv2R < dataFormats_->numChannel(Process::ht); binInv2R++) {
      const int inv2R = inv2R_.toSigned(binInv2R);
      deque<StubHT*> acceptedAll;
      deque<StubHT*> lostAll;
      for (deque<StubGP*>& inputSector : input_[binInv2R]) {
        const int size = inputSector.size();
        vector<StubHT*> acceptedSector;
        vector<StubHT*> lostSector;
        acceptedSector.reserve(size);
        lostSector.reserve(size);
        // associate stubs with inv2R and phiT bins
        fillIn(inv2R, inputSector, acceptedSector, lostSector);
        // Process::ht collects all stubs before readout starts -> remove all gaps
        acceptedSector.erase(remove(acceptedSector.begin(), acceptedSector.end(), nullptr), acceptedSector.end());
        // identify tracks
        readOut(acceptedSector, lostSector, acceptedAll, lostAll);
      }
      // truncate accepted stream
      const auto limit = enableTruncation_
                             ? next(acceptedAll.begin(), min(setup_->numFrames(), (int)acceptedAll.size()))
                             : acceptedAll.end();
      copy_if(limit, acceptedAll.end(), back_inserter(lostAll), [](StubHT* stub) { return stub; });
      acceptedAll.erase(limit, acceptedAll.end());
      // store found tracks
      auto put = [](const deque<StubHT*>& stubs, StreamStub& stream) {
        stream.reserve(stubs.size());
        for (StubHT* stub : stubs)
          stream.emplace_back(stub ? stub->frame() : FrameStub());
      };
      const int offset = region_ * dataFormats_->numChannel(Process::ht);
      put(acceptedAll, accepted[offset + binInv2R]);
      // store lost tracks
      put(lostAll, lost[offset + binInv2R]);
    }
  }

put()

void trackerTFP::HoughTransform::put ( ) const

private

Referenced by produce().

readOut()

void trackerTFP::HoughTransform::readOut ( const std::vector< StubHT *> &  acceptedSector, const std::vector< StubHT *> &  lostSector, std::deque< StubHT *> &  acceptedAll, std::deque< StubHT *> &  lostAll  ) const

private

Definition at line 152 of file HoughTransform.cc.

References tt::Setup::htMinLayers(), tt::Setup::htNumBinsPhiT(), hgcalTBTopologyTester_cfi::layers, tt::Setup::numLayers(), topSingleLeptonDQM_PU_cfi::pattern, trackerTFP::phiT, phiT_, setup_, trackerTFP::DataFormat::toSigned(), trackerTFP::DataFormat::toUnsigned(), HLT_2023v12_cff::track, DiMuonV_cfg::tracks, and HcalDetIdTransform::transform().

Referenced by produce().

                                                              {
    // used to recognise in which order tracks are found
    TTBV trkFoundPhiTs(0, setup_->htNumBinsPhiT());
    // hitPattern for all possible tracks, used to find tracks
    vector<TTBV> patternHits(setup_->htNumBinsPhiT(), TTBV(0, setup_->numLayers()));
    // found unsigned phiTs, ordered in time
    vector<int> binsPhiT;
    // stub container for all possible tracks
    vector<vector<StubHT*>> tracks(setup_->htNumBinsPhiT());
    for (int binPhiT = 0; binPhiT < setup_->htNumBinsPhiT(); binPhiT++) {
      const int phiT = phiT_.toSigned(binPhiT);
      auto samePhiT = [phiT](int sum, StubHT* stub) { return sum + (stub->phiT() == phiT); };
      const int numAccepted = accumulate(acceptedSector.begin(), acceptedSector.end(), 0, samePhiT);
      const int numLost = accumulate(lostSector.begin(), lostSector.end(), 0, samePhiT);
      tracks[binPhiT].reserve(numAccepted + numLost);
    }
    for (StubHT* stub : acceptedSector) {
      const int binPhiT = phiT_.toUnsigned(stub->phiT());
      TTBV& pattern = patternHits[binPhiT];
      pattern.set(stub->layer());
      tracks[binPhiT].push_back(stub);
      if (pattern.count() >= setup_->htMinLayers() && !trkFoundPhiTs[binPhiT]) {
        // first time track found
        trkFoundPhiTs.set(binPhiT);
        binsPhiT.push_back(binPhiT);
      }
    }
    // read out found tracks ordered as found
    for (int binPhiT : binsPhiT) {
      const vector<StubHT*>& track = tracks[binPhiT];
      acceptedAll.insert(acceptedAll.end(), track.begin(), track.end());
    }
    // look for lost tracks
    for (StubHT* stub : lostSector) {
      const int binPhiT = phiT_.toUnsigned(stub->phiT());
      if (!trkFoundPhiTs[binPhiT])
        tracks[binPhiT].push_back(stub);
    }
    for (int binPhiT : trkFoundPhiTs.ids(false)) {
      const vector<StubHT*>& track = tracks[binPhiT];
      set<int> layers;
      auto toLayer = [](StubHT* stub) { return stub->layer(); };
      transform(track.begin(), track.end(), inserter(layers, layers.begin()), toLayer);
      if ((int)layers.size() >= setup_->htMinLayers())
        lostAll.insert(lostAll.end(), track.begin(), track.end());
    }
  }

Member Data Documentation

dataFormats_

const DataFormats* trackerTFP::HoughTransform::dataFormats_

private

Definition at line 49 of file HoughTransform.h.

Referenced by consume(), and produce().

enableTruncation_

bool trackerTFP::HoughTransform::enableTruncation_

private

Definition at line 45 of file HoughTransform.h.

Referenced by fillIn(), and produce().

input_

std::vector<std::vector<std::deque<StubGP*> > > trackerTFP::HoughTransform::input_

private

Definition at line 61 of file HoughTransform.h.

Referenced by consume(), and produce().

inv2R_

DataFormat trackerTFP::HoughTransform::inv2R_

private

Definition at line 51 of file HoughTransform.h.

Referenced by fillIn(), and produce().

phiT_

DataFormat trackerTFP::HoughTransform::phiT_

private

Definition at line 53 of file HoughTransform.h.

Referenced by fillIn(), and readOut().

region_

int trackerTFP::HoughTransform::region_

private

Definition at line 55 of file HoughTransform.h.

Referenced by consume(), and produce().

setup_

const tt::Setup* trackerTFP::HoughTransform::setup_

private

Definition at line 47 of file HoughTransform.h.

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

stubsGP_

std::vector<StubGP> trackerTFP::HoughTransform::stubsGP_

private

Definition at line 57 of file HoughTransform.h.

Referenced by consume().

stubsHT_

std::vector<StubHT> trackerTFP::HoughTransform::stubsHT_

private

Definition at line 59 of file HoughTransform.h.

Referenced by consume(), and fillIn().