trackerDTC::DTC Class Reference

Class to represent an outer tracker DTC board. More...

#include <DTC.h>

Public Member Functions
	DTC (const edm::ParameterSet &iConfig, const tt::Setup *setup, const LayerEncoding *layerEncoding, int dtcId, const std::vector< std::vector< TTStubRef >> &stubsDTC)
void	produce (TTDTC &accepted, TTDTC &lost)
	~DTC ()

Private Types
typedef std::deque< Stub * >	Stubs
typedef std::vector< Stubs >	Stubss
typedef std::vector< Stubss >	Stubsss

Private Member Functions
void	merge (Stubss &inputs, Stubs &output, Stubs &lost)
Stub *	pop_front (Stubs &stubs)
void	produce (const Stubss &stubss, TTDTC &product)
void	split (Stubss &inputs, Stubss &outputs)

Private Attributes
int	board_
bool	enableTruncation_
Stubsss	input_
Stubss	lost_
std::vector< tt::SensorModule * >	modules_
int	region_
const tt::Setup *	setup_
std::vector< Stub >	stubs_

Detailed Description

Class to represent an outer tracker DTC board.

Author

Thomas Schuh

Date

2020, Jan

Definition at line 19 of file DTC.h.

Member Typedef Documentation

Stubs

typedef std::deque<Stub*> trackerDTC::DTC::Stubs

private

Definition at line 21 of file DTC.h.

Stubss

typedef std::vector<Stubs> trackerDTC::DTC::Stubss

private

Definition at line 22 of file DTC.h.

Stubsss

typedef std::vector<Stubss> trackerDTC::DTC::Stubsss

private

Definition at line 23 of file DTC.h.

Constructor & Destructor Documentation

DTC()

trackerDTC::DTC::DTC	(	const edm::ParameterSet &	iConfig,
		const tt::Setup *	setup,
		const LayerEncoding *	layerEncoding,
		int	dtcId,
		const std::vector< std::vector< TTStubRef >> &	stubsDTC
	)

Definition at line 14 of file DTC.cc.

References funct::abs(), trackerDTC::Stub::bend(), enableTruncation_, input_, remoteMonitoring_LASER_era2018_cfg::limit, lost_, modules_, GetRecoTauVFromDQM_MC_cff::next, nano_mu_digi_cff::region, singleTopDQM_cfi::setup, jetUpdater_cfi::sort, stubs_, and trackerDTC::Stub::valid().

      : setup_(setup),
        enableTruncation_(iConfig.getParameter<bool>("EnableTruncation")),
        region_(dtcId / setup->numDTCsPerRegion()),
        board_(dtcId % setup->numDTCsPerRegion()),
        modules_(setup->dtcModules(dtcId)),
        input_(setup->dtcNumRoutingBlocks(), Stubss(setup->dtcNumModulesPerRoutingBlock())),
        lost_(setup->numOverlappingRegions()) {
    // count number of stubs on this dtc
    auto acc = [](int sum, const vector<TTStubRef>& stubsModule) { return sum + stubsModule.size(); };
    const int nStubs = accumulate(stubsDTC.begin(), stubsDTC.end(), 0, acc);
    stubs_.reserve(nStubs);
    // convert and assign Stubs to DTC routing block channel
    for (int modId = 0; modId < setup->numModulesPerDTC(); modId++) {
      const vector<TTStubRef>& ttStubRefs = stubsDTC[modId];
      if (ttStubRefs.empty())
        continue;
      // Module which produced this ttStubRefs
      SensorModule* module = modules_.at(modId);
      // DTC routing block id [0-1]
      const int blockId = modId / setup->dtcNumModulesPerRoutingBlock();
      // DTC routing blockc  channel id [0-35]
      const int channelId = modId % setup->dtcNumModulesPerRoutingBlock();
      // convert TTStubs and fill input channel
      Stubs& stubs = input_[blockId][channelId];
      for (const TTStubRef& ttStubRef : ttStubRefs) {
        stubs_.emplace_back(iConfig, setup, layerEncoding, module, ttStubRef);
        Stub& stub = stubs_.back();
        if (stub.valid())
          // passed pt and eta cut
          stubs.push_back(&stub);
      }
      // sort stubs by bend
      sort(stubs.begin(), stubs.end(), [](Stub* lhs, Stub* rhs) { return abs(lhs->bend()) < abs(rhs->bend()); });
      // truncate stubs if desired
      if (!enableTruncation_ || (int)stubs.size() <= setup->numFramesFE())
        continue;
      // begin of truncated stubs
      const auto limit = next(stubs.begin(), setup->numFramesFE());
      // copy truncated stubs into lost output channel
      for (int region = 0; region < setup->numOverlappingRegions(); region++)
        copy_if(
            limit, stubs.end(), back_inserter(lost_[region]), [region](Stub* stub) { return stub->inRegion(region); });
      // remove truncated stubs form input channel
      stubs.erase(limit, stubs.end());
    }
  }

~DTC()

trackerDTC::DTC::~DTC ( )

inline

Definition at line 31 of file DTC.h.

{}

Member Function Documentation

merge()

void trackerDTC::DTC::merge ( Stubss &  inputs, Stubs &  output, Stubs &  lost  )

private

Definition at line 87 of file DTC.cc.

References tt::Setup::dtcDepthMemory(), enableTruncation_, input, PixelMapPlotter::inputs, createfilelist::int, ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, remoteMonitoring_LASER_era2018_cfg::limit, GetRecoTauVFromDQM_MC_cff::next, tt::Setup::numFramesIO(), or, pop_front(), setup_, and svgfig::stack.

Referenced by produce(), and split().

                                                            {
    // for each input one fifo
    Stubss stacks(inputs.size());
    // clock accurate firmware emulation, each while trip describes one clock tick
    while (!all_of(inputs.begin(), inputs.end(), [](const Stubs& channel) { return channel.empty(); }) or
           !all_of(stacks.begin(), stacks.end(), [](const Stubs& channel) { return channel.empty(); })) {
      // fill fifos
      for (int iInput = 0; iInput < (int)inputs.size(); iInput++) {
        Stubs& input = inputs[iInput];
        Stubs& stack = stacks[iInput];
        if (input.empty())
          continue;
        Stub* stub = pop_front(input);
        if (stub) {
          if (enableTruncation_ && (int)stack.size() == setup_->dtcDepthMemory() - 1)
            // kill current first stub when fifo overflows
            lost.push_back(pop_front(stack));
          stack.push_back(stub);
        }
      }
      // route stub from a fifo to output if possible
      bool nothingToRoute(true);
      for (int iInput = inputs.size() - 1; iInput >= 0; iInput--) {
        Stubs& stack = stacks[iInput];
        if (stack.empty())
          continue;
        nothingToRoute = false;
        output.push_back(pop_front(stack));
        // only one stub can be routed to output per clock tick
        break;
      }
      // each clock tick output will grow by one, if no stub is available then by a gap
      if (nothingToRoute)
        output.push_back(nullptr);
    }
    // truncate if desired
    if (enableTruncation_ && (int)output.size() > setup_->numFramesIO()) {
      const auto limit = next(output.begin(), setup_->numFramesIO());
      copy_if(limit, output.end(), back_inserter(lost), [](Stub* stub) { return stub; });
      output.erase(limit, output.end());
    }
    // remove all gaps between end and last stub
    for (auto it = output.end(); it != output.begin();)
      it = (*--it) ? output.begin() : output.erase(it);
  }

pop_front()

Stub * trackerDTC::DTC::pop_front ( Stubs &  stubs )

private

Definition at line 166 of file DTC.cc.

Referenced by merge().

                                   {
    Stub* stub = deque.front();
    deque.pop_front();
    return stub;
  }

produce() [1/2]

void trackerDTC::DTC::produce	(	TTDTC &	accepted,
		TTDTC &	lost
	)

Definition at line 67 of file DTC.cc.

References tt::Setup::dtcNumRoutingBlocks(), input_, lost_, merge(), tt::Setup::numOverlappingRegions(), nano_mu_digi_cff::region, setup_, and split().

                                                              {
    // router step 1: merges stubs of all modules connected to one routing block into one stream
    Stubs lost;
    Stubss blockStubs(setup_->dtcNumRoutingBlocks());
    for (int routingBlock = 0; routingBlock < setup_->dtcNumRoutingBlocks(); routingBlock++)
      merge(input_[routingBlock], blockStubs[routingBlock], lost);
    // copy lost stubs during merge into lost output channel
    for (int region = 0; region < setup_->numOverlappingRegions(); region++) {
      auto inRegion = [region](Stub* stub) { return stub->inRegion(region); };
      copy_if(lost.begin(), lost.end(), back_inserter(lost_[region]), inRegion);
    }
    // router step 2: merges stubs of all routing blocks and splits stubs into one stream per overlapping region
    Stubss regionStubs(setup_->numOverlappingRegions());
    split(blockStubs, regionStubs);
    // fill products
    produce(regionStubs, productAccepted);
    produce(lost_, productLost);
  }

produce() [2/2]

void trackerDTC::DTC::produce ( const Stubss &  stubss, TTDTC &  product  )

private

Definition at line 152 of file DTC.cc.

References board_, region_, TTDTC::setStream(), cms::cuda::stream, and HcalDetIdTransform::transform().

                                                        {
    int channel(0);
    auto toFrame = [&channel](Stub* stub) {
      return stub ? make_pair(stub->ttStubRef(), stub->frame(channel)) : FrameStub();
    };
    for (const Stubs& stubs : stubss) {
      StreamStub stream;
      stream.reserve(stubs.size());
      transform(stubs.begin(), stubs.end(), back_inserter(stream), toFrame);
      product.setStream(region_, board_, channel++, stream);
    }
  }

split()

void trackerDTC::DTC::split ( Stubss &  inputs, Stubss &  outputs  )

private

Definition at line 134 of file DTC.cc.

References mps_fire::i, input, PixelMapPlotter::inputs, ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, lost_, merge(), PatBasicFWLiteJetAnalyzer_Selector_cfg::outputs, nano_mu_digi_cff::region, cms::cuda::stream, HLT_2023v12_cff::streams, and HcalDetIdTransform::transform().

Referenced by produce().

                                                 {
    int region(0);
    auto regionMask = [&region](Stub* stub) { return stub && stub->inRegion(region) ? stub : nullptr; };
    for (Stubs& output : outputs) {
      // copy of masked inputs for each output
      Stubss streams(inputs.size());
      int i(0);
      for (Stubs& input : inputs) {
        Stubs& stream = streams[i++];
        transform(input.begin(), input.end(), back_inserter(stream), regionMask);
        for (auto it = stream.end(); it != stream.begin();)
          it = (*--it) ? stream.begin() : stream.erase(it);
      }
      merge(streams, output, lost_[region++]);
    }
  }

Member Data Documentation

board_

int trackerDTC::DTC::board_

private

Definition at line 51 of file DTC.h.

Referenced by produce().

enableTruncation_

bool trackerDTC::DTC::enableTruncation_

private

Definition at line 47 of file DTC.h.

Referenced by DTC(), and merge().

input_

Stubsss trackerDTC::DTC::input_

private

Definition at line 57 of file DTC.h.

Referenced by DTC(), and produce().

lost_

Stubss trackerDTC::DTC::lost_

private

Definition at line 59 of file DTC.h.

Referenced by DTC(), produce(), and split().

modules_

std::vector<tt::SensorModule*> trackerDTC::DTC::modules_

private

Definition at line 53 of file DTC.h.

Referenced by DTC().

region_

int trackerDTC::DTC::region_

private

Definition at line 49 of file DTC.h.

Referenced by produce().

setup_

const tt::Setup* trackerDTC::DTC::setup_

private

Definition at line 45 of file DTC.h.

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

stubs_

std::vector<Stub> trackerDTC::DTC::stubs_

private

Definition at line 55 of file DTC.h.

Referenced by DTC().