trklet::DR Class Reference

Class to bit- and clock-accurate emulate duplicate removal DR identifies duplicates based on pairs of tracks that share stubs in at least 3 layers. It keeps the first such track in each pair. More...

#include <DR.h>

Classes
struct	Stub
struct	Track

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

Private Member Functions
bool	equalEnough (Track *t0, Track *t1) const

Private Attributes
const ChannelAssignment *	channelAssignment_
const trackerTFP::DataFormats *	dataFormats_
bool	enableTruncation_
std::vector< std::vector< Track * > >	input_
const int	region_
const tt::Setup *	setup_
std::vector< Stub >	stubs_
std::vector< Track >	tracks_

Detailed Description

Class to bit- and clock-accurate emulate duplicate removal DR identifies duplicates based on pairs of tracks that share stubs in at least 3 layers. It keeps the first such track in each pair.

Author

Thomas Schuh

Date

2023, Feb

Definition at line 19 of file DR.h.

Constructor & Destructor Documentation

DR()

trklet::DR::DR	(	const edm::ParameterSet &	iConfig,
		const tt::Setup *	setup_,
		const trackerTFP::DataFormats *	dataFormats,
		const ChannelAssignment *	channelAssignment,
		int	region
	)

Definition at line 14 of file DR.cc.

      : enableTruncation_(iConfig.getParameter<bool>("EnableTruncation")),
        setup_(setup),
        dataFormats_(dataFormats),
        channelAssignment_(channelAssignment),
        region_(region),
        input_(channelAssignment_->numNodesDR()) {}

~DR()

trklet::DR::~DR ( )

inline

Definition at line 26 of file DR.h.

{}

Member Function Documentation

consume()

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

Definition at line 27 of file DR.cc.

References channelAssignment_, dataFormats_, trackerTFP::DataFormats::format(), amptDefault_cfi::frame, input, input_, createfilelist::int, ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, tt::Setup::numLayers(), trklet::ChannelAssignment::numNodesDR(), PVValHelper::phi, alignCSCRings::r, region_, setup_, SimL1Emulator_cff::stubs, stubs_, tracks_, trackerTFP::DataFormat::width(), trklet::ChannelAssignment::widthLayerId(), trklet::ChannelAssignment::widthPSTilt(), trklet::ChannelAssignment::widthSeedStubId(), and ctppsOpticalFunctions_non_DB_cff::z.

                                                                                   {
    const int offsetTrack = region_ * channelAssignment_->numNodesDR();
    auto nonNullTrack = [](int sum, const FrameTrack& frame) { return sum + (frame.first.isNonnull() ? 1 : 0); };
    auto nonNullStub = [](int sum, const FrameStub& frame) { return sum + (frame.first.isNonnull() ? 1 : 0); };
    // count tracks and stubs and reserve corresponding vectors
    int sizeTracks(0);
    int sizeStubs(0);
    for (int channel = 0; channel < channelAssignment_->numNodesDR(); channel++) {
      const int streamTrackId = offsetTrack + channel;
      const int offsetStub = streamTrackId * setup_->numLayers();
      const StreamTrack& streamTrack = streamsTrack[streamTrackId];
      input_[channel].reserve(streamTrack.size());
      sizeTracks += accumulate(streamTrack.begin(), streamTrack.end(), 0, nonNullTrack);
      for (int layer = 0; layer < setup_->numLayers(); layer++) {
        const StreamStub& streamStub = streamsStub[offsetStub + layer];
        sizeStubs += accumulate(streamStub.begin(), streamStub.end(), 0, nonNullStub);
      }
    }
    tracks_.reserve(sizeTracks);
    stubs_.reserve(sizeStubs);
    // transform input data into handy structs
    for (int channel = 0; channel < channelAssignment_->numNodesDR(); channel++) {
      vector<Track*>& input = input_[channel];
      const int streamTrackId = offsetTrack + channel;
      const int offsetStub = streamTrackId * setup_->numLayers();
      const StreamTrack& streamTrack = streamsTrack[streamTrackId];
      for (int frame = 0; frame < (int)streamTrack.size(); frame++) {
        const FrameTrack& frameTrack = streamTrack[frame];
        if (frameTrack.first.isNull()) {
          input.push_back(nullptr);
          continue;
        }
        vector<Stub*> stubs;
        stubs.reserve(setup_->numLayers());
        for (int layer = 0; layer < setup_->numLayers(); layer++) {
          const FrameStub& frameStub = streamsStub[offsetStub + layer][frame];
          if (frameStub.first.isNull())
            continue;
          TTBV ttBV = frameStub.second;
          const TTBV z(ttBV, dataFormats_->format(Variable::z, Process::kfin).width(), 0, true);
          ttBV >>= dataFormats_->format(Variable::z, Process::kfin).width();
          const TTBV phi(ttBV, dataFormats_->format(Variable::phi, Process::kfin).width(), 0, true);
          ttBV >>= dataFormats_->format(Variable::phi, Process::kfin).width();
          const TTBV r(ttBV, dataFormats_->format(Variable::r, Process::kfin).width(), 0, true);
          ttBV >>= dataFormats_->format(Variable::r, Process::kfin).width();
          const TTBV stubId(ttBV, channelAssignment_->widthSeedStubId(), 0);
          ttBV >>= channelAssignment_->widthSeedStubId();
          const TTBV layerId(ttBV, channelAssignment_->widthLayerId(), 0);
          ttBV >>= channelAssignment_->widthLayerId();
          const TTBV tilt(ttBV, channelAssignment_->widthPSTilt(), 0);
          const FrameStub frame(frameStub.first,
                                Frame("1" + tilt.str() + layerId.str() + r.str() + phi.str() + z.str()));
          stubs_.emplace_back(frame, stubId.val(), layer);
          stubs.push_back(&stubs_.back());
        }
        tracks_.emplace_back(frameTrack, stubs);
        input.push_back(&tracks_.back());
      }
      // remove all gaps between end and last track
      for (auto it = input.end(); it != input.begin();)
        it = (*--it) ? input.begin() : input.erase(it);
    }
  }

equalEnough()

bool trklet::DR::equalEnough ( Track *  t0, Track *  t1  ) const

private

Definition at line 148 of file DR.cc.

References channelAssignment_, trklet::ChannelAssignment::minIdenticalStubs(), tt::Setup::numLayers(), setup_, FrontierCondition_GT_autoExpress_cfi::t0, and RandomServiceHelper::t1.

Referenced by produce().

                                                 {
    int same(0);
    for (int layer = 0; layer < setup_->numLayers(); layer++) {
      auto onLayer = [layer](Stub* stub) { return stub->channel_ == layer; };
      const auto s0 = find_if(t0->stubs_.begin(), t0->stubs_.end(), onLayer);
      const auto s1 = find_if(t1->stubs_.begin(), t1->stubs_.end(), onLayer);
      if (s0 != t0->stubs_.end() && s1 != t1->stubs_.end() && **s0 == **s1)
        same++;
    }
    return same >= channelAssignment_->minIdenticalStubs();
  }

produce()

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

Definition at line 92 of file DR.cc.

References trklet::DR::Stub::channel_, channelAssignment_, equalEnough(), trklet::DR::Stub::frame_, trackerTFP::hitPattern, input_, ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, trklet::ChannelAssignment::numComparisonModules(), tt::Setup::numLayers(), trklet::ChannelAssignment::numNodesDR(), region_, setup_, HLT_2024v14_cff::track, and DiMuonV_cfg::tracks.

                                             {
    const int offsetTrack = region_ * channelAssignment_->numNodesDR();
    for (int node = 0; node < channelAssignment_->numNodesDR(); node++) {
      const int channelTrack = offsetTrack + node;
      const int offsetStub = channelTrack * setup_->numLayers();
      // remove duplicated tracks, no merge of stubs, one stub per layer expected
      vector<Track*> cms(channelAssignment_->numComparisonModules(), nullptr);
      vector<Track*>& tracks = input_[node];
      for (Track*& track : tracks) {
        if (!track)
          // gaps propagate trough chain and appear in output stream
          continue;
        for (Track*& trackCM : cms) {
          if (!trackCM) {
            // tracks used in CMs propagate trough chain and appear in output stream unaltered
            trackCM = track;
            break;
          }
          if (equalEnough(track, trackCM)) {
            // tracks compared in CMs propagate trough chain and appear in output stream as gap if identified as duplicate or unaltered elsewise
            track = nullptr;
            break;
          }
        }
      }
      // remove all gaps between end and last track
      for (auto it = tracks.end(); it != tracks.begin();)
        it = (*--it) ? tracks.begin() : tracks.erase(it);
      // store output
      StreamTrack& streamTrack = acceptedTracks[channelTrack];
      streamTrack.reserve(tracks.size());
      for (int layer = 0; layer < setup_->numLayers(); layer++)
        accpetedStubs[offsetStub + layer].reserve(tracks.size());
      for (Track* track : tracks) {
        if (!track) {
          streamTrack.emplace_back(FrameTrack());
          for (int layer = 0; layer < setup_->numLayers(); layer++)
            accpetedStubs[offsetStub + layer].emplace_back(FrameStub());
          continue;
        }
        streamTrack.push_back(track->frame_);
        TTBV hitPattern(0, setup_->numLayers());
        for (Stub* stub : track->stubs_) {
          hitPattern.set(stub->channel_);
          accpetedStubs[offsetStub + stub->channel_].push_back(stub->frame_);
        }
        for (int layer : hitPattern.ids(false))
          accpetedStubs[offsetStub + layer].emplace_back(FrameStub());
      }
    }
  }

Member Data Documentation

channelAssignment_

const ChannelAssignment* trklet::DR::channelAssignment_

private

Definition at line 62 of file DR.h.

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

dataFormats_

const trackerTFP::DataFormats* trklet::DR::dataFormats_

private

Definition at line 60 of file DR.h.

Referenced by consume().

enableTruncation_

bool trklet::DR::enableTruncation_

private

Definition at line 56 of file DR.h.

input_

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

private

Definition at line 70 of file DR.h.

Referenced by consume(), and produce().

region_

const int trklet::DR::region_

private

Definition at line 64 of file DR.h.

Referenced by consume(), and produce().

setup_

const tt::Setup* trklet::DR::setup_

private

Definition at line 58 of file DR.h.

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

stubs_

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

private

Definition at line 68 of file DR.h.

Referenced by consume().

tracks_

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

private

Definition at line 66 of file DR.h.

Referenced by consume().