TrackFindingTracklet/src/ChannelAssignment.cc

0001 #include "L1Trigger/TrackFindingTracklet/interface/ChannelAssignment.h"
0002 #include "L1Trigger/TrackFindingTracklet/interface/Settings.h"
0003
0004 #include <vector>
0005 #include <array>
0006 #include <set>
0007 #include <algorithm>
0008 #include <numeric>
0009 #include <iterator>
0010
0011 using namespace std;
0012 using namespace edm;
0013 using namespace tt;
0014
0015 namespace trklet {
0016
0017   ChannelAssignment::ChannelAssignment(const edm::ParameterSet& iConfig, const Setup* setup)
0018       : setup_(setup),
0019         useDuplicateRemoval_(iConfig.getParameter<bool>("UseDuplicateRemoval")),
0020         boundaries_(iConfig.getParameter<vector<double>>("PtBoundaries")),
0021         seedTypeNames_(iConfig.getParameter<vector<string>>("SeedTypes")),
0022         numSeedTypes_(seedTypeNames_.size()),
0023         numChannelsTrack_(useDuplicateRemoval_ ? 2 * boundaries_.size() : numSeedTypes_),
0024         channelEncoding_(iConfig.getParameter<vector<int>>("IRChannelsIn")) {
0025     const ParameterSet& pSetSeedTypesSeedLayers = iConfig.getParameter<ParameterSet>("SeedTypesSeedLayers");
0026     const ParameterSet& pSetSeedTypesProjectionLayers = iConfig.getParameter<ParameterSet>("SeedTypesProjectionLayers");
0027     seedTypesSeedLayers_.reserve(numSeedTypes_);
0028     seedTypesProjectionLayers_.reserve(numSeedTypes_);
0029     for (const string& s : seedTypeNames_) {
0030       seedTypesSeedLayers_.emplace_back(pSetSeedTypesSeedLayers.getParameter<vector<int>>(s));
0031       seedTypesProjectionLayers_.emplace_back(pSetSeedTypesProjectionLayers.getParameter<vector<int>>(s));
0032     }
0033     auto acc = [](int sum, vector<int> ints) { return sum + (int)ints.size(); };
0034     numChannelsStub_ = accumulate(seedTypesProjectionLayers_.begin(), seedTypesProjectionLayers_.end(), 0, acc);
0035     offsetsStubs_.reserve(numSeedTypes_);
0036     for (int seed = 0; seed < numSeedTypes_; seed++) {
0037       const auto it = next(seedTypesProjectionLayers_.begin(), seed);
0038       offsetsStubs_.emplace_back(accumulate(seedTypesProjectionLayers_.begin(), it, 0, acc));
0039     }
0040     // consistency check
0041     const int offsetBarrel = setup_->offsetLayerId();
0042     const int numBarrelLayer = setup_->numBarrelLayer();
0043     const int offsetDisk = setup_->offsetLayerDisks() + offsetBarrel;
0044     static constexpr int invalidSeedLayer = -1;
0045     static constexpr int invalidLayerDisk = 0;
0046     const Settings settings;
0047     const auto& seedlayers = settings.seedlayers();
0048     const auto& projlayers = settings.projlayers();
0049     const auto& projdisks = settings.projdisks();
0050     // convert Seetings layer ids into ChannelAssignment layer ids
0051     vector<set<int>> allSeedingLayer(seedlayers.size());
0052     vector<set<int>> allProjectionLayer(seedlayers.size());
0053     for (int iSeed = 0; iSeed < (int)seedlayers.size(); iSeed++)
0054       for (const auto& layer : seedlayers[iSeed])
0055         if (layer != invalidSeedLayer)
0056           allSeedingLayer[iSeed].insert(layer < numBarrelLayer ? layer + offsetBarrel
0057                                                                : layer + offsetDisk - numBarrelLayer);
0058     for (int iSeed = 0; iSeed < (int)projlayers.size(); iSeed++)
0059       for (const auto& layer : projlayers[iSeed])
0060         if (layer != invalidLayerDisk)
0061           allProjectionLayer[iSeed].insert(layer);
0062     for (int iSeed = 0; iSeed < (int)projdisks.size(); iSeed++)
0063       for (const auto& disk : projdisks[iSeed])
0064         if (disk != invalidLayerDisk)
0065           allProjectionLayer[iSeed].insert(disk - offsetBarrel + offsetDisk);
0066     // check if ChannelAssignment seedTypesSeedLayers_ and seedTypesProjectionLayers_ are subsets of Settings pendants
0067     for (int iSubSeed = 0; iSubSeed < numSeedTypes_; iSubSeed++) {
0068       const vector<int>& seedLayers = seedTypesSeedLayers_[iSubSeed];
0069       bool subset(false);
0070       for (int iAllSeed = 0; iAllSeed < (int)seedlayers.size(); iAllSeed++) {
0071         // compare seed layer
0072         const set<int>& asl = allSeedingLayer[iAllSeed];
0073         set<int> sl(seedLayers.begin(), seedLayers.end());
0074         set<int> intersect;
0075         set_intersection(sl.begin(), sl.end(), asl.begin(), asl.end(), inserter(intersect, intersect.begin()));
0076         if (intersect == sl) {
0077           subset = true;
0078           // compare projection layer
0079           const vector<int>& projectionLayers = seedTypesProjectionLayers_[iSubSeed];
0080           const set<int>& apl = allProjectionLayer[iAllSeed];
0081           set<int> pl(projectionLayers.begin(), projectionLayers.end());
0082           set<int> intersect;
0083           set_intersection(pl.begin(), pl.end(), apl.begin(), apl.end(), inserter(intersect, intersect.begin()));
0084           if (intersect == pl)
0085             break;
0086           set<int> difference;
0087           set_difference(
0088               pl.begin(), pl.end(), intersect.begin(), intersect.end(), inserter(difference, difference.begin()));
0089           cms::Exception exception("LogicError.");
0090           exception << "ProjectionLayers ( ";
0091           for (int layer : difference)
0092             exception << layer << " ";
0093           exception << ") are not supported with seed type ( ";
0094           for (int layer : seedLayers)
0095             exception << layer << " ";
0096           exception << ")";
0097           exception.addContext("trklet::ChannelAssignment::ChannelAssignment");
0098           throw exception;
0099         }
0100       }
0101       if (subset)
0102         continue;
0103       cms::Exception exception("LogicError.");
0104       exception << "SeedLayers ( ";
0105       for (int layer : seedLayers)
0106         exception << layer << " ";
0107       exception << ") are not supported";
0108       exception.addContext("trklet::ChannelAssignment::ChannelAssignment");
0109       throw exception;
0110     }
0111     auto bigger = [](const vector<int>& lhs, const vector<int>& rhs) { return lhs.size() < rhs.size(); };
0112     numSeedingLayers_ = max_element(seedTypesSeedLayers_.begin(), seedTypesSeedLayers_.end(), bigger)->size();
0113     maxNumProjectionLayers_ =
0114         max_element(seedTypesProjectionLayers_.begin(), seedTypesProjectionLayers_.end(), bigger)->size();
0115   }
0116
0117   // sets channelId of given TTTrackRef, return false if track outside pt range
0118   bool ChannelAssignment::channelId(const TTTrackRef& ttTrackRef, int& channelId) {
0119     if (!useDuplicateRemoval_) {
0120       const int seedType = ttTrackRef->trackSeedType();
0121       if (seedType >= numSeedTypes_) {
0122         cms::Exception exception("logic_error");
0123         exception << "TTTracks form seed type" << seedType << " not in supported list: (";
0124         for (const auto& s : seedTypeNames_)
0125           exception << s << " ";
0126         exception << ").";
0127         exception.addContext("trklet:ChannelAssignment:channelId");
0128         throw exception;
0129       }
0130       channelId = ttTrackRef->phiSector() * numSeedTypes_ + seedType;
0131       return true;
0132     }
0133     const double pt = ttTrackRef->momentum().perp();
0134     channelId = -1;
0135     for (double boundary : boundaries_) {
0136       if (pt < boundary)
0137         break;
0138       else
0139         channelId++;
0140     }
0141     if (channelId == -1)
0142       return false;
0143     channelId = ttTrackRef->rInv() < 0. ? channelId : numChannelsTrack_ - channelId - 1;
0144     channelId += ttTrackRef->phiSector() * numChannelsTrack_;
0145     return true;
0146   }
0147
0148   // sets layerId of given TTStubRef and seedType, returns false if seeed stub
0149   bool ChannelAssignment::layerId(int seedType, const TTStubRef& ttStubRef, int& layerId) const {
0150     layerId = -1;
0151     if (seedType < 0 || seedType >= numSeedTypes_) {
0152       cms::Exception exception("logic_error");
0153       exception.addContext("trklet::ChannelAssignment::layerId");
0154       exception << "TTTracks with with seed type " << seedType << " not supported.";
0155       throw exception;
0156     }
0157     const int layer = setup_->layerId(ttStubRef);
0158     const vector<int>& seedingLayers = seedTypesSeedLayers_[seedType];
0159     if (find(seedingLayers.begin(), seedingLayers.end(), layer) != seedingLayers.end())
0160       return false;
0161     const vector<int>& projectingLayers = seedTypesProjectionLayers_[seedType];
0162     const auto pos = find(projectingLayers.begin(), projectingLayers.end(), layer);
0163     if (pos == projectingLayers.end()) {
0164       const string& name = seedTypeNames_[seedType];
0165       cms::Exception exception("logic_error");
0166       exception.addContext("trklet::ChannelAssignment::layerId");
0167       exception << "TTStub from layer " << layer << " (barrel: 1-6; discs: 11-15) from seed type " << name
0168                 << " not supported.";
0169       throw exception;
0170     }
0171     layerId = distance(projectingLayers.begin(), pos);
0172     return true;
0173   }
0174
0175   // index of first stub channel belonging to given track channel
0176   int ChannelAssignment::offsetStub(int channelTrack) const {
0177     return channelTrack / numChannelsTrack_ * numChannelsStub_ + offsetsStubs_[channelTrack % numChannelsTrack_];
0178   }
0179
0180   //
0181   int ChannelAssignment::channelId(int seedType, int layerId) const {
0182     const vector<int>& projections = seedTypesProjectionLayers_.at(seedType);
0183     const vector<int>& seeds = seedTypesSeedLayers_.at(seedType);
0184     const auto itp = find(projections.begin(), projections.end(), layerId);
0185     const auto its = find(seeds.begin(), seeds.end(), layerId);
0186     if (its != seeds.end())
0187       return (int)projections.size() + distance(seeds.begin(), its);
0188     if (itp != projections.end())
0189       return distance(projections.begin(), itp);
0190     return -1;
0191   }
0192
0193 }  // namespace trklet