trackerTFP::GeometricProcessor Class Reference

#include <GeometricProcessor.h>

Public Member Functions
void	consume (const TTDTC &ttDTC)
	GeometricProcessor (const edm::ParameterSet &iConfig, const tt::Setup *setup_, const DataFormats *dataFormats, int region)
void	produce (tt::StreamsStub &accepted, tt::StreamsStub &lost)
	~GeometricProcessor ()

Private Member Functions
template<class T >
T *	pop_front (std::deque< T *> &ts) const

Private Attributes
const DataFormats *	dataFormats_
bool	enableTruncation_
std::vector< std::vector< std::deque< StubPP * > > >	input_
const int	region_
const tt::Setup *	setup_
std::vector< StubGP >	stubsGP_
std::vector< StubPP >	stubsPP_

Detailed Description

Definition at line 14 of file GeometricProcessor.h.

Constructor & Destructor Documentation

GeometricProcessor()

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

Definition at line 15 of file GeometricProcessor.cc.

      : enableTruncation_(iConfig.getParameter<bool>("EnableTruncation")),
        setup_(setup),
        dataFormats_(dataFormats),
        region_(region),
        input_(dataFormats_->numChannel(Process::gp), vector<deque<StubPP*>>(dataFormats_->numChannel(Process::pp))) {}

~GeometricProcessor()

trackerTFP::GeometricProcessor::~GeometricProcessor ( )

inline

Definition at line 20 of file GeometricProcessor.h.

{}

Member Function Documentation

consume()

void trackerTFP::GeometricProcessor::consume

(

const TTDTC &

ttDTC

)

Definition at line 26 of file GeometricProcessor.cc.

References dataFormats_, amptDefault_cfi::frame, trackerTFP::gp, input, input_, trackerTFP::StubPP::inSector(), ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, trackerTFP::DataFormats::numChannel(), trackerTFP::pp, push_back(), region_, nano_mu_digi_cff::sector, TTDTC::stream(), cms::cuda::stream, SimL1Emulator_cff::stubs, stubsGP_, stubsPP_, and trackerHitRTTI::vector.

                                                     {
    auto validFrame = [](int sum, const FrameStub& frame) { return sum + (frame.first.isNonnull() ? 1 : 0); };
    int nStubsPP(0);
    for (int channel = 0; channel < dataFormats_->numChannel(Process::pp); channel++) {
      const StreamStub& stream = ttDTC.stream(region_, channel);
      nStubsPP += accumulate(stream.begin(), stream.end(), 0, validFrame);
    }
    stubsPP_.reserve(nStubsPP);
    for (int channel = 0; channel < dataFormats_->numChannel(Process::pp); channel++) {
      for (const FrameStub& frame : ttDTC.stream(region_, channel)) {
        StubPP* stub = nullptr;
        if (frame.first.isNonnull()) {
          stubsPP_.emplace_back(frame, dataFormats_);
          stub = &stubsPP_.back();
        }
        for (int sector = 0; sector < dataFormats_->numChannel(Process::gp); sector++)
          // adding gaps (nullptr) if no stub available or not in sector to emulate f/w
          input_[sector][channel].push_back(stub && stub->inSector(sector) ? stub : nullptr);
      }
    }
    // remove all gaps between end and last stub
    for (vector<deque<StubPP*>>& input : input_)
      for (deque<StubPP*>& stubs : input)
        for (auto it = stubs.end(); it != stubs.begin();)
          it = (*--it) ? stubs.begin() : stubs.erase(it);
    auto validStub = [](int sum, StubPP* stub) { return sum + (stub ? 1 : 0); };
    int nStubsGP(0);
    for (const vector<deque<StubPP*>>& sector : input_)
      for (const deque<StubPP*>& channel : sector)
        nStubsGP += accumulate(channel.begin(), channel.end(), 0, validStub);
    stubsGP_.reserve(nStubsGP);
  }

pop_front()

template<class T >

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

private

Definition at line 122 of file GeometricProcessor.cc.

References submitPVValidationJobs::t.

Referenced by produce().

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

produce()

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

Definition at line 60 of file GeometricProcessor.cc.

References dataFormats_, enableTruncation_, trackerTFP::gp, tt::Setup::gpDepthMemory(), input_, PixelMapPlotter::inputs, ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, remoteMonitoring_LASER_era2018_cfg::limit, GetRecoTauVFromDQM_MC_cff::next, trackerTFP::DataFormats::numChannel(), tt::Setup::numFrames(), tt::Setup::numSectorsPhi(), or, pop_front(), trackerTFP::pp, put(), region_, nano_mu_digi_cff::sector, trackerTFP::sectorEta, trackerTFP::sectorPhi, setup_, svgfig::stack, cms::cuda::stream, SimL1Emulator_cff::stubs, stubsGP_, and HcalDetIdTransform::transform().

                                                                           {
    for (int sector = 0; sector < dataFormats_->numChannel(Process::gp); sector++) {
      vector<deque<StubPP*>>& inputs = input_[sector];
      vector<deque<StubGP*>> stacks(dataFormats_->numChannel(Process::pp));
      const int sectorPhi = sector % setup_->numSectorsPhi();
      const int sectorEta = sector / setup_->numSectorsPhi();
      auto size = [](int sum, const deque<StubPP*>& stubs) { return sum + stubs.size(); };
      const int nStubs = accumulate(inputs.begin(), inputs.end(), 0, size);
      vector<StubGP*> acceptedSector;
      vector<StubGP*> lostSector;
      acceptedSector.reserve(nStubs);
      lostSector.reserve(nStubs);
      // 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<StubPP*>& stubs) { return stubs.empty(); }) or
             !all_of(stacks.begin(), stacks.end(), [](const deque<StubGP*>& stubs) { return stubs.empty(); })) {
        // fill input fifos
        for (int channel = 0; channel < dataFormats_->numChannel(Process::pp); channel++) {
          deque<StubGP*>& stack = stacks[channel];
          StubPP* stub = pop_front(inputs[channel]);
          if (stub) {
            stubsGP_.emplace_back(*stub, sectorPhi, sectorEta);
            if (enableTruncation_ && (int)stack.size() == setup_->gpDepthMemory() - 1)
              lostSector.push_back(pop_front(stack));
            stack.push_back(&stubsGP_.back());
          }
        }
        // merge input fifos to one stream, prioritizing higher input channel over lower channel
        bool nothingToRoute(true);
        for (int channel = dataFormats_->numChannel(Process::pp) - 1; channel >= 0; channel--) {
          StubGP* stub = pop_front(stacks[channel]);
          if (stub) {
            nothingToRoute = false;
            acceptedSector.push_back(stub);
            break;
          }
        }
        if (nothingToRoute)
          acceptedSector.push_back(nullptr);
      }
      // truncate if desired
      if (enableTruncation_ && (int)acceptedSector.size() > setup_->numFrames()) {
        const auto limit = next(acceptedSector.begin(), setup_->numFrames());
        copy_if(limit, acceptedSector.end(), back_inserter(lostSector), [](const StubGP* stub) { return stub; });
        acceptedSector.erase(limit, acceptedSector.end());
      }
      // remove all gaps between end and last stub
      for (auto it = acceptedSector.end(); it != acceptedSector.begin();)
        it = (*--it) ? acceptedSector.begin() : acceptedSector.erase(it);
      // fill products
      auto put = [](const vector<StubGP*>& stubs, StreamStub& stream) {
        auto toFrame = [](StubGP* stub) { return stub ? stub->frame() : FrameStub(); };
        stream.reserve(stubs.size());
        transform(stubs.begin(), stubs.end(), back_inserter(stream), toFrame);
      };
      const int index = region_ * dataFormats_->numChannel(Process::gp) + sector;
      put(acceptedSector, accepted[index]);
      put(lostSector, lost[index]);
    }
  }

Member Data Documentation

dataFormats_

const DataFormats* trackerTFP::GeometricProcessor::dataFormats_

private

Definition at line 37 of file GeometricProcessor.h.

Referenced by consume(), and produce().

enableTruncation_

bool trackerTFP::GeometricProcessor::enableTruncation_

private

Definition at line 33 of file GeometricProcessor.h.

Referenced by produce().

input_

std::vector<std::vector<std::deque<StubPP*> > > trackerTFP::GeometricProcessor::input_

private

Definition at line 45 of file GeometricProcessor.h.

Referenced by consume(), and produce().

region_

const int trackerTFP::GeometricProcessor::region_

private

Definition at line 39 of file GeometricProcessor.h.

Referenced by consume(), and produce().

setup_

const tt::Setup* trackerTFP::GeometricProcessor::setup_

private

Definition at line 35 of file GeometricProcessor.h.

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

stubsGP_

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

private

Definition at line 43 of file GeometricProcessor.h.

Referenced by consume(), and produce().

stubsPP_

std::vector<StubPP> trackerTFP::GeometricProcessor::stubsPP_

private

Definition at line 41 of file GeometricProcessor.h.

Referenced by consume().