TTStubBuilder.h

Go to the documentation of this file.

#ifndef L1_TRACK_TRIGGER_STUB_BUILDER_H
#define L1_TRACK_TRIGGER_STUB_BUILDER_H

#include "FWCore/Framework/interface/Frameworkfwd.h"
#include "FWCore/Framework/interface/EDProducer.h"
#include "FWCore/Framework/interface/Event.h"
#include "FWCore/Framework/interface/EventSetup.h"
#include "FWCore/Framework/interface/ESHandle.h"
#include "FWCore/Framework/interface/MakerMacros.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"

#include "Geometry/CommonDetUnit/interface/PixelGeomDetUnit.h"
#include "Geometry/CommonTopologies/interface/PixelTopology.h"

#include "L1Trigger/TrackTrigger/interface/TTStubAlgorithm.h"
#include "L1Trigger/TrackTrigger/interface/TTStubAlgorithmRecord.h"

#include "DataFormats/Common/interface/DetSetVectorNew.h"

#include <memory>
#include <map>
#include <vector>

#include "DataFormats/TrackerCommon/interface/TrackerTopology.h"
#include "Geometry/TrackerGeometryBuilder/interface/TrackerGeometry.h"

template <typename T>
class TTStubBuilder : public edm::EDProducer {
public:
  explicit TTStubBuilder(const edm::ParameterSet& iConfig);

  ~TTStubBuilder() override;

private:
  edm::ESHandle<TTStubAlgorithm<T> > theStubFindingAlgoHandle;
  edm::EDGetTokenT<edmNew::DetSetVector<TTCluster<T> > > clustersToken;
  bool ForbidMultipleStubs;

  void beginRun(const edm::Run& run, const edm::EventSetup& iSetup) override;
  void endRun(const edm::Run& run, const edm::EventSetup& iSetup) override;
  void produce(edm::Event& iEvent, const edm::EventSetup& iSetup) override;

  static bool SortStubBendPairs(const std::pair<unsigned int, double>& left,
                                const std::pair<unsigned int, double>& right);
  static bool SortStubsBend(const TTStub<T>& left, const TTStub<T>& right);

  // FE stub extraction limits (only for experts, not used by default)

  bool applyFE;  // Turn ON (true) or OFF (false) the dynamic FE inefficiency accounting
                 // OFF is by default, ON is for experts only

  unsigned int maxStubs_2S;         // CBC chip limit (in stubs/chip/BX)
  unsigned int maxStubs_PS;         // MPA chip limit (in stubs/chip/2BX)
  unsigned int maxStubs_2S_CIC_5;   // 2S 5G chip limit (in stubs/CIC/8BX)
  unsigned int maxStubs_PS_CIC_5;   // PS 5G chip limit (in stubs/CIC/8BX)
  unsigned int maxStubs_PS_CIC_10;  // PS 10G chip limit (in stubs/CIC/8BX)

  unsigned int tedd1_maxring;  // PS 10G outermost ring in TEDD1 (default is 3)
  unsigned int tedd2_maxring;  // PS 10G outermost ring in TEDD2 (default is 0)

  int ievt;


  std::unordered_map<int, std::vector<TTStub<Ref_Phase2TrackerDigi_> > > moduleStubs_CIC;
  std::unordered_map<int, int> moduleStubs_MPA;
  std::unordered_map<int, int> moduleStubs_CBC;

  // Which disk rings are in 10G transmission scheme module
  //
  // sviret comment (221217): this info should be made available in conddb at some point
  // not in TrackerTopology as some modules may switch between 10G and 5G transmission
  // schemes during running period

  unsigned int high_rate_max_ring[5];

};  

template <typename T>
TTStubBuilder<T>::TTStubBuilder(const edm::ParameterSet& iConfig) {
  clustersToken = consumes<edmNew::DetSetVector<TTCluster<T> > >(iConfig.getParameter<edm::InputTag>("TTClusters"));
  ForbidMultipleStubs = iConfig.getParameter<bool>("OnlyOnePerInputCluster");
  applyFE = iConfig.getParameter<bool>("FEineffs");
  maxStubs_2S = iConfig.getParameter<uint32_t>("CBClimit");
  maxStubs_PS = iConfig.getParameter<uint32_t>("MPAlimit");
  maxStubs_2S_CIC_5 = iConfig.getParameter<uint32_t>("SS5GCIClimit");
  maxStubs_PS_CIC_5 = iConfig.getParameter<uint32_t>("PS5GCIClimit");
  maxStubs_PS_CIC_10 = iConfig.getParameter<uint32_t>("PS10GCIClimit");
  tedd1_maxring = iConfig.getParameter<uint32_t>("TEDD1Max10GRing");
  tedd2_maxring = iConfig.getParameter<uint32_t>("TEDD2Max10GRing");
  produces<edmNew::DetSetVector<TTCluster<T> > >("ClusterAccepted");
  produces<edmNew::DetSetVector<TTStub<T> > >("StubAccepted");
  produces<edmNew::DetSetVector<TTStub<T> > >("StubRejected");

  high_rate_max_ring[0] = tedd1_maxring;
  high_rate_max_ring[1] = tedd1_maxring;
  high_rate_max_ring[2] = tedd2_maxring;
  high_rate_max_ring[3] = tedd2_maxring;
  high_rate_max_ring[4] = tedd2_maxring;
}

template <typename T>
TTStubBuilder<T>::~TTStubBuilder() {}

template <typename T>
void TTStubBuilder<T>::beginRun(const edm::Run& run, const edm::EventSetup& iSetup) {
  iSetup.get<TTStubAlgorithmRecord>().get(theStubFindingAlgoHandle);
  ievt = 0;
  moduleStubs_CIC.clear();
  moduleStubs_MPA.clear();
  moduleStubs_CBC.clear();
}

template <typename T>
void TTStubBuilder<T>::endRun(const edm::Run& run, const edm::EventSetup& iSetup) {}

template <typename T>
bool TTStubBuilder<T>::SortStubBendPairs(const std::pair<unsigned int, double>& left,
                                         const std::pair<unsigned int, double>& right) {
  return std::abs(left.second) < std::abs(right.second);
}

template <typename T>
bool TTStubBuilder<T>::SortStubsBend(const TTStub<T>& left, const TTStub<T>& right) {
  return std::abs(left.bendFE()) < std::abs(right.bendFE());
}

template <>
void TTStubBuilder<Ref_Phase2TrackerDigi_>::produce(edm::Event& iEvent, const edm::EventSetup& iSetup);

#endif