L1TCorrelatorLayer1Producer Class Reference

Inheritance diagram for L1TCorrelatorLayer1Producer:

Public Member Functions
	L1TCorrelatorLayer1Producer (const edm::ParameterSet &)
	~L1TCorrelatorLayer1Producer () override
Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default
	EDProducer (const EDProducer &)=delete
bool	hasAbilityToProduceInBeginLumis () const final
bool	hasAbilityToProduceInBeginProcessBlocks () const final
bool	hasAbilityToProduceInBeginRuns () const final
bool	hasAbilityToProduceInEndLumis () const final
bool	hasAbilityToProduceInEndProcessBlocks () const final
bool	hasAbilityToProduceInEndRuns () const final
const EDProducer &	operator= (const EDProducer &)=delete

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

Private Types
enum	InputType { caloType = 0, emcaloType = 1, trackType = 2, l1muType = 3 }
typedef l1ct::OutputRegion::ObjType	OutputType

Private Member Functions
void	addDecodedEmCalo (l1ct::DetectorSector< l1ct::EmCaloObjEmu > &sec, const l1t::PFCluster &t)
void	addDecodedHadCalo (l1ct::DetectorSector< l1ct::HadCaloObjEmu > &sec, const l1t::PFCluster &t)
void	addDecodedMuon (l1ct::DetectorSector< l1ct::MuObjEmu > &sec, const l1t::SAMuon &t)
void	addDecodedTrack (l1ct::DetectorSector< l1ct::TkObjEmu > &sec, const l1t::PFTrack &t)
void	addEmCalo (const l1t::PFCluster &t, l1t::PFClusterRef ref)
void	addHadCalo (const l1t::PFCluster &t, l1t::PFClusterRef ref)
void	addMuon (const l1t::SAMuon &t, l1t::PFCandidate::MuonRef ref)
void	addRawHgcalCluster (l1ct::DetectorSector< ap_uint< 256 >> &sec, const l1t::PFCluster &c)
void	addTrack (const l1t::PFTrack &t, l1t::PFTrackRef ref)
void	addUInt (unsigned int value, std::string iLabel, edm::Event &iEvent)
void	beginStream (edm::StreamID) override
void	doVertexings (std::vector< float > &pvdz) const
void	endStream () override
std::unique_ptr< std::vector< l1t::PFTrack > >	fetchDecodedTracks () const
std::unique_ptr< l1t::PFCandidateCollection >	fetchEmCalo () const
std::unique_ptr< l1t::PFCandidateCollection >	fetchHadCalo () const
std::unique_ptr< l1t::PFCandidateCollection >	fetchPF () const
std::unique_ptr< l1t::PFCandidateCollection >	fetchTracks () const
void	initEvent (const edm::Event &e)
void	initSectorsAndRegions (const edm::ParameterSet &iConfig)
void	produce (edm::Event &, const edm::EventSetup &) override
void	putEgObjects (edm::Event &iEvent, const bool writeEgSta, const std::string &tkEmLabel, const std::string &tkEmPerBoardLabel, const std::string &tkEleLabel, const std::string &tkElePerBoardLabel) const
void	putEgStaObjects (edm::Event &iEvent, const std::string &egLablel) const
void	putPuppi (edm::Event &iEvent) const
template<class T >
void	rawHgcalClusterEncode (ap_uint< 256 > &cwrd, const l1ct::DetectorSector< T > &sec, const l1t::PFCluster &c) const
template<typename T >
void	setRefs_ (l1t::PFCandidate &pf, const T &p) const
std::pair< unsigned int, unsigned int >	totAndMax (const std::vector< unsigned > &perRegion) const
std::unique_ptr< std::vector< unsigned > >	vecOutput (OutputType i, bool usePuppi) const
std::unique_ptr< std::vector< unsigned > >	vecRegInput (InputType i) const
std::unique_ptr< std::vector< unsigned > >	vecSecInput (InputType i) const

Static Private Member Functions
template<typename T >
static edm::ParameterDescription< edm::ParameterSetDescription >	getParDesc (const std::string &name)

Private Attributes
std::unordered_map< const l1t::PFCluster *, l1t::PFClusterRef >	clusterRefMap_
edm::ParameterSet	config_
float	debugEta_
float	debugPhi_
float	debugR_
std::vector< edm::EDGetTokenT< l1t::PFClusterCollection > >	emCands_
float	emPtCut_
bool	emuTkVtx_
l1ct::Event	event_
edm::EDGetTokenT< std::vector< l1t::Vertex > >	extTkVtx_
std::fstream	fRegionDump_
std::vector< edm::EDGetTokenT< l1t::PFClusterCollection > >	hadCands_
float	hadPtCut_
bool	hasTracks_
std::unique_ptr< l1ct::HgcalClusterDecoderEmulator >	hgcalInput_
std::unique_ptr< l1ct::PFAlgoEmulatorBase >	l1pfalgo_
std::unique_ptr< l1ct::LinPuppiEmulator >	l1pualgo_
std::unique_ptr< l1ct::PFTkEGAlgoEmulator >	l1tkegalgo_
std::unique_ptr< l1ct::PFTkEGSorterEmulator >	l1tkegsorter_
edm::EDGetTokenT< l1t::SAMuonCollection >	muCands_
std::unique_ptr< l1ct::GMTMuonDecoderEmulator >	muonInput_
std::unordered_map< const l1t::SAMuon *, l1t::PFCandidate::MuonRef >	muonRefMap_
int	nVtx_
const edm::VParameterSet	patternWriterConfigs_
std::vector< std::unique_ptr< L1TCorrelatorLayer1PatternFileWriter > >	patternWriters_
const std::string	regionDumpName_
std::unique_ptr< l1ct::RegionizerEmulator >	regionizer_
edm::EDGetTokenT< l1t::PFTrackCollection >	tkCands_
edm::EDGetTokenT< std::vector< l1t::VertexWord > >	tkVtxEmu_
std::unique_ptr< l1ct::TrackInputEmulator >	trackInput_
std::unordered_map< const l1t::PFTrack *, l1t::PFTrackRef >	trackRefMap_
float	trkPt_
bool	writeRawHgcalCluster_

Static Private Attributes
static constexpr const char *	inputTypeName [l1muType+1] = {"Calo", "EmCalo", "TK", "Mu"}

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer<>
using	CacheTypes = CacheContexts< T... >
using	GlobalCache = typename CacheTypes::GlobalCache
using	HasAbility = AbilityChecker< T... >
using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache
using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache
using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >
using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache
using	RunCache = typename CacheTypes::RunCache
using	RunContext = RunContextT< RunCache, GlobalCache >
using	RunSummaryCache = typename CacheTypes::RunSummaryCache

Detailed Description

Definition at line 50 of file L1TCorrelatorLayer1Producer.cc.

Member Typedef Documentation

OutputType

typedef l1ct::OutputRegion::ObjType L1TCorrelatorLayer1Producer::OutputType

private

Definition at line 178 of file L1TCorrelatorLayer1Producer.cc.

Member Enumeration Documentation

InputType

enum L1TCorrelatorLayer1Producer::InputType

private

Enumerator
caloType
emcaloType
trackType
l1muType

Definition at line 174 of file L1TCorrelatorLayer1Producer.cc.

{ caloType = 0, emcaloType = 1, trackType = 2, l1muType = 3 };

Constructor & Destructor Documentation

L1TCorrelatorLayer1Producer()

L1TCorrelatorLayer1Producer::L1TCorrelatorLayer1Producer ( const edm::ParameterSet &  iConfig )

explicit

Definition at line 193 of file L1TCorrelatorLayer1Producer.cc.

References emCands_, emuTkVtx_, Exception, extTkVtx_, edm::ParameterSet::getParameter(), hadCands_, hasTracks_, hgcalInput_, mps_fire::i, initSectorsAndRegions(), inputTypeName, l1muType, l1pfalgo_, l1pualgo_, l1tkegalgo_, l1tkegsorter_, muonInput_, l1ct::OutputRegion::nPFTypes, nVtx_, l1ct::OutputRegion::objTypeName, muonDTDigis_cfi::pset, regionizer_, AlCaHLTBitMon_QueryRunRegistry::string, makeGlobalPositionRcd_cfg::tag, tkVtxEmu_, and trackInput_.

    : config_(iConfig),
      hasTracks_(!iConfig.getParameter<edm::InputTag>("tracks").label().empty()),
      tkCands_(hasTracks_ ? consumes<l1t::PFTrackCollection>(iConfig.getParameter<edm::InputTag>("tracks"))
                          : edm::EDGetTokenT<l1t::PFTrackCollection>()),
      trkPt_(iConfig.getParameter<double>("trkPtCut")),
      muCands_(consumes<l1t::SAMuonCollection>(iConfig.getParameter<edm::InputTag>("muons"))),
      emPtCut_(iConfig.getParameter<double>("emPtCut")),
      hadPtCut_(iConfig.getParameter<double>("hadPtCut")),
      regionizer_(nullptr),
      l1pfalgo_(nullptr),
      l1pualgo_(nullptr),
      l1tkegalgo_(nullptr),
      l1tkegsorter_(nullptr),
      regionDumpName_(iConfig.getUntrackedParameter<std::string>("dumpFileName")),
      writeRawHgcalCluster_(iConfig.getUntrackedParameter<bool>("writeRawHgcalCluster")),
      patternWriterConfigs_(iConfig.getUntrackedParameter<edm::VParameterSet>("patternWriters")),
      debugEta_(iConfig.getUntrackedParameter<double>("debugEta")),
      debugPhi_(iConfig.getUntrackedParameter<double>("debugPhi")),
      debugR_(iConfig.getUntrackedParameter<double>("debugR")) {
  produces<l1t::PFCandidateCollection>("PF");
  produces<l1t::PFCandidateCollection>("Puppi");
  produces<l1t::PFCandidateRegionalOutput>("PuppiRegional");

  produces<l1t::PFCandidateCollection>("EmCalo");
  produces<l1t::PFCandidateCollection>("Calo");
  produces<l1t::PFCandidateCollection>("TK");
#if 0  // LATER
  produces<l1t::PFCandidateCollection>("TKVtx");
#endif
  produces<std::vector<l1t::PFTrack>>("DecodedTK");

  for (const auto &tag : iConfig.getParameter<std::vector<edm::InputTag>>("emClusters")) {
    emCands_.push_back(consumes<l1t::PFClusterCollection>(tag));
  }
  for (const auto &tag : iConfig.getParameter<std::vector<edm::InputTag>>("hadClusters")) {
    hadCands_.push_back(consumes<l1t::PFClusterCollection>(tag));
  }

  if (hasTracks_) {
    const std::string &tkInAlgo = iConfig.getParameter<std::string>("trackInputConversionAlgo");
    if (tkInAlgo == "Emulator") {
      trackInput_ = std::make_unique<l1ct::TrackInputEmulator>(
          iConfig.getParameter<edm::ParameterSet>("trackInputConversionParameters"));
    } else if (tkInAlgo != "Ideal")
      throw cms::Exception("Configuration", "Unsupported trackInputConversionAlgo");
  }

  const std::string &muInAlgo = iConfig.getParameter<std::string>("muonInputConversionAlgo");
  if (muInAlgo == "Emulator") {
    muonInput_ = std::make_unique<l1ct::GMTMuonDecoderEmulator>(
        iConfig.getParameter<edm::ParameterSet>("muonInputConversionParameters"));
  } else if (muInAlgo != "Ideal")
    throw cms::Exception("Configuration", "Unsupported muonInputConversionAlgo");

  const std::string &hgcalInAlgo = iConfig.getParameter<std::string>("hgcalInputConversionAlgo");
  if (hgcalInAlgo == "Emulator") {
    hgcalInput_ = std::make_unique<l1ct::HgcalClusterDecoderEmulator>(
        iConfig.getParameter<edm::ParameterSet>("hgcalInputConversionParameters"));
  } else if (hgcalInAlgo != "Ideal")
    throw cms::Exception("Configuration", "Unsupported hgcalInputConversionAlgo");

  const std::string &regalgo = iConfig.getParameter<std::string>("regionizerAlgo");
  if (regalgo == "Ideal") {
    regionizer_ =
        std::make_unique<l1ct::RegionizerEmulator>(iConfig.getParameter<edm::ParameterSet>("regionizerAlgoParameters"));
  } else if (regalgo == "Multififo") {
    regionizer_ = std::make_unique<l1ct::MultififoRegionizerEmulator>(
        iConfig.getParameter<edm::ParameterSet>("regionizerAlgoParameters"));
  } else if (regalgo == "BufferedFoldedMultififo") {
    regionizer_ = std::make_unique<l1ct::BufferedFoldedMultififoRegionizerEmulator>(
        iConfig.getParameter<edm::ParameterSet>("regionizerAlgoParameters"));
  } else if (regalgo == "MultififoBarrel") {
    const auto &pset = iConfig.getParameter<edm::ParameterSet>("regionizerAlgoParameters");
    regionizer_ =
        std::make_unique<l1ct::MultififoRegionizerEmulator>(pset.getParameter<std::string>("barrelSetup"), pset);
  } else if (regalgo == "MiddleBufferMultififo") {
    regionizer_ = std::make_unique<l1ct::MiddleBufferMultififoRegionizerEmulator>(
        iConfig.getParameter<edm::ParameterSet>("regionizerAlgoParameters"));
  } else if (regalgo == "TDR") {
    regionizer_ = std::make_unique<l1ct::TDRRegionizerEmulator>(
        iConfig.getParameter<edm::ParameterSet>("regionizerAlgoParameters"));
  } else
    throw cms::Exception("Configuration", "Unsupported regionizerAlgo");

  const std::string &algo = iConfig.getParameter<std::string>("pfAlgo");
  if (algo == "PFAlgo3") {
    l1pfalgo_ = std::make_unique<l1ct::PFAlgo3Emulator>(iConfig.getParameter<edm::ParameterSet>("pfAlgoParameters"));
  } else if (algo == "PFAlgo2HGC") {
    l1pfalgo_ = std::make_unique<l1ct::PFAlgo2HGCEmulator>(iConfig.getParameter<edm::ParameterSet>("pfAlgoParameters"));
  } else if (algo == "PFAlgoDummy") {
    l1pfalgo_ =
        std::make_unique<l1ct::PFAlgoDummyEmulator>(iConfig.getParameter<edm::ParameterSet>("pfAlgoParameters"));
  } else
    throw cms::Exception("Configuration", "Unsupported pfAlgo");

  const std::string &pualgo = iConfig.getParameter<std::string>("puAlgo");
  if (pualgo == "LinearizedPuppi") {
    l1pualgo_ = std::make_unique<l1ct::LinPuppiEmulator>(iConfig.getParameter<edm::ParameterSet>("puAlgoParameters"));
  } else
    throw cms::Exception("Configuration", "Unsupported puAlgo");

  l1tkegalgo_ = std::make_unique<l1ct::PFTkEGAlgoEmulator>(
      l1ct::PFTkEGAlgoEmuConfig(iConfig.getParameter<edm::ParameterSet>("tkEgAlgoParameters")));

  const std::string &egsortalgo = iConfig.getParameter<std::string>("tkEgSorterAlgo");
  if (egsortalgo == "Barrel") {
    l1tkegsorter_ = std::make_unique<l1ct::PFTkEGSorterBarrelEmulator>(
        iConfig.getParameter<edm::ParameterSet>("tkEgSorterParameters"));
  } else if (egsortalgo == "Endcap") {
    l1tkegsorter_ =
        std::make_unique<l1ct::PFTkEGSorterEmulator>(iConfig.getParameter<edm::ParameterSet>("tkEgSorterParameters"));
  } else
    throw cms::Exception("Configuration", "Unsupported tkEgSorterAlgo");

  if (l1tkegalgo_->writeEgSta())
    produces<BXVector<l1t::EGamma>>("L1Eg");
  produces<l1t::TkElectronCollection>("L1TkEle");
  produces<l1t::TkElectronRegionalOutput>("L1TkElePerBoard");
  produces<l1t::TkEmCollection>("L1TkEm");
  produces<l1t::TkEmRegionalOutput>("L1TkEmPerBoard");

  emuTkVtx_ = iConfig.getParameter<bool>("vtxCollectionEmulation");
  if (emuTkVtx_) {
    tkVtxEmu_ = consumes<std::vector<l1t::VertexWord>>(iConfig.getParameter<edm::InputTag>("vtxCollection"));
  } else {
    extTkVtx_ = consumes<std::vector<l1t::Vertex>>(iConfig.getParameter<edm::InputTag>("vtxCollection"));
  }
  nVtx_ = iConfig.getParameter<int>("nVtx");

  const char *iprefix[4] = {"totNReg", "maxNReg", "totNSec", "maxNSec"};
  for (int i = 0; i <= l1muType; ++i) {
    for (int ip = 0; ip < 4; ++ip) {
      produces<unsigned int>(std::string(iprefix[ip]) + inputTypeName[i]);
    }
    produces<std::vector<unsigned>>(std::string("vecNReg") + inputTypeName[i]);
    produces<std::vector<unsigned>>(std::string("vecNSec") + inputTypeName[i]);
  }
  const char *oprefix[4] = {"totNPF", "maxNPF", "totNPuppi", "maxNPuppi"};
  for (int i = 0; i < l1ct::OutputRegion::nPFTypes; ++i) {
    for (int ip = 0; ip < 4; ++ip) {
      produces<unsigned int>(std::string(oprefix[ip]) + l1ct::OutputRegion::objTypeName[i]);
    }
    produces<std::vector<unsigned>>(std::string("vecNPF") + l1ct::OutputRegion::objTypeName[i]);
    produces<std::vector<unsigned>>(std::string("vecNPuppi") + l1ct::OutputRegion::objTypeName[i]);
  }

  initSectorsAndRegions(iConfig);
}

~L1TCorrelatorLayer1Producer()

L1TCorrelatorLayer1Producer::~L1TCorrelatorLayer1Producer ( )

override

Definition at line 343 of file L1TCorrelatorLayer1Producer.cc.

{}

Member Function Documentation

addDecodedEmCalo()

void L1TCorrelatorLayer1Producer::addDecodedEmCalo ( l1ct::DetectorSector< l1ct::EmCaloObjEmu > &  sec, const l1t::PFCluster &  t  )

private

Definition at line 847 of file L1TCorrelatorLayer1Producer.cc.

References DummyCfis::c, l1tPhase2CaloJetEmulator_cfi::calo, l1ct::Scales::makeGlbEta(), l1ct::Scales::makePhi(), l1ct::Scales::makePtFromFloat(), and fileinputsource_cfi::sec.

Referenced by addEmCalo().

                                                                          {
  l1ct::EmCaloObjEmu calo;
  // set the endcap-sepcific variables to default value:
  calo.clear();
  calo.hwPt = l1ct::Scales::makePtFromFloat(c.pt());
  calo.hwEta = l1ct::Scales::makeGlbEta(c.eta()) -
               sec.region.hwEtaCenter;  // important to enforce that the region boundary is on a discrete value
  calo.hwPhi = l1ct::Scales::makePhi(sec.region.localPhi(c.phi()));
  calo.hwPtErr = l1ct::Scales::makePtFromFloat(c.ptError());
  calo.hwEmID = c.hwEmID();
  calo.src = &c;
  sec.obj.push_back(calo);
}

addDecodedHadCalo()

void L1TCorrelatorLayer1Producer::addDecodedHadCalo ( l1ct::DetectorSector< l1ct::HadCaloObjEmu > &  sec, const l1t::PFCluster &  t  )

private

Definition at line 819 of file L1TCorrelatorLayer1Producer.cc.

References DummyCfis::c, l1tPhase2CaloJetEmulator_cfi::calo, hgcalInput_, l1ct::Scales::makeGlbEta(), l1ct::Scales::makeHoe(), l1ct::Scales::makeMeanZ(), l1ct::Scales::makePhi(), l1ct::Scales::makePtFromFloat(), l1ct::Scales::makeSrrTot(), rawHgcalClusterEncode(), and fileinputsource_cfi::sec.

Referenced by addHadCalo().

                                                                           {
  l1ct::HadCaloObjEmu calo;
  ap_uint<256> word = 0;
  rawHgcalClusterEncode(word, sec, c);
  if (hgcalInput_) {
    calo = hgcalInput_->decode(word);
  } else {
    calo.hwPt = l1ct::Scales::makePtFromFloat(c.pt());
    calo.hwEta = l1ct::Scales::makeGlbEta(c.eta()) -
                 sec.region.hwEtaCenter;  // important to enforce that the region boundary is on a discrete value
    calo.hwPhi = l1ct::Scales::makePhi(sec.region.localPhi(c.phi()));
    calo.hwEmPt = l1ct::Scales::makePtFromFloat(c.emEt());
    calo.hwEmID = c.hwEmID();
    calo.hwSrrTot = l1ct::Scales::makeSrrTot(c.sigmaRR());
    calo.hwMeanZ = c.absZBarycenter() < 320. ? l1ct::meanz_t(0) : l1ct::Scales::makeMeanZ(c.absZBarycenter());
    calo.hwHoe = l1ct::Scales::makeHoe(c.hOverE());
  }
  calo.src = &c;
  sec.obj.push_back(calo);
}

addDecodedMuon()

void L1TCorrelatorLayer1Producer::addDecodedMuon ( l1ct::DetectorSector< l1ct::MuObjEmu > &  sec, const l1t::SAMuon &  t  )

private

Definition at line 800 of file L1TCorrelatorLayer1Producer.cc.

References l1ct::Scales::makeGlbEta(), l1ct::Scales::makeGlbPhi(), l1ct::Scales::makePtFromFloat(), l1ct::Scales::makeZ0(), amptDefaultParameters_cff::mu, muonInput_, fileinputsource_cfi::sec, and submitPVValidationJobs::t.

Referenced by addMuon().

                                                                                                          {
  l1ct::MuObjEmu mu;
  if (muonInput_) {
    mu = muonInput_->decode(t.word());
  } else {
    mu.hwPt = l1ct::Scales::makePtFromFloat(t.pt());
    mu.hwEta = l1ct::Scales::makeGlbEta(t.eta());  // IMPORTANT: input is in global coordinates!
    mu.hwPhi = l1ct::Scales::makeGlbPhi(t.phi());
    mu.hwCharge = !t.hwCharge();
    mu.hwQuality = t.hwQual() / 2;
    mu.hwDEta = 0;
    mu.hwDPhi = 0;
    mu.hwZ0 = l1ct::Scales::makeZ0(t.vertex().Z());
    mu.hwDxy = 0;  // Dxy not defined yet
  }
  mu.src = &t;
  sec.obj.push_back(mu);
}

addDecodedTrack()

void L1TCorrelatorLayer1Producer::addDecodedTrack ( l1ct::DetectorSector< l1ct::TkObjEmu > &  sec, const l1t::PFTrack &  t  )

private

Definition at line 764 of file L1TCorrelatorLayer1Producer.cc.

References funct::abs(), reco::deltaPhi(), l1ct::Scales::makeEta(), l1ct::Scales::makeGlbEta(), l1ct::Scales::makePhi(), l1ct::Scales::makePtFromFloat(), l1ct::Scales::makeZ0(), fileinputsource_cfi::sec, submitPVValidationJobs::t, and trackInput_.

Referenced by addTrack().

                                                                                                            {
  std::pair<l1ct::TkObjEmu, bool> tkAndSel;
  if (trackInput_) {
    tkAndSel = trackInput_->decodeTrack(t.trackWord().getTrackWord(), sec.region);
  } else {
    tkAndSel.first.hwPt = l1ct::Scales::makePtFromFloat(t.pt());
    tkAndSel.first.hwEta =
        l1ct::Scales::makeGlbEta(t.caloEta()) -
        sec.region.hwEtaCenter;  // important to enforce that the region boundary is on a discrete value
    tkAndSel.first.hwPhi = l1ct::Scales::makePhi(sec.region.localPhi(t.caloPhi()));
    tkAndSel.first.hwCharge = t.charge() > 0;
    tkAndSel.first.hwQuality = t.quality();
    tkAndSel.first.hwDEta = l1ct::Scales::makeEta(t.eta() - t.caloEta());
    tkAndSel.first.hwDPhi = l1ct::Scales::makePhi(std::abs(reco::deltaPhi(t.phi(), t.caloPhi())));
    tkAndSel.first.hwZ0 = l1ct::Scales::makeZ0(t.vertex().Z());
    tkAndSel.first.hwDxy = 0;
    tkAndSel.second = t.quality() > 0;
  }
  // CMSSW-only extra info
  tkAndSel.first.hwChi2 = round(t.chi2() * 10);
  tkAndSel.first.simPt = t.pt();
  tkAndSel.first.simCaloEta = t.caloEta();
  tkAndSel.first.simCaloPhi = t.caloPhi();
  tkAndSel.first.simVtxEta = t.eta();
  tkAndSel.first.simVtxPhi = t.phi();
  tkAndSel.first.simZ0 = t.vertex().Z();
  tkAndSel.first.simD0 = t.vertex().Rho();
  tkAndSel.first.src = &t;

  // If the track fails, we set its pT to zero, so that the decoded tracks are still aligned with the raw tracks
  // Downstream, the regionizer will just ignore zero-momentum tracks
  if (!tkAndSel.second)
    tkAndSel.first.hwPt = 0;
  sec.obj.push_back(tkAndSel.first);
}

addEmCalo()

void L1TCorrelatorLayer1Producer::addEmCalo ( const l1t::PFCluster &  t, l1t::PFClusterRef  ref  )

private

Definition at line 755 of file L1TCorrelatorLayer1Producer.cc.

References addDecodedEmCalo(), DummyCfis::c, clusterRefMap_, l1ct::Event::decoded, l1ct::RegionizerDecodedInputs::emcalo, event_, and fileinputsource_cfi::sec.

Referenced by produce().

                                                                                      {
  for (auto &sec : event_.decoded.emcalo) {
    if (sec.region.contains(c.eta(), c.phi())) {
      addDecodedEmCalo(sec, c);
    }
  }
  clusterRefMap_[&c] = ref;
}

addHadCalo()

void L1TCorrelatorLayer1Producer::addHadCalo ( const l1t::PFCluster &  t, l1t::PFClusterRef  ref  )

private

Definition at line 743 of file L1TCorrelatorLayer1Producer.cc.

References addDecodedHadCalo(), addRawHgcalCluster(), DummyCfis::c, clusterRefMap_, l1ct::Event::decoded, event_, l1ct::RegionizerDecodedInputs::hadcalo, l1ct::RawInputs::hgcalcluster, l1ct::Event::raw, fileinputsource_cfi::sec, and writeRawHgcalCluster_.

Referenced by produce().

                                                                                       {
  int sidx = 0;
  for (auto &sec : event_.decoded.hadcalo) {
    if (sec.region.contains(c.eta(), c.phi())) {
      addDecodedHadCalo(sec, c);
      if (writeRawHgcalCluster_)
        addRawHgcalCluster(event_.raw.hgcalcluster[sidx], c);
    }
    sidx++;
  }
  clusterRefMap_[&c] = ref;
}

addMuon()

void L1TCorrelatorLayer1Producer::addMuon ( const l1t::SAMuon &  t, l1t::PFCandidate::MuonRef  ref  )

private

Definition at line 738 of file L1TCorrelatorLayer1Producer.cc.

References addDecodedMuon(), l1ct::Event::decoded, event_, amptDefaultParameters_cff::mu, l1ct::RawInputs::muon, l1ct::RegionizerDecodedInputs::muon, muonRefMap_, l1ct::DetectorSector< T >::obj, and l1ct::Event::raw.

Referenced by produce().

                                                                                        {
  event_.raw.muon.obj.emplace_back(mu.word());
  addDecodedMuon(event_.decoded.muon, mu);
  muonRefMap_[&mu] = ref;
}

addRawHgcalCluster()

void L1TCorrelatorLayer1Producer::addRawHgcalCluster ( l1ct::DetectorSector< ap_uint< 256 >> &  sec, const l1t::PFCluster &  c  )

private

Definition at line 841 of file L1TCorrelatorLayer1Producer.cc.

References DummyCfis::c, rawHgcalClusterEncode(), and fileinputsource_cfi::sec.

Referenced by addHadCalo().

                                                                                                                 {
  ap_uint<256> cwrd = 0;
  rawHgcalClusterEncode(cwrd, sec, c);
  sec.obj.push_back(cwrd);
}

addTrack()

void L1TCorrelatorLayer1Producer::addTrack ( const l1t::PFTrack &  t, l1t::PFTrackRef  ref  )

private

Definition at line 729 of file L1TCorrelatorLayer1Producer.cc.

References addDecodedTrack(), cms::cuda::assert(), l1ct::Event::decoded, event_, l1ctLayer1_patternWriters_cff::isec, l1ct::Event::raw, volumeBasedMagneticField_160812_cfi::sectors, submitPVValidationJobs::t, l1ct::RawInputs::track, l1ct::RegionizerDecodedInputs::track, and trackRefMap_.

Referenced by produce().

                                                                                 {
  auto &rawsectors = event_.raw.track;
  auto &sectors = event_.decoded.track;
  assert(sectors.size() == 18 && rawsectors.size() == 18);
  int isec = t.track()->phiSector() + (t.eta() >= 0 ? 9 : 0);
  rawsectors[isec].obj.push_back(t.trackWord().getTrackWord());
  addDecodedTrack(sectors[isec], t);
  trackRefMap_[&t] = ref;
}

addUInt()

void L1TCorrelatorLayer1Producer::addUInt ( unsigned int  value, std::string  iLabel, edm::Event &  iEvent  )

private

Definition at line 639 of file L1TCorrelatorLayer1Producer.cc.

References iEvent.

Referenced by produce().

                                                                                                {
  iEvent.put(std::make_unique<unsigned>(value), iLabel);
}

beginStream()

void L1TCorrelatorLayer1Producer::beginStream ( edm::StreamID  id )

overrideprivate

Definition at line 423 of file L1TCorrelatorLayer1Producer.cc.

References event_, fRegionDump_, MillePedeFileConverter_cfg::out, patternWriterConfigs_, patternWriters_, muonDTDigis_cfi::pset, and regionDumpName_.

                                                            {
  if (!regionDumpName_.empty()) {
    if (id == 0) {
      fRegionDump_.open(regionDumpName_.c_str(), std::ios::out | std::ios::binary);
    } else {
      edm::LogWarning("L1TCorrelatorLayer1Producer")
          << "Job running with multiple streams, but dump file will have only events on stream zero.";
    }
  }
  if (!patternWriterConfigs_.empty()) {
    if (id == 0) {
      for (const auto &pset : patternWriterConfigs_) {
        patternWriters_.emplace_back(std::make_unique<L1TCorrelatorLayer1PatternFileWriter>(pset, event_));
      }
    } else {
      edm::LogWarning("L1TCorrelatorLayer1Producer")
          << "Job running with multiple streams, but pattern files will be written only on stream zero.";
    }
  }
}

doVertexings()

void L1TCorrelatorLayer1Producer::doVertexings ( std::vector< float > &  pvdz ) const

private

endStream()

void L1TCorrelatorLayer1Producer::endStream ( )

overrideprivate

Definition at line 444 of file L1TCorrelatorLayer1Producer.cc.

References patternWriters_, and convertToRaw::writer.

                                            {
  for (auto &writer : patternWriters_) {
    writer->flush();
  }
}

fetchDecodedTracks()

std::unique_ptr< std::vector< l1t::PFTrack > > L1TCorrelatorLayer1Producer::fetchDecodedTracks ( ) const

private

Definition at line 988 of file L1TCorrelatorLayer1Producer.cc.

References l1ct::Event::decoded, event_, AlCaHLTBitMon_ParallelJobs::p, alignCSCRings::r, runTheMatrix::ret, l1ct::RegionizerDecodedInputs::track, and L1BJetProducer_cff::vtx.

Referenced by produce().

                                                                                           {
  auto ret = std::make_unique<std::vector<l1t::PFTrack>>();
  for (const auto &r : event_.decoded.track) {
    const auto &reg = r.region;
    for (const auto &p : r.obj) {
      if (p.hwPt == 0 || !reg.isFiducial(p))
        continue;
      reco::Particle::PolarLorentzVector p4(
          p.floatPt(), reg.floatGlbEta(p.hwVtxEta()), reg.floatGlbPhi(p.hwVtxPhi()), 0);

      reco::Particle::Point vtx(0, 0, p.floatZ0());

      ret->emplace_back(l1t::PFTrack(p.intCharge(),
                                     reco::Particle::LorentzVector(p4),
                                     vtx,
                                     p.src->track(),
                                     0,
                                     reg.floatGlbEta(p.hwEta),
                                     reg.floatGlbPhi(p.hwPhi),
                                     -1,
                                     -1,
                                     p.hwQuality.to_int(),
                                     false,
                                     p.intPt(),
                                     p.intEta(),
                                     p.intPhi()));
    }
  }
  return ret;
}

fetchEmCalo()

std::unique_ptr< l1t::PFCandidateCollection > L1TCorrelatorLayer1Producer::fetchEmCalo ( ) const

private

Definition at line 957 of file L1TCorrelatorLayer1Producer.cc.

References event_, AlCaHLTBitMon_ParallelJobs::p, l1ct::Event::pfinputs, l1t::PFCandidate::Photon, alignCSCRings::r, runTheMatrix::ret, and setRefs_().

Referenced by produce().

                                                                                       {
  auto ret = std::make_unique<l1t::PFCandidateCollection>();
  for (const auto &r : event_.pfinputs) {
    const auto &reg = r.region;
    for (const auto &p : r.emcalo) {
      if (p.hwPt == 0 || !reg.isFiducial(p))
        continue;
      reco::Particle::PolarLorentzVector p4(p.floatPt(), reg.floatGlbEtaOf(p), reg.floatGlbPhiOf(p), 0.13f);
      ret->emplace_back(l1t::PFCandidate::Photon, 0, p4, 1, p.intPt(), p.intEta(), p.intPhi());
      ret->back().setHwEmID(p.hwEmID);
      setRefs_(ret->back(), p);
    }
  }
  return ret;
}

fetchHadCalo()

std::unique_ptr< l1t::PFCandidateCollection > L1TCorrelatorLayer1Producer::fetchHadCalo ( ) const

private

Definition at line 941 of file L1TCorrelatorLayer1Producer.cc.

References event_, l1t::PFCandidate::NeutralHadron, AlCaHLTBitMon_ParallelJobs::p, l1ct::Event::pfinputs, l1t::PFCandidate::Photon, alignCSCRings::r, runTheMatrix::ret, and setRefs_().

Referenced by produce().

                                                                                        {
  auto ret = std::make_unique<l1t::PFCandidateCollection>();
  for (const auto &r : event_.pfinputs) {
    const auto &reg = r.region;
    for (const auto &p : r.hadcalo) {
      if (p.hwPt == 0 || !reg.isFiducial(p))
        continue;
      reco::Particle::PolarLorentzVector p4(p.floatPt(), reg.floatGlbEtaOf(p), reg.floatGlbPhiOf(p), 0.13f);
      l1t::PFCandidate::ParticleType type = p.hwIsEM() ? l1t::PFCandidate::Photon : l1t::PFCandidate::NeutralHadron;
      ret->emplace_back(type, 0, p4, 1, p.intPt(), p.intEta(), p.intPhi());
      ret->back().setHwEmID(p.hwEmID);
      setRefs_(ret->back(), p);
    }
  }
  return ret;
}

fetchPF()

std::unique_ptr< l1t::PFCandidateCollection > L1TCorrelatorLayer1Producer::fetchPF ( ) const

private

Definition at line 1019 of file L1TCorrelatorLayer1Producer.cc.

References l1t::PFCandidate::ChargedHadron, l1t::PFCandidate::Electron, event_, f, l1t::PFCandidate::Muon, l1t::PFCandidate::NeutralHadron, EgHLTOffHistBins_cfi::nr, l1ct::Event::out, AlCaHLTBitMon_ParallelJobs::p, l1ct::Event::pfinputs, l1t::PFCandidate::Photon, runTheMatrix::ret, and setRefs_().

Referenced by produce().

                                                                                   {
  auto ret = std::make_unique<l1t::PFCandidateCollection>();
  for (unsigned int ir = 0, nr = event_.pfinputs.size(); ir < nr; ++ir) {
    const auto &reg = event_.pfinputs[ir].region;
    for (const auto &p : event_.out[ir].pfcharged) {
      if (p.hwPt == 0 || !reg.isFiducial(p))
        continue;
      reco::Particle::PolarLorentzVector p4(
          p.floatPt(), reg.floatGlbEta(p.hwVtxEta()), reg.floatGlbPhi(p.hwVtxPhi()), 0.13f);
      l1t::PFCandidate::ParticleType type = l1t::PFCandidate::ChargedHadron;
      if (p.hwId.isMuon())
        type = l1t::PFCandidate::Muon;
      else if (p.hwId.isElectron())
        type = l1t::PFCandidate::Electron;
      ret->emplace_back(type, p.intCharge(), p4, 1, p.intPt(), p.intEta(), p.intPhi());
      ret->back().setZ0(p.floatZ0());
      ret->back().setDxy(p.floatDxy());
      ret->back().setHwZ0(p.hwZ0);
      ret->back().setHwDxy(p.hwDxy);
      ret->back().setHwTkQuality(p.hwTkQuality);
      ret->back().setCaloEta(reg.floatGlbEtaOf(p));
      ret->back().setCaloPhi(reg.floatGlbPhiOf(p));

      setRefs_(ret->back(), p);
    }
    for (const auto &p : event_.out[ir].pfneutral) {
      if (p.hwPt == 0 || !reg.isFiducial(p))
        continue;
      reco::Particle::PolarLorentzVector p4(p.floatPt(), reg.floatGlbEtaOf(p), reg.floatGlbPhiOf(p), 0.13f);
      l1t::PFCandidate::ParticleType type =
          p.hwId.isPhoton() ? l1t::PFCandidate::Photon : l1t::PFCandidate::NeutralHadron;
      ret->emplace_back(type, 0, p4, 1, p.intPt(), p.intEta(), p.intPhi());
      ret->back().setHwEmID(p.hwEmID);
      ret->back().setCaloEta(reg.floatGlbEtaOf(p));
      ret->back().setCaloPhi(reg.floatGlbPhiOf(p));
      setRefs_(ret->back(), p);
    }
  }
  return ret;
}

fetchTracks()

std::unique_ptr< l1t::PFCandidateCollection > L1TCorrelatorLayer1Producer::fetchTracks ( ) const

private

Definition at line 972 of file L1TCorrelatorLayer1Producer.cc.

References l1t::PFCandidate::ChargedHadron, event_, f, AlCaHLTBitMon_ParallelJobs::p, l1ct::Event::pfinputs, alignCSCRings::r, runTheMatrix::ret, and setRefs_().

Referenced by produce().

                                                                                       {
  auto ret = std::make_unique<l1t::PFCandidateCollection>();
  for (const auto &r : event_.pfinputs) {
    const auto &reg = r.region;
    for (const auto &p : r.track) {
      if (p.hwPt == 0 || !reg.isFiducial(p))
        continue;
      reco::Particle::PolarLorentzVector p4(
          p.floatPt(), reg.floatGlbEta(p.hwVtxEta()), reg.floatGlbPhi(p.hwVtxPhi()), 0.13f);
      ret->emplace_back(l1t::PFCandidate::ChargedHadron, p.intCharge(), p4, 1, p.intPt(), p.intEta(), p.intPhi());
      setRefs_(ret->back(), p);
    }
  }
  return ret;
}

fillDescriptions()

void L1TCorrelatorLayer1Producer::fillDescriptions ( edm::ConfigurationDescriptions &  descriptions )

static

Definition at line 345 of file L1TCorrelatorLayer1Producer.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), submitPVResolutionJobs::desc, L1TCorrelatorLayer1PatternFileWriter::getParameterSetDescription(), l1ct::PFTkEGAlgoEmuConfig::getParameterSetDescription(), l1ct::MultififoRegionizerEmulator::getParameterSetDescriptionBarrel(), ProducerED_cfi::InputTag, or, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                             {
  edm::ParameterSetDescription desc;
  // Inputs and cuts
  desc.add<edm::InputTag>("tracks", edm::InputTag(""));
  desc.add<edm::InputTag>("muons", edm::InputTag("l1tSAMuonsGmt", "prompt"));
  desc.add<std::vector<edm::InputTag>>("emClusters", std::vector<edm::InputTag>());
  desc.add<std::vector<edm::InputTag>>("hadClusters", std::vector<edm::InputTag>());
  desc.add<edm::InputTag>("vtxCollection", edm::InputTag("l1tVertexFinderEmulator", "L1VerticesEmulation"));
  desc.add<bool>("vtxCollectionEmulation", true);
  desc.add<double>("emPtCut", 0.0);
  desc.add<double>("hadPtCut", 0.0);
  desc.add<double>("trkPtCut", 0.0);
  desc.add<int32_t>("nVtx");
  // Input conversion
  edm::EmptyGroupDescription emptyGroup;
  desc.ifValue(edm::ParameterDescription<std::string>("trackInputConversionAlgo", "Ideal", true),
               "Ideal" >> emptyGroup or "Emulator" >> getParDesc<l1ct::TrackInputEmulator>("trackInputConversion"));
  desc.ifValue(edm::ParameterDescription<std::string>("muonInputConversionAlgo", "Ideal", true),
               "Ideal" >> emptyGroup or "Emulator" >> getParDesc<l1ct::GMTMuonDecoderEmulator>("muonInputConversion"));
  desc.ifValue(
      edm::ParameterDescription<std::string>("hgcalInputConversionAlgo", "Ideal", true),
      "Ideal" >> emptyGroup or "Emulator" >> getParDesc<l1ct::HgcalClusterDecoderEmulator>("hgcalInputConversion"));
  // Regionizer
  auto idealRegPD = getParDesc<l1ct::RegionizerEmulator>("regionizerAlgo");
  auto tdrRegPD = getParDesc<l1ct::TDRRegionizerEmulator>("regionizerAlgo");
  auto multififoRegPD = getParDesc<l1ct::MultififoRegionizerEmulator>("regionizerAlgo");
  auto bfMultififoRegPD = getParDesc<l1ct::BufferedFoldedMultififoRegionizerEmulator>("regionizerAlgo");
  auto multififoBarrelRegPD = edm::ParameterDescription<edm::ParameterSetDescription>(
      "regionizerAlgoParameters", l1ct::MultififoRegionizerEmulator::getParameterSetDescriptionBarrel(), true);
  auto mbMultififoRegPD = getParDesc<l1ct::MiddleBufferMultififoRegionizerEmulator>("regionizerAlgo");
  desc.ifValue(edm::ParameterDescription<std::string>("regionizerAlgo", "Ideal", true),
               "Ideal" >> idealRegPD or "TDR" >> tdrRegPD or "Multififo" >> multififoRegPD or
                   "BufferedFoldedMultififo" >> bfMultififoRegPD or "MultififoBarrel" >> multififoBarrelRegPD or
                   "MiddleBufferMultififo" >> mbMultififoRegPD);
  // PF
  desc.ifValue(edm::ParameterDescription<std::string>("pfAlgo", "PFAlgo3", true),
               "PFAlgo3" >> getParDesc<l1ct::PFAlgo3Emulator>("pfAlgo") or
                   "PFAlgo2HGC" >> getParDesc<l1ct::PFAlgo2HGCEmulator>("pfAlgo") or
                   "PFAlgoDummy" >> getParDesc<l1ct::PFAlgoDummyEmulator>("pfAlgo"));
  // Puppi
  desc.ifValue(edm::ParameterDescription<std::string>("puAlgo", "LinearizedPuppi", true),
               "LinearizedPuppi" >> getParDesc<l1ct::LinPuppiEmulator>("puAlgo"));
  // EGamma
  desc.add<edm::ParameterSetDescription>("tkEgAlgoParameters", l1ct::PFTkEGAlgoEmuConfig::getParameterSetDescription());
  // EGamma sort
  desc.ifValue(edm::ParameterDescription<std::string>("tkEgSorterAlgo", "Barrel", true),
               "Barrel" >> getParDesc<l1ct::PFTkEGSorterBarrelEmulator>("tkEgSorter") or
                   "Endcap" >> getParDesc<l1ct::PFTkEGSorterEmulator>("tkEgSorter"));
  // geometry: calo sectors
  edm::ParameterSetDescription caloSectorPSD;
  caloSectorPSD.add<std::vector<double>>("etaBoundaries");
  caloSectorPSD.add<uint32_t>("phiSlices", 3);
  caloSectorPSD.add<double>("phiZero", 0.);
  desc.addVPSet("caloSectors", caloSectorPSD);
  // geometry: regions
  edm::ParameterSetDescription regionPSD;
  regionPSD.add<std::vector<double>>("etaBoundaries");
  regionPSD.add<uint32_t>("phiSlices", 9);
  regionPSD.add<double>("etaExtra", 0.25);
  regionPSD.add<double>("phiExtra", 0.25);
  desc.addVPSet("regions", regionPSD);
  // geometry: boards
  edm::ParameterSetDescription boardPSD;
  boardPSD.add<std::vector<unsigned int>>("regions");
  desc.addVPSet("boards", boardPSD);
  // dump files
  desc.addUntracked<std::string>("dumpFileName", "");
  desc.addUntracked<bool>("writeRawHgcalCluster", false);
  // pattern files
  desc.addVPSetUntracked(
      "patternWriters", L1TCorrelatorLayer1PatternFileWriter::getParameterSetDescription(), edm::VParameterSet());
  // debug
  desc.addUntracked<double>("debugEta", 0.);
  desc.addUntracked<double>("debugPhi", 0.);
  desc.addUntracked<double>("debugR", -1.);
  descriptions.add("l1tCorrelatorLayer1", desc);
}

getParDesc()

template<typename T >

static edm::ParameterDescription<edm::ParameterSetDescription> L1TCorrelatorLayer1Producer::getParDesc ( const std::string &  name )

inlinestaticprivate

Definition at line 184 of file L1TCorrelatorLayer1Producer.cc.

References Skims_PA_cff::name.

                                                                                               {
    return edm::ParameterDescription<edm::ParameterSetDescription>(
        name + "Parameters", T::getParameterSetDescription(), true);
  }

initEvent()

void L1TCorrelatorLayer1Producer::initEvent ( const edm::Event &  e )

private

Definition at line 719 of file L1TCorrelatorLayer1Producer.cc.

References l1ct::Event::clear(), clusterRefMap_, l1ct::Event::event, event_, iEvent, l1ct::Event::lumi, muonRefMap_, l1ct::Event::run, and trackRefMap_.

Referenced by produce().

                                                                  {
  event_.clear();
  event_.run = iEvent.id().run();
  event_.lumi = iEvent.id().luminosityBlock();
  event_.event = iEvent.id().event();
  clusterRefMap_.clear();
  trackRefMap_.clear();
  muonRefMap_.clear();
}

initSectorsAndRegions()

void L1TCorrelatorLayer1Producer::initSectorsAndRegions ( const edm::ParameterSet &  iConfig )

private

Definition at line 643 of file L1TCorrelatorLayer1Producer.cc.

References l1ct::Event::board_out, l1ct::Event::decoded, l1ct::RegionizerDecodedInputs::emcalo, hltEgammaEleL1TrkIsoL1Seeded_cfi::etaBoundaries, electrons_cff::etaWidth, event_, Exception, edm::ParameterSet::getParameter(), l1ct::RegionizerDecodedInputs::hadcalo, l1ct::RawInputs::hgcalcluster, hcalRecHitTable_cff::ieta, hcalRecHitTable_cff::iphi, M_PI, l1ct::Scales::maxAbsEta(), l1ct::Scales::maxAbsPhi(), l1ct::RawInputs::muon, l1ct::RegionizerDecodedInputs::muon, neta, l1ct::Event::pfinputs, l1ctLayer1_cff::phiSlices, electrons_cff::phiWidth, l1ctLayer1_cff::phiZero, l1ct::Event::raw, reco::reduceRange(), l1ct::DetectorSector< T >::region, l1ct::RawInputs::track, and l1ct::RegionizerDecodedInputs::track.

Referenced by L1TCorrelatorLayer1Producer().

                                                                                      {
  // the track finder geometry is fixed
  unsigned int TF_phiSlices = 9;
  float TF_phiWidth = 2 * M_PI / TF_phiSlices;
  event_.decoded.track.clear();
  for (unsigned int ieta = 0, neta = 2; ieta < neta; ++ieta) {
    for (unsigned int iphi = 0; iphi < TF_phiSlices; ++iphi) {
      float phiCenter = reco::reduceRange(iphi * TF_phiWidth);
      event_.decoded.track.emplace_back((ieta ? 0. : -2.5), (ieta ? 2.5 : 0.0), phiCenter, TF_phiWidth);
      event_.raw.track.emplace_back((ieta ? 0. : -2.5), (ieta ? 2.5 : 0.0), phiCenter, TF_phiWidth);
    }
  }

  event_.decoded.emcalo.clear();
  event_.decoded.hadcalo.clear();
  event_.raw.hgcalcluster.clear();

  for (const edm::ParameterSet &preg : iConfig.getParameter<edm::VParameterSet>("caloSectors")) {
    std::vector<double> etaBoundaries = preg.getParameter<std::vector<double>>("etaBoundaries");
    if (!std::is_sorted(etaBoundaries.begin(), etaBoundaries.end()))
      throw cms::Exception("Configuration", "caloSectors.etaBoundaries not sorted\n");
    unsigned int phiSlices = preg.getParameter<uint32_t>("phiSlices");
    float phiWidth = 2 * M_PI / phiSlices;
    if (phiWidth > 2 * l1ct::Scales::maxAbsPhi())
      throw cms::Exception("Configuration", "caloSectors phi range too large for phi_t data type");
    double phiZero = preg.getParameter<double>("phiZero");
    for (unsigned int ieta = 0, neta = etaBoundaries.size() - 1; ieta < neta; ++ieta) {
      float etaWidth = etaBoundaries[ieta + 1] - etaBoundaries[ieta];
      if (etaWidth > 2 * l1ct::Scales::maxAbsEta())
        throw cms::Exception("Configuration", "caloSectors eta range too large for eta_t data type");
      for (unsigned int iphi = 0; iphi < phiSlices; ++iphi) {
        float phiCenter = reco::reduceRange(iphi * phiWidth + phiZero);
        event_.decoded.hadcalo.emplace_back(etaBoundaries[ieta], etaBoundaries[ieta + 1], phiCenter, phiWidth);
        event_.decoded.emcalo.emplace_back(etaBoundaries[ieta], etaBoundaries[ieta + 1], phiCenter, phiWidth);
        event_.raw.hgcalcluster.emplace_back(etaBoundaries[ieta], etaBoundaries[ieta + 1], phiCenter, phiWidth);
      }
    }
  }

  event_.decoded.muon.region = l1ct::PFRegionEmu(0., 0.);  // centered at (0,0)
  event_.raw.muon.region = l1ct::PFRegionEmu(0., 0.);      // centered at (0,0)

  event_.pfinputs.clear();
  for (const edm::ParameterSet &preg : iConfig.getParameter<edm::VParameterSet>("regions")) {
    std::vector<double> etaBoundaries = preg.getParameter<std::vector<double>>("etaBoundaries");
    if (!std::is_sorted(etaBoundaries.begin(), etaBoundaries.end()))
      throw cms::Exception("Configuration", "regions.etaBoundaries not sorted\n");
    unsigned int phiSlices = preg.getParameter<uint32_t>("phiSlices");
    float etaExtra = preg.getParameter<double>("etaExtra");
    float phiExtra = preg.getParameter<double>("phiExtra");
    float phiWidth = 2 * M_PI / phiSlices;
    for (unsigned int ieta = 0, neta = etaBoundaries.size() - 1; ieta < neta; ++ieta) {
      for (unsigned int iphi = 0; iphi < phiSlices; ++iphi) {
        float phiCenter = reco::reduceRange(iphi * phiWidth);  //align with L1 TrackFinder phi sector indexing
        event_.pfinputs.emplace_back(
            etaBoundaries[ieta], etaBoundaries[ieta + 1], phiCenter, phiWidth, etaExtra, phiExtra);
      }
    }
  }

  event_.board_out.clear();
  const edm::VParameterSet &board_params = iConfig.getParameter<edm::VParameterSet>("boards");
  event_.board_out.resize(board_params.size());
  for (unsigned int bidx = 0; bidx < board_params.size(); bidx++) {
    event_.board_out[bidx].region_index = board_params[bidx].getParameter<std::vector<unsigned int>>("regions");
    float etaBoard = 0.;
    float phiBoard = 0.;
    for (auto ridx : event_.board_out[bidx].region_index) {
      etaBoard += event_.pfinputs[ridx].region.floatEtaCenter();
      phiBoard += event_.pfinputs[ridx].region.floatPhiCenter();
    }
    event_.board_out[bidx].eta = etaBoard / event_.board_out[bidx].region_index.size();
    event_.board_out[bidx].phi = phiBoard / event_.board_out[bidx].region_index.size();
  }
}

produce()

void L1TCorrelatorLayer1Producer::produce ( edm::Event &  iEvent, const edm::EventSetup &  iSetup  )

overrideprivate

—— READ TRACKS -—

---— READ MUONS -—

Definition at line 451 of file L1TCorrelatorLayer1Producer.cc.

References a, addEmCalo(), addHadCalo(), addMuon(), addTrack(), addUInt(), b, l1ct::Event::board_out, l1ct::Event::clear(), debugEta_, debugPhi_, debugR_, l1ct::Event::decoded, PbPb_ZMuSkimMuonDPG_cff::deltaR, emCands_, emPtCut_, emuTkVtx_, event_, extTkVtx_, fetchDecodedTracks(), fetchEmCalo(), fetchHadCalo(), fetchPF(), fetchTracks(), fRegionDump_, hadCands_, hadPtCut_, hasTracks_, l1ct::PVObj::hwZ0, mps_fire::i, iEvent, initEvent(), inputTypeName, l1muType, l1pfalgo_, l1pualgo_, l1tkegalgo_, l1tkegsorter_, l1ct::Scales::makeZ0(), SiStripPI::min, eostools::move(), amptDefaultParameters_cff::mu, muCands_, DiMuonV_cfg::muons, dqmiodumpmetadata::n, l1ct::OutputRegion::nPFTypes, EgHLTOffHistBins_cfi::nr, nVtx_, l1ct::OutputRegion::objTypeName, l1ct::Event::out, patternWriters_, l1ct::Event::pfinputs, putEgObjects(), putEgStaObjects(), putPuppi(), l1ct::Event::pvs, l1ct::Event::pvs_emu, regionizer_, edm::second(), AlCaHLTBitMon_QueryRunRegistry::string, makeGlobalPositionRcd_cfg::tag, tkCands_, tkVtxEmu_, totAndMax(), DiMuonV_cfg::tracks, trkPt_, vecOutput(), vecRegInput(), vecSecInput(), l1t::VertexWord::vertexWord(), L1BJetProducer_cff::vtx, l1ct::Event::write(), convertToRaw::writer, HLTMuonOfflineAnalyzer_cfi::z0, and l1t::VertexWord::z0().

                                                                                       {
  // clear the regions also at the beginning, in case one event didn't complete but the job continues on
  initEvent(iEvent);

  if (hasTracks_) {
    edm::Handle<l1t::PFTrackCollection> htracks;
    iEvent.getByToken(tkCands_, htracks);
    const auto &tracks = *htracks;
    for (unsigned int itk = 0, ntk = tracks.size(); itk < ntk; ++itk) {
      const auto &tk = tracks[itk];
      // adding objects to PF
      if (debugR_ > 0 && deltaR(tk.eta(), tk.phi(), debugEta_, debugPhi_) > debugR_)
        continue;
      if (tk.pt() > trkPt_) {
        addTrack(tk, l1t::PFTrackRef(htracks, itk));
      }
    }
  }

  edm::Handle<l1t::SAMuonCollection> muons;
  iEvent.getByToken(muCands_, muons);
  for (unsigned int i = 0, n = muons->size(); i < n; ++i) {
    const l1t::SAMuon &mu = (*muons)[i];
    if (debugR_ > 0 && deltaR(mu.eta(), mu.phi(), debugEta_, debugPhi_) > debugR_)
      continue;
    addMuon(mu, l1t::PFCandidate::MuonRef(muons, i));
  }
  // ------ READ CALOS -----
  edm::Handle<l1t::PFClusterCollection> caloHandle;
  for (const auto &tag : emCands_) {
    iEvent.getByToken(tag, caloHandle);
    const auto &calos = *caloHandle;
    for (unsigned int ic = 0, nc = calos.size(); ic < nc; ++ic) {
      const auto &calo = calos[ic];
      if (debugR_ > 0 && deltaR(calo.eta(), calo.phi(), debugEta_, debugPhi_) > debugR_)
        continue;
      if (calo.pt() > emPtCut_)
        addEmCalo(calo, l1t::PFClusterRef(caloHandle, ic));
    }
  }
  for (const auto &tag : hadCands_) {
    iEvent.getByToken(tag, caloHandle);
    const auto &calos = *caloHandle;
    for (unsigned int ic = 0, nc = calos.size(); ic < nc; ++ic) {
      const auto &calo = calos[ic];
      if (debugR_ > 0 && deltaR(calo.eta(), calo.phi(), debugEta_, debugPhi_) > debugR_)
        continue;
      if (calo.pt() > hadPtCut_)
        addHadCalo(calo, l1t::PFClusterRef(caloHandle, ic));
    }
  }

  regionizer_->run(event_.decoded, event_.pfinputs);

  // First, get a copy of the discretized and corrected inputs, and write them out
  iEvent.put(fetchEmCalo(), "EmCalo");
  iEvent.put(fetchHadCalo(), "Calo");
  iEvent.put(fetchTracks(), "TK");
  iEvent.put(fetchDecodedTracks(), "DecodedTK");

  // Then do the vertexing, and save it out
  std::vector<float> z0s;
  std::vector<std::pair<float, float>> ptsums;
  float z0 = 0;
  double ptsum = 0;
  l1t::VertexWord pvwd;
  // FIXME: collections seem to be already sorted
  if (emuTkVtx_) {
    edm::Handle<std::vector<l1t::VertexWord>> vtxEmuHandle;
    iEvent.getByToken(tkVtxEmu_, vtxEmuHandle);
    for (const auto &vtx : *vtxEmuHandle) {
      ptsums.push_back(std::pair<float, float>(vtx.pt(), vtx.z0()));
      if (ptsum == 0 || vtx.pt() > ptsum) {
        ptsum = vtx.pt();
        pvwd = vtx;
      }
    }
  } else {
    edm::Handle<std::vector<l1t::Vertex>> vtxHandle;
    iEvent.getByToken(extTkVtx_, vtxHandle);
    for (const auto &vtx : *vtxHandle) {
      ptsums.push_back(std::pair<float, float>(vtx.pt(), vtx.z0()));
      if (ptsum == 0 || vtx.pt() > ptsum) {
        ptsum = vtx.pt();
        z0 = vtx.z0();
      }
    }
    pvwd = l1t::VertexWord(1, z0, 1, ptsum, 1, 1, 1);
  }
  l1ct::PVObjEmu hwpv;
  hwpv.hwZ0 = l1ct::Scales::makeZ0(pvwd.z0());
  event_.pvs.push_back(hwpv);
  event_.pvs_emu.push_back(pvwd.vertexWord());
  //get additional vertices if requested
  if (nVtx_ > 1) {
    std::stable_sort(ptsums.begin(), ptsums.end(), [](const auto &a, const auto &b) { return a.first > b.first; });
    for (int i0 = 0; i0 < std::min(int(ptsums.size()), int(nVtx_)); i0++) {
      z0s.push_back(ptsums[i0].second);
    }
    for (unsigned int i = 1; i < z0s.size(); ++i) {
      l1ct::PVObjEmu hwpv;
      hwpv.hwZ0 = l1ct::Scales::makeZ0(z0s[i]);
      event_.pvs.push_back(hwpv);  //Skip emu
    }
  }
  // Then also save the tracks with a vertex cut
#if 0
  iEvent.put(l1regions_.fetchTracks(/*ptmin=*/0.0, /*fromPV=*/true), "TKVtx");
#endif

  // Then run PF in each region
  event_.out.resize(event_.pfinputs.size());
  for (unsigned int ir = 0, nr = event_.pfinputs.size(); ir < nr; ++ir) {
    l1pfalgo_->run(event_.pfinputs[ir], event_.out[ir]);
    l1pfalgo_->mergeNeutrals(event_.out[ir]);
    l1tkegalgo_->run(event_.pfinputs[ir], event_.out[ir]);
    l1tkegalgo_->runIso(event_.pfinputs[ir], event_.pvs, event_.out[ir]);
  }

  // Then run puppi (regionally)
  for (unsigned int ir = 0, nr = event_.pfinputs.size(); ir < nr; ++ir) {
    l1pualgo_->run(event_.pfinputs[ir], event_.pvs, event_.out[ir]);
    //l1pualgo_->runNeutralsPU(l1region, z0, -1., puGlobals);
  }

  // NOTE: This needs to happen before the EG sorting per board so that the EG objects
  // get a global reference to the EGSta before being mixed among differente regions
  std::vector<edm::Ref<BXVector<l1t::EGamma>>> egsta_refs;
  if (l1tkegalgo_->writeEgSta()) {
    putEgStaObjects(iEvent, "L1Eg");
  }

  // l1tkegsorter_->setDebug(true);
  for (auto &board : event_.board_out) {
    l1tkegsorter_->runPho(event_.pfinputs, event_.out, board.region_index, board.egphoton);
    l1tkegsorter_->runEle(event_.pfinputs, event_.out, board.region_index, board.egelectron);
  }

  // save PF into the event
  iEvent.put(fetchPF(), "PF");

  // and save puppi
  putPuppi(iEvent);

  // save the EG objects
  putEgObjects(iEvent, l1tkegalgo_->writeEgSta(), "L1TkEm", "L1TkEmPerBoard", "L1TkEle", "L1TkElePerBoard");

  // Then go do the multiplicities
  for (int i = 0; i <= l1muType; ++i) {
    auto vecInputs = vecSecInput(InputType(i));
    auto tm = totAndMax(*vecInputs);
    addUInt(tm.first, std::string("totNSec") + inputTypeName[i], iEvent);
    addUInt(tm.second, std::string("maxNSec") + inputTypeName[i], iEvent);
    iEvent.put(std::move(vecInputs), std::string("vecNSec") + inputTypeName[i]);
  }
  for (int i = 0; i <= l1muType; ++i) {
    auto vecInputs = vecRegInput(InputType(i));
    auto tm = totAndMax(*vecInputs);
    addUInt(tm.first, std::string("totNReg") + inputTypeName[i], iEvent);
    addUInt(tm.second, std::string("maxNReg") + inputTypeName[i], iEvent);
    iEvent.put(std::move(vecInputs), std::string("vecNReg") + inputTypeName[i]);
  }
  for (int i = 0; i < l1ct::OutputRegion::nPFTypes; ++i) {
    auto vecPF = vecOutput(OutputType(i), false);
    auto tmPF = totAndMax(*vecPF);
    addUInt(tmPF.first, std::string("totNPF") + l1ct::OutputRegion::objTypeName[i], iEvent);
    addUInt(tmPF.second, std::string("maxNPF") + l1ct::OutputRegion::objTypeName[i], iEvent);
    iEvent.put(std::move(vecPF), std::string("vecNPF") + l1ct::OutputRegion::objTypeName[i]);
    auto vecPuppi = vecOutput(OutputType(i), true);
    auto tmPuppi = totAndMax(*vecPuppi);
    addUInt(tmPuppi.first, std::string("totNPuppi") + l1ct::OutputRegion::objTypeName[i], iEvent);
    addUInt(tmPuppi.second, std::string("maxNPuppi") + l1ct::OutputRegion::objTypeName[i], iEvent);
    iEvent.put(std::move(vecPuppi), std::string("vecNPuppi") + l1ct::OutputRegion::objTypeName[i]);
  }

  if (fRegionDump_.is_open()) {
    event_.write(fRegionDump_);
  }
  for (auto &writer : patternWriters_) {
    writer->write(event_);
  }

  // finally clear the regions
  event_.clear();
}

putEgObjects()

void L1TCorrelatorLayer1Producer::putEgObjects ( edm::Event &  iEvent, const bool  writeEgSta, const std::string &  tkEmLabel, const std::string &  tkEmPerBoardLabel, const std::string &  tkEleLabel, const std::string &  tkElePerBoardLabel  ) const

private

Definition at line 1130 of file L1TCorrelatorLayer1Producer.cc.

References l1ct::Event::board_out, l1t::TkEm::CT, event_, iEvent, eostools::move(), edm::refToPtr(), and l1t::L1Candidate::setHwQual().

Referenced by produce().

                                                                                          {
  auto tkems = std::make_unique<l1t::TkEmCollection>();
  auto tkemRefProd = iEvent.getRefBeforePut<l1t::TkEmCollection>(tkEmLabel);
  auto tkemPerBoard = std::make_unique<l1t::TkEmRegionalOutput>(tkemRefProd);
  auto tkeles = std::make_unique<l1t::TkElectronCollection>();
  auto tkeleRefProd = iEvent.getRefBeforePut<l1t::TkElectronCollection>(tkEleLabel);
  auto tkelePerBoard = std::make_unique<l1t::TkElectronRegionalOutput>(tkeleRefProd);

  // TkEG objects are written out after the per-board sorting.
  // The mapping to each board is saved into the regionalmap for further (stage-2 consumption)
  std::vector<int> nele_obj;
  std::vector<int> npho_obj;

  for (const auto &board : event_.board_out) {
    npho_obj.clear();
    for (const auto &egiso : board.egphoton) {
      if (egiso.hwPt == 0)
        continue;

      reco::Candidate::PolarLorentzVector mom(egiso.floatPt(), egiso.floatEta(), egiso.floatPhi(), 0.);

      l1t::TkEm tkem(reco::Candidate::LorentzVector(mom),
                     egiso.srcCluster->constituentsAndFractions()[0].first,
                     egiso.floatRelIso(l1ct::EGIsoObjEmu::IsoType::TkIso),
                     egiso.floatRelIso(l1ct::EGIsoObjEmu::IsoType::TkIsoPV));
      tkem.setHwQual(egiso.hwQual);
      tkem.setPFIsol(egiso.floatRelIso(l1ct::EGIsoObjEmu::IsoType::PfIso));
      tkem.setPFIsolPV(egiso.floatRelIso(l1ct::EGIsoObjEmu::IsoType::PfIsoPV));
      tkem.setEgBinaryWord(egiso.pack(), l1t::TkEm::HWEncoding::CT);
      tkems->push_back(tkem);
      npho_obj.push_back(tkems->size() - 1);
    }
    tkemPerBoard->addRegion(npho_obj, board.eta, board.phi);

    nele_obj.clear();
    for (const auto &egele : board.egelectron) {
      if (egele.hwPt == 0)
        continue;

      reco::Candidate::PolarLorentzVector mom(egele.floatPt(), egele.floatVtxEta(), egele.floatVtxPhi(), 0.);

      l1t::TkElectron tkele(reco::Candidate::LorentzVector(mom),
                            egele.srcCluster->constituentsAndFractions()[0].first,
                            edm::refToPtr(egele.srcTrack->track()),
                            egele.floatRelIso(l1ct::EGIsoEleObjEmu::IsoType::TkIso));
      tkele.setHwQual(egele.hwQual);
      tkele.setPFIsol(egele.floatRelIso(l1ct::EGIsoEleObjEmu::IsoType::PfIso));
      tkele.setEgBinaryWord(egele.pack(), l1t::TkElectron::HWEncoding::CT);
      tkele.setIdScore(egele.floatIDScore());
      tkele.setCharge(egele.intCharge());
      tkele.setTrkzVtx(egele.floatZ0());
      tkeles->push_back(tkele);
      nele_obj.push_back(tkeles->size() - 1);
    }
    tkelePerBoard->addRegion(nele_obj, board.eta, board.phi);
  }

  iEvent.put(std::move(tkems), tkEmLabel);
  iEvent.put(std::move(tkemPerBoard), tkEmPerBoardLabel);
  iEvent.put(std::move(tkeles), tkEleLabel);
  iEvent.put(std::move(tkelePerBoard), tkElePerBoardLabel);
}

putEgStaObjects()

void L1TCorrelatorLayer1Producer::putEgStaObjects ( edm::Event &  iEvent, const std::string &  egLablel  ) const

private

Definition at line 1108 of file L1TCorrelatorLayer1Producer.cc.

References event_, iEvent, eostools::move(), EgHLTOffHistBins_cfi::nr, l1ct::Event::out, AlCaHLTBitMon_ParallelJobs::p, l1ct::Event::pfinputs, and l1t::L1Candidate::setHwQual().

Referenced by produce().

                                                                                                   {
  auto egs = std::make_unique<BXVector<l1t::EGamma>>();
  // FIXME: in case more BXes are introduced shuld probably use egs->key(egs->end(bx));

  for (unsigned int ir = 0, nr = event_.pfinputs.size(); ir < nr; ++ir) {
    const auto &reg = event_.pfinputs[ir].region;

    // EG standalone objects
    for (unsigned int ieg = 0, neg = event_.out[ir].egsta.size(); ieg < neg; ++ieg) {
      const auto &p = event_.out[ir].egsta[ieg];
      if (p.hwPt == 0 || !reg.isFiducial(p))
        continue;
      l1t::EGamma eg(
          reco::Candidate::PolarLorentzVector(p.floatPt(), reg.floatGlbEta(p.hwEta), reg.floatGlbPhi(p.hwPhi), 0.));
      eg.setHwQual(p.hwQual);
      egs->push_back(0, eg);
    }
  }

  iEvent.put(std::move(egs), egLablel);
}

putPuppi()

void L1TCorrelatorLayer1Producer::putPuppi ( edm::Event &  iEvent ) const

private

Definition at line 1060 of file L1TCorrelatorLayer1Producer.cc.

References l1t::PFCandidate::ChargedHadron, l1t::PFCandidate::Electron, event_, iEvent, EgHLTOffHistBins_cfi::mass, eostools::move(), l1t::PFCandidate::Muon, l1t::PFCandidate::NeutralHadron, EgHLTOffHistBins_cfi::nr, l1ct::Event::out, AlCaHLTBitMon_ParallelJobs::p, l1ct::Event::pfinputs, l1t::PFCandidate::Photon, and setRefs_().

Referenced by produce().

                                                                 {
  auto refprod = iEvent.getRefBeforePut<l1t::PFCandidateCollection>("Puppi");
  auto coll = std::make_unique<l1t::PFCandidateCollection>();
  auto reg = std::make_unique<l1t::PFCandidateRegionalOutput>(refprod);
  std::vector<int> nobj;
  for (unsigned int ir = 0, nr = event_.pfinputs.size(); ir < nr; ++ir) {
    nobj.clear();
    for (const auto &p : event_.out[ir].puppi) {
      if (p.hwPt == 0)
        continue;
      // note: Puppi candidates are already in global coordinates & fiducial-only!
      l1t::PFCandidate::ParticleType type;
      float mass = 0.13f;
      if (p.hwId.charged()) {
        if (p.hwId.isMuon()) {
          type = l1t::PFCandidate::Muon;
          mass = 0.105;
        } else if (p.hwId.isElectron()) {
          type = l1t::PFCandidate::Electron;
          mass = 0.005;
        } else
          type = l1t::PFCandidate::ChargedHadron;
      } else {
        type = p.hwId.isPhoton() ? l1t::PFCandidate::Photon : l1t::PFCandidate::NeutralHadron;
        mass = p.hwId.isPhoton() ? 0.0 : 0.5;
      }
      reco::Particle::PolarLorentzVector p4(p.floatPt(), p.floatEta(), p.floatPhi(), mass);
      coll->emplace_back(type, p.intCharge(), p4, p.floatPuppiW(), p.intPt(), p.intEta(), p.intPhi());
      if (p.hwId.charged()) {
        coll->back().setZ0(p.floatZ0());
        coll->back().setDxy(p.floatDxy());
        coll->back().setHwZ0(p.hwZ0());
        coll->back().setHwDxy(p.hwDxy());
        coll->back().setHwTkQuality(p.hwTkQuality());
      } else {
        coll->back().setHwPuppiWeight(p.hwPuppiW());
        coll->back().setHwEmID(p.hwEmID());
      }
      coll->back().setEncodedPuppi64(p.pack().to_uint64());
      setRefs_(coll->back(), p);
      nobj.push_back(coll->size() - 1);
    }
    reg->addRegion(nobj, event_.pfinputs[ir].region.floatEtaCenter(), event_.pfinputs[ir].region.floatPhiCenter());
  }
  iEvent.put(std::move(coll), "Puppi");
  iEvent.put(std::move(reg), "PuppiRegional");
}

rawHgcalClusterEncode()

template<class T >

void L1TCorrelatorLayer1Producer::rawHgcalClusterEncode ( ap_uint< 256 > &  cwrd, const l1ct::DetectorSector< T > &  sec, const l1t::PFCluster &  c  ) const

inlineprivate

Definition at line 122 of file L1TCorrelatorLayer1Producer.cc.

References DummyCfis::c, ALPAKA_ACCELERATOR_NAMESPACE::brokenline::constexpr(), l1ct::Scales::ETAPHI_LSB, M_PI, fileinputsource_cfi::sec, l1ct::Scales::SRRTOT_LSB, and l1ct::Scales::SRRTOT_SCALE.

Referenced by addDecodedHadCalo(), and addRawHgcalCluster().

                                                                                                                {
    cwrd = 0;
    ap_ufixed<14, 12, AP_RND_CONV, AP_SAT> w_pt = c.pt();
    ap_uint<14> w_empt = round(c.emEt() / 0.25);
    constexpr float ETAPHI_LSB = M_PI / 720;
    ap_int<9> w_eta = round(sec.region.localEta(c.eta()) / ETAPHI_LSB);
    ap_int<9> w_phi = round(sec.region.localPhi(c.phi()) / ETAPHI_LSB);
    ap_uint<10> w_qual = c.hwQual();
    // NOTE: this is an arbitrary choice to keep the rounding consistent with the "addDecodedHadCalo" one
    ap_uint<13> w_srrtot = round(c.sigmaRR() * l1ct::Scales::SRRTOT_SCALE / l1ct::Scales::SRRTOT_LSB);
    ap_uint<12> w_meanz = round(c.absZBarycenter());
    // NOTE: the calibration can actually make hoe become negative....we add a small protection for now
    // We use ap_ufixed to handle saturation and rounding
    ap_ufixed<10, 5, AP_RND_CONV, AP_SAT> w_hoe = c.hOverE();

    cwrd(13, 0) = w_pt.range();
    cwrd(27, 14) = w_empt;
    cwrd(72, 64) = w_eta;
    cwrd(81, 73) = w_phi;
    cwrd(115, 106) = w_qual;

    // FIXME: we add the variables use by composite-ID. The definitin will have to be reviewd once the
    // hgc format is better defined. For now we use
    // hwMeanZ = word 1 bits 30-19
    // hwSrrTot = word 3 bits 21 - 9
    // hoe = word 1 bits 63-52 (currently spare in the interface)
    cwrd(213, 201) = w_srrtot;
    cwrd(94, 83) = w_meanz;
    cwrd(127, 116) = w_hoe.range();
  }

setRefs_()

template<typename T >

void L1TCorrelatorLayer1Producer::setRefs_ ( l1t::PFCandidate &  pf, const T &  p  ) const

private

Definition at line 863 of file L1TCorrelatorLayer1Producer.cc.

References clusterRefMap_, Exception, match(), muonRefMap_, AlCaHLTBitMon_ParallelJobs::p, packedPFCandidateRefMixer_cfi::pf, and trackRefMap_.

Referenced by fetchEmCalo(), fetchHadCalo(), fetchPF(), fetchTracks(), and putPuppi().

                                                                               {
  if (p.srcCluster) {
    auto match = clusterRefMap_.find(p.srcCluster);
    if (match == clusterRefMap_.end()) {
      throw cms::Exception("CorruptData") << "Invalid cluster pointer in PF candidate id " << p.intId() << " pt "
                                          << p.floatPt() << " eta " << p.floatEta() << " phi " << p.floatPhi();
    }
    pf.setPFCluster(match->second);
  }
  if (p.srcTrack) {
    auto match = trackRefMap_.find(p.srcTrack);
    if (match == trackRefMap_.end()) {
      throw cms::Exception("CorruptData") << "Invalid track pointer in PF candidate id " << p.intId() << " pt "
                                          << p.floatPt() << " eta " << p.floatEta() << " phi " << p.floatPhi();
    }
    pf.setPFTrack(match->second);
  }
  if (p.srcMu) {
    auto match = muonRefMap_.find(p.srcMu);
    if (match == muonRefMap_.end()) {
      throw cms::Exception("CorruptData") << "Invalid muon pointer in PF candidate id " << p.intId() << " pt "
                                          << p.floatPt() << " eta " << p.floatEta() << " phi " << p.floatPhi();
    }
    pf.setMuon(match->second);
  }
}

totAndMax()

std::pair< unsigned int, unsigned int > L1TCorrelatorLayer1Producer::totAndMax ( const std::vector< unsigned > &  perRegion ) const

private

Definition at line 1250 of file L1TCorrelatorLayer1Producer.cc.

References SiStripPI::max, and ALPAKA_ACCELERATOR_NAMESPACE::caPixelDoublets::ntot.

Referenced by produce().

                                                {
  unsigned int ntot = 0, nmax = 0;
  for (unsigned ni : perRegion) {
    ntot += ni;
    nmax = std::max(nmax, ni);
  }
  return std::make_pair(ntot, nmax);
}

vecOutput()

std::unique_ptr< std::vector< unsigned > > L1TCorrelatorLayer1Producer::vecOutput ( OutputType  i, bool  usePuppi  ) const

private

Definition at line 1243 of file L1TCorrelatorLayer1Producer.cc.

References event_, mps_fire::i, l1ct::Event::out, and findQualityFiles::v.

Referenced by produce().

                                                                                                           {
  auto v = std::make_unique<std::vector<unsigned>>();
  for (const auto &reg : event_.out) {
    v->push_back(reg.nObj(i, usePuppi));
  }
  return v;
}

vecRegInput()

std::unique_ptr< std::vector< unsigned > > L1TCorrelatorLayer1Producer::vecRegInput ( InputType  i ) const

private

Definition at line 1222 of file L1TCorrelatorLayer1Producer.cc.

References caloType, emcaloType, event_, l1muType, l1ct::Event::pfinputs, submitPVValidationJobs::t, trackType, and findQualityFiles::v.

Referenced by produce().

                                                                                             {
  auto v = std::make_unique<std::vector<unsigned>>();
  for (const auto &reg : event_.pfinputs) {
    switch (t) {
      case caloType:
        v->push_back(reg.hadcalo.size());
        break;
      case emcaloType:
        v->push_back(reg.emcalo.size());
        break;
      case trackType:
        v->push_back(reg.track.size());
        break;
      case l1muType:
        v->push_back(reg.muon.size());
        break;
    }
  }
  return v;
}

vecSecInput()

std::unique_ptr< std::vector< unsigned > > L1TCorrelatorLayer1Producer::vecSecInput ( InputType  i ) const

private

Definition at line 1198 of file L1TCorrelatorLayer1Producer.cc.

References caloType, l1ct::Event::decoded, l1ct::RegionizerDecodedInputs::emcalo, emcaloType, event_, l1ct::RegionizerDecodedInputs::hadcalo, l1muType, l1ct::RegionizerDecodedInputs::muon, alignCSCRings::s, submitPVValidationJobs::t, l1ct::RegionizerDecodedInputs::track, trackType, and findQualityFiles::v.

Referenced by produce().

                                                                                             {
  auto v = std::make_unique<std::vector<unsigned>>();
  {
    switch (t) {
      case caloType:
        for (const auto &s : event_.decoded.hadcalo)
          v->push_back(s.size());
        break;
      case emcaloType:
        for (const auto &s : event_.decoded.emcalo)
          v->push_back(s.size());
        break;
      case trackType:
        for (const auto &s : event_.decoded.track)
          v->push_back(s.size());
        break;
      case l1muType:
        v->push_back(event_.decoded.muon.size());
        break;
    }
  }
  return v;
}

Member Data Documentation

clusterRefMap_

std::unordered_map<const l1t::PFCluster *, l1t::PFClusterRef> L1TCorrelatorLayer1Producer::clusterRefMap_

private

Definition at line 96 of file L1TCorrelatorLayer1Producer.cc.

Referenced by addEmCalo(), addHadCalo(), initEvent(), and setRefs_().

config_

edm::ParameterSet L1TCorrelatorLayer1Producer::config_

private

Definition at line 58 of file L1TCorrelatorLayer1Producer.cc.

debugEta_

float L1TCorrelatorLayer1Producer::debugEta_

private

Definition at line 93 of file L1TCorrelatorLayer1Producer.cc.

Referenced by produce().

debugPhi_

float L1TCorrelatorLayer1Producer::debugPhi_

private

Definition at line 93 of file L1TCorrelatorLayer1Producer.cc.

Referenced by produce().

debugR_

float L1TCorrelatorLayer1Producer::debugR_

private

Definition at line 93 of file L1TCorrelatorLayer1Producer.cc.

Referenced by produce().

emCands_

std::vector<edm::EDGetTokenT<l1t::PFClusterCollection> > L1TCorrelatorLayer1Producer::emCands_

private

Definition at line 70 of file L1TCorrelatorLayer1Producer.cc.

Referenced by L1TCorrelatorLayer1Producer(), and produce().

emPtCut_

float L1TCorrelatorLayer1Producer::emPtCut_

private

Definition at line 73 of file L1TCorrelatorLayer1Producer.cc.

Referenced by produce().

emuTkVtx_

bool L1TCorrelatorLayer1Producer::emuTkVtx_

private

Definition at line 63 of file L1TCorrelatorLayer1Producer.cc.

Referenced by L1TCorrelatorLayer1Producer(), and produce().

event_

l1ct::Event L1TCorrelatorLayer1Producer::event_

private

Definition at line 75 of file L1TCorrelatorLayer1Producer.cc.

Referenced by addEmCalo(), addHadCalo(), addMuon(), addTrack(), beginStream(), fetchDecodedTracks(), fetchEmCalo(), fetchHadCalo(), fetchPF(), fetchTracks(), initEvent(), initSectorsAndRegions(), produce(), putEgObjects(), putEgStaObjects(), putPuppi(), vecOutput(), vecRegInput(), and vecSecInput().

extTkVtx_

edm::EDGetTokenT<std::vector<l1t::Vertex> > L1TCorrelatorLayer1Producer::extTkVtx_

private

Definition at line 64 of file L1TCorrelatorLayer1Producer.cc.

Referenced by L1TCorrelatorLayer1Producer(), and produce().

fRegionDump_

std::fstream L1TCorrelatorLayer1Producer::fRegionDump_

private

Definition at line 88 of file L1TCorrelatorLayer1Producer.cc.

Referenced by beginStream(), and produce().

hadCands_

std::vector<edm::EDGetTokenT<l1t::PFClusterCollection> > L1TCorrelatorLayer1Producer::hadCands_

private

Definition at line 71 of file L1TCorrelatorLayer1Producer.cc.

Referenced by L1TCorrelatorLayer1Producer(), and produce().

hadPtCut_

float L1TCorrelatorLayer1Producer::hadPtCut_

private

Definition at line 73 of file L1TCorrelatorLayer1Producer.cc.

Referenced by produce().

hasTracks_

bool L1TCorrelatorLayer1Producer::hasTracks_

private

Definition at line 60 of file L1TCorrelatorLayer1Producer.cc.

Referenced by L1TCorrelatorLayer1Producer(), and produce().

hgcalInput_

std::unique_ptr<l1ct::HgcalClusterDecoderEmulator> L1TCorrelatorLayer1Producer::hgcalInput_

private

Definition at line 78 of file L1TCorrelatorLayer1Producer.cc.

Referenced by addDecodedHadCalo(), and L1TCorrelatorLayer1Producer().

inputTypeName

constexpr const char* L1TCorrelatorLayer1Producer::inputTypeName[l1muType+1] = {"Calo", "EmCalo", "TK", "Mu"}

staticprivate

Definition at line 175 of file L1TCorrelatorLayer1Producer.cc.

Referenced by L1TCorrelatorLayer1Producer(), and produce().

l1pfalgo_

std::unique_ptr<l1ct::PFAlgoEmulatorBase> L1TCorrelatorLayer1Producer::l1pfalgo_

private

Definition at line 80 of file L1TCorrelatorLayer1Producer.cc.

Referenced by L1TCorrelatorLayer1Producer(), and produce().

l1pualgo_

std::unique_ptr<l1ct::LinPuppiEmulator> L1TCorrelatorLayer1Producer::l1pualgo_

private

Definition at line 81 of file L1TCorrelatorLayer1Producer.cc.

Referenced by L1TCorrelatorLayer1Producer(), and produce().

l1tkegalgo_

std::unique_ptr<l1ct::PFTkEGAlgoEmulator> L1TCorrelatorLayer1Producer::l1tkegalgo_

private

Definition at line 82 of file L1TCorrelatorLayer1Producer.cc.

Referenced by L1TCorrelatorLayer1Producer(), and produce().

l1tkegsorter_

std::unique_ptr<l1ct::PFTkEGSorterEmulator> L1TCorrelatorLayer1Producer::l1tkegsorter_

private

Definition at line 83 of file L1TCorrelatorLayer1Producer.cc.

Referenced by L1TCorrelatorLayer1Producer(), and produce().

muCands_

edm::EDGetTokenT<l1t::SAMuonCollection> L1TCorrelatorLayer1Producer::muCands_

private

Definition at line 68 of file L1TCorrelatorLayer1Producer.cc.

Referenced by produce().

muonInput_

std::unique_ptr<l1ct::GMTMuonDecoderEmulator> L1TCorrelatorLayer1Producer::muonInput_

private

Definition at line 77 of file L1TCorrelatorLayer1Producer.cc.

Referenced by addDecodedMuon(), and L1TCorrelatorLayer1Producer().

muonRefMap_

std::unordered_map<const l1t::SAMuon *, l1t::PFCandidate::MuonRef> L1TCorrelatorLayer1Producer::muonRefMap_

private

Definition at line 98 of file L1TCorrelatorLayer1Producer.cc.

Referenced by addMuon(), initEvent(), and setRefs_().

nVtx_

int L1TCorrelatorLayer1Producer::nVtx_

private

Definition at line 66 of file L1TCorrelatorLayer1Producer.cc.

Referenced by L1TCorrelatorLayer1Producer(), and produce().

patternWriterConfigs_

const edm::VParameterSet L1TCorrelatorLayer1Producer::patternWriterConfigs_

private

Definition at line 89 of file L1TCorrelatorLayer1Producer.cc.

Referenced by beginStream().

patternWriters_

std::vector<std::unique_ptr<L1TCorrelatorLayer1PatternFileWriter> > L1TCorrelatorLayer1Producer::patternWriters_

private

Definition at line 90 of file L1TCorrelatorLayer1Producer.cc.

Referenced by beginStream(), endStream(), and produce().

regionDumpName_

const std::string L1TCorrelatorLayer1Producer::regionDumpName_

private

Definition at line 86 of file L1TCorrelatorLayer1Producer.cc.

Referenced by beginStream().

regionizer_

std::unique_ptr<l1ct::RegionizerEmulator> L1TCorrelatorLayer1Producer::regionizer_

private

Definition at line 79 of file L1TCorrelatorLayer1Producer.cc.

Referenced by L1TCorrelatorLayer1Producer(), and produce().

tkCands_

edm::EDGetTokenT<l1t::PFTrackCollection> L1TCorrelatorLayer1Producer::tkCands_

private

Definition at line 61 of file L1TCorrelatorLayer1Producer.cc.

Referenced by produce().

tkVtxEmu_

edm::EDGetTokenT<std::vector<l1t::VertexWord> > L1TCorrelatorLayer1Producer::tkVtxEmu_

private

Definition at line 65 of file L1TCorrelatorLayer1Producer.cc.

Referenced by L1TCorrelatorLayer1Producer(), and produce().

trackInput_

std::unique_ptr<l1ct::TrackInputEmulator> L1TCorrelatorLayer1Producer::trackInput_

private

Definition at line 76 of file L1TCorrelatorLayer1Producer.cc.

Referenced by addDecodedTrack(), and L1TCorrelatorLayer1Producer().

trackRefMap_

std::unordered_map<const l1t::PFTrack *, l1t::PFTrackRef> L1TCorrelatorLayer1Producer::trackRefMap_

private

Definition at line 97 of file L1TCorrelatorLayer1Producer.cc.

Referenced by addTrack(), initEvent(), and setRefs_().

trkPt_

float L1TCorrelatorLayer1Producer::trkPt_

private

Definition at line 62 of file L1TCorrelatorLayer1Producer.cc.

Referenced by produce().

writeRawHgcalCluster_

bool L1TCorrelatorLayer1Producer::writeRawHgcalCluster_

private

Definition at line 87 of file L1TCorrelatorLayer1Producer.cc.

Referenced by addHadCalo().