trklet::ChannelAssignment Class Reference

Class to assign tracklet tracks and stubs to output channel based on their Pt or seed type as well as DTC stubs to input channel. More...

#include <ChannelAssignment.h>

Public Member Functions
	ChannelAssignment ()
	ChannelAssignment (const edm::ParameterSet &iConfig, const tt::Setup *setup)
const std::vector< int > &	channelEncoding () const
bool	channelId (const TTTrackRef &ttTrackRef, int &channelId)
int	channelId (int seedType, int layerId) const
bool	layerId (int seedType, const TTStubRef &ttStubRef, int &layerId) const
int	layerId (int seedType, int channel) const
int	maxNumProjectionLayers () const
int	numChannelsStub () const
int	numChannelsTrack () const
int	numProjectionLayers (int seedType) const
int	numSeedingLayers () const
int	numSeedTypes () const
int	offsetStub (int channelTrack) const
const std::vector< int > &	seedingLayers (int seedType) const
tt::SensorModule::Type	type (const TTStubRef &ttStubRef) const
	~ChannelAssignment ()

Private Attributes
std::vector< double >	boundaries_
std::vector< int >	channelEncoding_
int	maxNumProjectionLayers_
int	numChannelsStub_
int	numChannelsTrack_
int	numSeedingLayers_
int	numSeedTypes_
std::vector< int >	offsetsStubs_
std::vector< std::string >	seedTypeNames_
std::vector< std::vector< int > >	seedTypesProjectionLayers_
std::vector< std::vector< int > >	seedTypesSeedLayers_
const tt::Setup *	setup_
bool	useDuplicateRemoval_

Detailed Description

Class to assign tracklet tracks and stubs to output channel based on their Pt or seed type as well as DTC stubs to input channel.

Author

Thomas Schuh

Date

2020, Nov; updated 2021 Oct

Definition at line 20 of file ChannelAssignment.h.

Constructor & Destructor Documentation

ChannelAssignment() [1/2]

trklet::ChannelAssignment::ChannelAssignment ( )

inline

Definition at line 22 of file ChannelAssignment.h.

{}

ChannelAssignment() [2/2]

trklet::ChannelAssignment::ChannelAssignment	(	const edm::ParameterSet &	iConfig,
		const tt::Setup *	setup
	)

Definition at line 17 of file ChannelAssignment.cc.

References cppFunctionSkipper::exception, edm::ParameterSet::getParameter(), createfilelist::int, maxNumProjectionLayers_, GetRecoTauVFromDQM_MC_cff::next, tt::Setup::numBarrelLayer(), numChannelsStub_, numSeedingLayers_, numSeedTypes_, tt::Setup::offsetLayerDisks(), tt::Setup::offsetLayerId(), offsetsStubs_, trklet::Settings::projdisks(), trklet::Settings::projlayers(), alignCSCRings::s, fileCollector::seed, trklet::Settings::seedlayers(), seedTypeNames_, seedTypesProjectionLayers_, seedTypesSeedLayers_, DBoxMetadataHelper::set_difference(), DBoxMetadataHelper::set_intersection(), setup_, and findQualityFiles::size.

      : setup_(setup),
        useDuplicateRemoval_(iConfig.getParameter<bool>("UseDuplicateRemoval")),
        boundaries_(iConfig.getParameter<vector<double>>("PtBoundaries")),
        seedTypeNames_(iConfig.getParameter<vector<string>>("SeedTypes")),
        numSeedTypes_(seedTypeNames_.size()),
        numChannelsTrack_(useDuplicateRemoval_ ? 2 * boundaries_.size() : numSeedTypes_),
        channelEncoding_(iConfig.getParameter<vector<int>>("IRChannelsIn")) {
    const ParameterSet& pSetSeedTypesSeedLayers = iConfig.getParameter<ParameterSet>("SeedTypesSeedLayers");
    const ParameterSet& pSetSeedTypesProjectionLayers = iConfig.getParameter<ParameterSet>("SeedTypesProjectionLayers");
    seedTypesSeedLayers_.reserve(numSeedTypes_);
    seedTypesProjectionLayers_.reserve(numSeedTypes_);
    for (const string& s : seedTypeNames_) {
      seedTypesSeedLayers_.emplace_back(pSetSeedTypesSeedLayers.getParameter<vector<int>>(s));
      seedTypesProjectionLayers_.emplace_back(pSetSeedTypesProjectionLayers.getParameter<vector<int>>(s));
    }
    auto acc = [](int sum, vector<int> ints) { return sum + (int)ints.size(); };
    numChannelsStub_ = accumulate(seedTypesProjectionLayers_.begin(), seedTypesProjectionLayers_.end(), 0, acc);
    offsetsStubs_.reserve(numSeedTypes_);
    for (int seed = 0; seed < numSeedTypes_; seed++) {
      const auto it = next(seedTypesProjectionLayers_.begin(), seed);
      offsetsStubs_.emplace_back(accumulate(seedTypesProjectionLayers_.begin(), it, 0, acc));
    }
    // consistency check
    const int offsetBarrel = setup_->offsetLayerId();
    const int numBarrelLayer = setup_->numBarrelLayer();
    const int offsetDisk = setup_->offsetLayerDisks() + offsetBarrel;
    static constexpr int invalidSeedLayer = -1;
    static constexpr int invalidLayerDisk = 0;
    const Settings settings;
    const auto& seedlayers = settings.seedlayers();
    const auto& projlayers = settings.projlayers();
    const auto& projdisks = settings.projdisks();
    // convert Seetings layer ids into ChannelAssignment layer ids
    vector<set<int>> allSeedingLayer(seedlayers.size());
    vector<set<int>> allProjectionLayer(seedlayers.size());
    for (int iSeed = 0; iSeed < (int)seedlayers.size(); iSeed++)
      for (const auto& layer : seedlayers[iSeed])
        if (layer != invalidSeedLayer)
          allSeedingLayer[iSeed].insert(layer < numBarrelLayer ? layer + offsetBarrel
                                                               : layer + offsetDisk - numBarrelLayer);
    for (int iSeed = 0; iSeed < (int)projlayers.size(); iSeed++)
      for (const auto& layer : projlayers[iSeed])
        if (layer != invalidLayerDisk)
          allProjectionLayer[iSeed].insert(layer);
    for (int iSeed = 0; iSeed < (int)projdisks.size(); iSeed++)
      for (const auto& disk : projdisks[iSeed])
        if (disk != invalidLayerDisk)
          allProjectionLayer[iSeed].insert(disk - offsetBarrel + offsetDisk);
    // check if ChannelAssignment seedTypesSeedLayers_ and seedTypesProjectionLayers_ are subsets of Settings pendants
    for (int iSubSeed = 0; iSubSeed < numSeedTypes_; iSubSeed++) {
      const vector<int>& seedLayers = seedTypesSeedLayers_[iSubSeed];
      bool subset(false);
      for (int iAllSeed = 0; iAllSeed < (int)seedlayers.size(); iAllSeed++) {
        // compare seed layer
        const set<int>& asl = allSeedingLayer[iAllSeed];
        set<int> sl(seedLayers.begin(), seedLayers.end());
        set<int> intersect;
        set_intersection(sl.begin(), sl.end(), asl.begin(), asl.end(), inserter(intersect, intersect.begin()));
        if (intersect == sl) {
          subset = true;
          // compare projection layer
          const vector<int>& projectionLayers = seedTypesProjectionLayers_[iSubSeed];
          const set<int>& apl = allProjectionLayer[iAllSeed];
          set<int> pl(projectionLayers.begin(), projectionLayers.end());
          set<int> intersect;
          set_intersection(pl.begin(), pl.end(), apl.begin(), apl.end(), inserter(intersect, intersect.begin()));
          if (intersect == pl)
            break;
          set<int> difference;
          set_difference(
              pl.begin(), pl.end(), intersect.begin(), intersect.end(), inserter(difference, difference.begin()));
          cms::Exception exception("LogicError.");
          exception << "ProjectionLayers ( ";
          for (int layer : difference)
            exception << layer << " ";
          exception << ") are not supported with seed type ( ";
          for (int layer : seedLayers)
            exception << layer << " ";
          exception << ")";
          exception.addContext("trklet::ChannelAssignment::ChannelAssignment");
          throw exception;
        }
      }
      if (subset)
        continue;
      cms::Exception exception("LogicError.");
      exception << "SeedLayers ( ";
      for (int layer : seedLayers)
        exception << layer << " ";
      exception << ") are not supported";
      exception.addContext("trklet::ChannelAssignment::ChannelAssignment");
      throw exception;
    }
    auto bigger = [](const vector<int>& lhs, const vector<int>& rhs) { return lhs.size() < rhs.size(); };
    numSeedingLayers_ = max_element(seedTypesSeedLayers_.begin(), seedTypesSeedLayers_.end(), bigger)->size();
    maxNumProjectionLayers_ =
        max_element(seedTypesProjectionLayers_.begin(), seedTypesProjectionLayers_.end(), bigger)->size();
  }

~ChannelAssignment()

trklet::ChannelAssignment::~ChannelAssignment ( )

inline

Definition at line 24 of file ChannelAssignment.h.

{}

Member Function Documentation

channelEncoding()

const std::vector<int>& trklet::ChannelAssignment::channelEncoding ( ) const

inline

Definition at line 40 of file ChannelAssignment.h.

References channelEncoding_.

{ return channelEncoding_; }

channelId() [1/2]

bool trklet::ChannelAssignment::channelId	(	const TTTrackRef &	ttTrackRef,
		int &	channelId
	)

Definition at line 118 of file ChannelAssignment.cc.

References boundaries_, cppFunctionSkipper::exception, numChannelsTrack_, numSeedTypes_, DiDispStaMuonMonitor_cfi::pt, alignCSCRings::s, seedTypeNames_, and useDuplicateRemoval_.

Referenced by trklet::ProducerTBout::produce().

                                                                                {
    if (!useDuplicateRemoval_) {
      const int seedType = ttTrackRef->trackSeedType();
      if (seedType >= numSeedTypes_) {
        cms::Exception exception("logic_error");
        exception << "TTTracks form seed type" << seedType << " not in supported list: (";
        for (const auto& s : seedTypeNames_)
          exception << s << " ";
        exception << ").";
        exception.addContext("trklet:ChannelAssignment:channelId");
        throw exception;
      }
      channelId = ttTrackRef->phiSector() * numSeedTypes_ + seedType;
      return true;
    }
    const double pt = ttTrackRef->momentum().perp();
    channelId = -1;
    for (double boundary : boundaries_) {
      if (pt < boundary)
        break;
      else
        channelId++;
    }
    if (channelId == -1)
      return false;
    channelId = ttTrackRef->rInv() < 0. ? channelId : numChannelsTrack_ - channelId - 1;
    channelId += ttTrackRef->phiSector() * numChannelsTrack_;
    return true;
  }

channelId() [2/2]

int trklet::ChannelAssignment::channelId	(	int	seedType,
		int	layerId
	)		const

Definition at line 181 of file ChannelAssignment.cc.

References HLT_2023v12_cff::distance, spr::find(), layerId(), DetachedQuadStep_cff::seeds, seedTypesProjectionLayers_, and seedTypesSeedLayers_.

                                                                  {
    const vector<int>& projections = seedTypesProjectionLayers_.at(seedType);
    const vector<int>& seeds = seedTypesSeedLayers_.at(seedType);
    const auto itp = find(projections.begin(), projections.end(), layerId);
    const auto its = find(seeds.begin(), seeds.end(), layerId);
    if (its != seeds.end())
      return (int)projections.size() + distance(seeds.begin(), its);
    if (itp != projections.end())
      return distance(projections.begin(), itp);
    return -1;
  }

layerId() [1/2]

bool trklet::ChannelAssignment::layerId	(	int	seedType,
		const TTStubRef &	ttStubRef,
		int &	layerId
	)		const

Definition at line 149 of file ChannelAssignment.cc.

References HLT_2023v12_cff::distance, cppFunctionSkipper::exception, spr::find(), tt::Setup::layerId(), Skims_PA_cff::name, numSeedTypes_, seedingLayers(), seedTypeNames_, seedTypesProjectionLayers_, seedTypesSeedLayers_, and setup_.

Referenced by channelId(), trklet::KFin::consume(), and L1FPGATrackProducer::produce().

                                                                                              {
    layerId = -1;
    if (seedType < 0 || seedType >= numSeedTypes_) {
      cms::Exception exception("logic_error");
      exception.addContext("trklet::ChannelAssignment::layerId");
      exception << "TTTracks with with seed type " << seedType << " not supported.";
      throw exception;
    }
    const int layer = setup_->layerId(ttStubRef);
    const vector<int>& seedingLayers = seedTypesSeedLayers_[seedType];
    if (find(seedingLayers.begin(), seedingLayers.end(), layer) != seedingLayers.end())
      return false;
    const vector<int>& projectingLayers = seedTypesProjectionLayers_[seedType];
    const auto pos = find(projectingLayers.begin(), projectingLayers.end(), layer);
    if (pos == projectingLayers.end()) {
      const string& name = seedTypeNames_[seedType];
      cms::Exception exception("logic_error");
      exception.addContext("trklet::ChannelAssignment::layerId");
      exception << "TTStub from layer " << layer << " (barrel: 1-6; discs: 11-15) from seed type " << name
                << " not supported.";
      throw exception;
    }
    layerId = distance(projectingLayers.begin(), pos);
    return true;
  }

layerId() [2/2]

int trklet::ChannelAssignment::layerId ( int  seedType, int  channel  ) const

inline

Definition at line 48 of file ChannelAssignment.h.

References seedTypesProjectionLayers_.

{ return seedTypesProjectionLayers_.at(seedType).at(channel); }

maxNumProjectionLayers()

int trklet::ChannelAssignment::maxNumProjectionLayers ( ) const

inline

Definition at line 38 of file ChannelAssignment.h.

References maxNumProjectionLayers_.

Referenced by L1FPGATrackProducer::produce().

{ return maxNumProjectionLayers_; }

numChannelsStub()

int trklet::ChannelAssignment::numChannelsStub ( ) const

inline

Definition at line 30 of file ChannelAssignment.h.

References numChannelsStub_.

Referenced by trklet::ProducerTBout::produce(), and L1FPGATrackProducer::produce().

{ return numChannelsStub_; }

numChannelsTrack()

int trklet::ChannelAssignment::numChannelsTrack ( ) const

inline

Definition at line 28 of file ChannelAssignment.h.

References numChannelsTrack_.

Referenced by trklet::KFin::consume(), trklet::KFin::produce(), trklet::ProducerTBout::produce(), and L1FPGATrackProducer::produce().

{ return numChannelsTrack_; }

numProjectionLayers()

int trklet::ChannelAssignment::numProjectionLayers ( int  seedType ) const

inline

Definition at line 36 of file ChannelAssignment.h.

References seedTypesProjectionLayers_.

Referenced by trklet::KFin::consume(), and L1FPGATrackProducer::produce().

{ return (int)seedTypesProjectionLayers_.at(seedType).size(); }

numSeedingLayers()

int trklet::ChannelAssignment::numSeedingLayers ( ) const

inline

Definition at line 52 of file ChannelAssignment.h.

References numSeedingLayers_.

Referenced by trklet::KFin::consume().

{ return numSeedingLayers_; }

numSeedTypes()

int trklet::ChannelAssignment::numSeedTypes ( ) const

inline

Definition at line 32 of file ChannelAssignment.h.

References numSeedTypes_.

{ return numSeedTypes_; }

offsetStub()

int trklet::ChannelAssignment::offsetStub

(

int

channelTrack

)

const

Definition at line 176 of file ChannelAssignment.cc.

References numChannelsStub_, numChannelsTrack_, and offsetsStubs_.

Referenced by trklet::KFin::consume(), and L1FPGATrackProducer::produce().

                                                          {
    return channelTrack / numChannelsTrack_ * numChannelsStub_ + offsetsStubs_[channelTrack % numChannelsTrack_];
  }

seedingLayers()

const std::vector<int>& trklet::ChannelAssignment::seedingLayers ( int  seedType ) const

inline

Definition at line 44 of file ChannelAssignment.h.

References seedTypesSeedLayers_.

Referenced by trklet::KFin::consume(), and layerId().

{ return seedTypesSeedLayers_.at(seedType); }

type()

tt::SensorModule::Type trklet::ChannelAssignment::type ( const TTStubRef &  ttStubRef ) const

inline

Definition at line 46 of file ChannelAssignment.h.

References setup_, and tt::Setup::type().

{ return setup_->type(ttStubRef); }

Member Data Documentation

boundaries_

std::vector<double> trklet::ChannelAssignment::boundaries_

private

Definition at line 60 of file ChannelAssignment.h.

Referenced by channelId().

channelEncoding_

std::vector<int> trklet::ChannelAssignment::channelEncoding_

private

Definition at line 76 of file ChannelAssignment.h.

Referenced by channelEncoding().

maxNumProjectionLayers_

int trklet::ChannelAssignment::maxNumProjectionLayers_

private

Definition at line 74 of file ChannelAssignment.h.

Referenced by ChannelAssignment(), and maxNumProjectionLayers().

numChannelsStub_

int trklet::ChannelAssignment::numChannelsStub_

private

Definition at line 68 of file ChannelAssignment.h.

Referenced by ChannelAssignment(), numChannelsStub(), and offsetStub().

numChannelsTrack_

int trklet::ChannelAssignment::numChannelsTrack_

private

Definition at line 66 of file ChannelAssignment.h.

Referenced by channelId(), numChannelsTrack(), and offsetStub().

numSeedingLayers_

int trklet::ChannelAssignment::numSeedingLayers_

private

Definition at line 80 of file ChannelAssignment.h.

Referenced by ChannelAssignment(), and numSeedingLayers().

numSeedTypes_

int trklet::ChannelAssignment::numSeedTypes_

private

Definition at line 64 of file ChannelAssignment.h.

Referenced by ChannelAssignment(), channelId(), layerId(), and numSeedTypes().

offsetsStubs_

std::vector<int> trklet::ChannelAssignment::offsetsStubs_

private

Definition at line 78 of file ChannelAssignment.h.

Referenced by ChannelAssignment(), and offsetStub().

seedTypeNames_

std::vector<std::string> trklet::ChannelAssignment::seedTypeNames_

private

Definition at line 62 of file ChannelAssignment.h.

Referenced by ChannelAssignment(), channelId(), and layerId().

seedTypesProjectionLayers_

std::vector<std::vector<int> > trklet::ChannelAssignment::seedTypesProjectionLayers_

private

Definition at line 72 of file ChannelAssignment.h.

Referenced by ChannelAssignment(), channelId(), layerId(), and numProjectionLayers().

seedTypesSeedLayers_

std::vector<std::vector<int> > trklet::ChannelAssignment::seedTypesSeedLayers_

private

Definition at line 70 of file ChannelAssignment.h.

Referenced by ChannelAssignment(), channelId(), layerId(), and seedingLayers().

setup_

const tt::Setup* trklet::ChannelAssignment::setup_

private

Definition at line 56 of file ChannelAssignment.h.

Referenced by ChannelAssignment(), layerId(), upgradeWorkflowComponents.UpgradeWorkflow::setup(), and type().

useDuplicateRemoval_

bool trklet::ChannelAssignment::useDuplicateRemoval_

private

Definition at line 58 of file ChannelAssignment.h.

Referenced by channelId().