File indexing completed on 2024-09-24 22:51:27
0001
0002
0003
0004
0005
0006
0007
0008
0009
0010
0011
0012
0013
0014
0015
0016
0017
0018
0019
0020
0021
0022
0023
0024
0025
0026
0027
0028
0029
0030
0031
0032
0033
0034
0035
0036
0037
0038 #include <iostream>
0039 #include <vector>
0040 #include <cmath>
0041
0042 #include "boost/property_tree/ptree.hpp"
0043 #include "boost/property_tree/json_parser.hpp"
0044
0045 #include "ap_int.h"
0046 #include "ap_fixed.h"
0047
0048
0049 #include "FWCore/Framework/interface/Frameworkfwd.h"
0050 #include "FWCore/Framework/interface/stream/EDProducer.h"
0051 #include "FWCore/ParameterSet/interface/ParameterSet.h"
0052 #include "FWCore/ParameterSet/interface/ParameterSetDescription.h"
0053 #include "FWCore/ServiceRegistry/interface/Service.h"
0054 #include "FWCore/Framework/interface/Event.h"
0055 #include "FWCore/Framework/interface/ESHandle.h"
0056 #include "FWCore/Framework/interface/MakerMacros.h"
0057 #include "FWCore/MessageLogger/interface/MessageLogger.h"
0058
0059 #include "DataFormats/L1TCalorimeterPhase2/interface/CaloTower.h"
0060 #include "DataFormats/HcalDigi/interface/HcalDigiCollections.h"
0061 #include "DataFormats/L1THGCal/interface/HGCalMulticluster.h"
0062 #include "DataFormats/L1TParticleFlow/interface/PFCluster.h"
0063 #include "DataFormats/L1THGCal/interface/HGCalTower.h"
0064 #include "DataFormats/Math/interface/deltaPhi.h"
0065 #include "DataFormats/L1Trigger/interface/Tau.h"
0066
0067 #include "CalibFormats/CaloTPG/interface/CaloTPGTranscoder.h"
0068 #include "CalibFormats/CaloTPG/interface/CaloTPGRecord.h"
0069
0070 #include "L1Trigger/L1THGCal/interface/backend/HGCalTriggerClusterIdentificationBase.h"
0071 #include "L1Trigger/Phase2L1ParticleFlow/interface/HGC3DClusterEgID.h"
0072 #include "L1Trigger/L1TCalorimeter/interface/CaloTools.h"
0073
0074 #include "PhysicsTools/TensorFlow/interface/TensorFlow.h"
0075
0076 struct NNmodels_GlobalCache {
0077 std::string CNNmodel_CB_path;
0078 std::string DNNident_CB_path;
0079 std::string DNNcalib_CB_path;
0080
0081 std::string CNNmodel_CE_path;
0082 std::string DNNident_CE_path;
0083 std::string DNNcalib_CE_path;
0084 std::string FeatScaler_CE_path;
0085 boost::property_tree::ptree FeatScaler_CE;
0086
0087 tensorflow::GraphDef* CNNmodel_CB;
0088 tensorflow::GraphDef* DNNident_CB;
0089 tensorflow::GraphDef* DNNcalib_CB;
0090
0091 tensorflow::Session* CNNmodel_CBsession;
0092 tensorflow::Session* DNNident_CBsession;
0093 tensorflow::Session* DNNcalib_CBsession;
0094
0095 tensorflow::GraphDef* CNNmodel_CE;
0096 tensorflow::GraphDef* DNNident_CE;
0097 tensorflow::GraphDef* DNNcalib_CE;
0098
0099 tensorflow::Session* CNNmodel_CEsession;
0100 tensorflow::Session* DNNident_CEsession;
0101 tensorflow::Session* DNNcalib_CEsession;
0102 };
0103
0104 class L1NNCaloTauEmulator : public edm::stream::EDProducer<edm::GlobalCache<NNmodels_GlobalCache>> {
0105 public:
0106 explicit L1NNCaloTauEmulator(const edm::ParameterSet&, const NNmodels_GlobalCache*);
0107
0108 static void fillDescriptions(edm::ConfigurationDescriptions& descriptions);
0109 static std::unique_ptr<NNmodels_GlobalCache> initializeGlobalCache(const edm::ParameterSet&);
0110 static void globalEndJob(const NNmodels_GlobalCache*) { }
0111
0112 private:
0113
0114 static constexpr int INTPHI_PI = 36;
0115 static constexpr int INTPHI_2PI = 2 * INTPHI_PI;
0116 static constexpr float IETAPHI_LSB = M_PI / INTPHI_PI;
0117
0118 static constexpr int FINEINTPHI_PI = 720;
0119 static constexpr int FINEINTPHI_2PI = 2 * FINEINTPHI_PI;
0120 static constexpr float ETAPHI_LSB = M_PI / FINEINTPHI_PI;
0121
0122 static constexpr float SHAPEFEAT_LSB = 0.0000153;
0123 static constexpr float SZZ_LSB = SHAPEFEAT_LSB * 100;
0124 static constexpr float ETAHGCAL_OFFSET = 1.321;
0125 static constexpr float IETAHGCAL_LSBp = 0.0808;
0126 static constexpr float IETAHGCAL_LSB = 0.0845;
0127 static constexpr float PUID_LSB = 0.00390625;
0128 static constexpr float MEANZ_OFFSET = 321.05;
0129 static constexpr int IETAHGCAL_OFFSET = 17;
0130 static constexpr float MEANZ_LSB = 0.5;
0131 static constexpr float PTET_LSB = 0.25;
0132 static constexpr float CM2MM = 10;
0133 static constexpr int R2cone = 0.25 / ETAPHI_LSB / ETAPHI_LSB;
0134
0135 static constexpr int SHAPEFEAT_W = 16;
0136 static constexpr int DETAPHI_W = 12;
0137 static constexpr int DIETAPHI_W = 8;
0138 static constexpr int IETAPHI_W = 7;
0139 static constexpr int SHOWLEN_W = 6;
0140 static constexpr int ETAPHI_W = 11;
0141 static constexpr int MEANZ_W = 12;
0142 static constexpr int PUID_W = 9;
0143
0144 static constexpr int PT_W = 14;
0145 static constexpr int PT_I = 12;
0146 static constexpr int ET_W = 10;
0147 static constexpr int ET_I = 8;
0148
0149
0150 static constexpr int CALIBPT_W = 10;
0151 static constexpr int CALIBPT_I = 9;
0152 static constexpr int ID_W = 8;
0153 static constexpr int ID_I = 1;
0154
0155 typedef ap_ufixed<PT_W, PT_I, AP_TRN, AP_SAT> Pt_t;
0156 typedef ap_ufixed<ET_W, ET_I, AP_TRN, AP_SAT> Et_t;
0157
0158 typedef ap_ufixed<CALIBPT_W, CALIBPT_I, AP_TRN, AP_SAT> CalibPt_t;
0159 typedef ap_ufixed<ID_W, ID_I, AP_TRN, AP_SAT> Id_t;
0160
0161 typedef ap_uint<SHAPEFEAT_W> ShapeFeat_t;
0162 typedef ap_int<DIETAPHI_W> dIEtaPhi_t;
0163 typedef ap_int<DETAPHI_W> dEtaPhi_t;
0164 typedef ap_uint<SHOWLEN_W> ShowLen_t;
0165 typedef ap_int<ETAPHI_W> EtaPhi_t;
0166 typedef ap_uint<IETAPHI_W> IPhi_t;
0167 typedef ap_int<IETAPHI_W> IEta_t;
0168 typedef ap_uint<MEANZ_W> Meanz_t;
0169 typedef ap_int<PUID_W> PUid_t;
0170
0171
0172 const int seedIdx = 22;
0173 const int IEta_dim = 5;
0174 const int IPhi_dim = 9;
0175 const int Eta_limit = 33;
0176
0177
0178 void produce(edm::Event&, const edm::EventSetup&) override;
0179
0180
0181 template <class outPrecision, class inPrecision>
0182 outPrecision dPhi(inPrecision iPhi_1, inPrecision iPhi_2);
0183 dIEtaPhi_t tower_dIEta(IEta_t iEta_1, IEta_t iEta_2);
0184 dEtaPhi_t tw2cl_dPhi(EtaPhi_t iPhi_1, IPhi_t iPhi_2);
0185 dEtaPhi_t tw2cl_dEta(EtaPhi_t iEta_1, IEta_t iEta_2);
0186 IEta_t makeEndcapHwIEta(float eta);
0187 IPhi_t makeEndcapHwIPhi(float phi);
0188 float apfixedQuantizer(float inputF, float LSB, int nbits);
0189 int apintQuantizer(float inputF, float LSB, int nbits);
0190 float inputScaler(float inputF, std::string feature);
0191 float correctInputEtaCl3d(float eta);
0192 float correctInputMeanzCl3d(float meanz);
0193
0194 inline float floatPt(Pt_t pt) { return pt.to_float(); }
0195 inline float floatEt(Et_t et) { return et.to_float(); }
0196 inline float floatEta(EtaPhi_t eta) { return eta.to_float() * ETAPHI_LSB; }
0197 inline float floatPhi(EtaPhi_t phi) { return phi.to_float() * ETAPHI_LSB; }
0198 inline float floatShape(ShapeFeat_t shape) { return shape.to_float() * SHAPEFEAT_LSB; };
0199 inline float floatSzz(ShapeFeat_t szz) { return szz.to_float() * SZZ_LSB; };
0200 inline float floatMeanZ(Meanz_t meanz) { return meanz.to_float() * MEANZ_LSB + MEANZ_OFFSET; };
0201 inline float floatMeanZHgcalCoord(Meanz_t meanz) { return meanz.to_float() * MEANZ_LSB; };
0202 inline float floatPuId(PUid_t pu) { return pu.to_float() * PUID_LSB; };
0203 float floatIEta(IEta_t eta);
0204 float floatIPhi(IPhi_t phi);
0205
0206 template <int W>
0207 ap_int<W> ap_abs(ap_int<W> x);
0208 template <int W, int I, ap_q_mode _AP_Q, ap_o_mode _AP_O>
0209 ap_ufixed<W, I> ap_abs(ap_fixed<W, I, _AP_Q, _AP_O> x);
0210
0211
0212 edm::EDGetTokenT<l1tp2::CaloTowerCollection> l1TowersToken;
0213 edm::Handle<l1tp2::CaloTowerCollection> l1CaloTowerHandle;
0214
0215 edm::EDGetToken hgcalTowersToken;
0216 edm::Handle<l1t::HGCalTowerBxCollection> hgcalTowersHandle;
0217
0218 edm::EDGetTokenT<l1t::HGCalMulticlusterBxCollection> HGClusterToken;
0219 edm::Handle<l1t::HGCalMulticlusterBxCollection> HGClusterHandle;
0220
0221
0222 enum class UseEmInterp { No, EmOnly, AllKeepHad, AllKeepTot };
0223 UseEmInterp scenario;
0224 StringCutObjectSelector<l1t::HGCalMulticluster> preEmId;
0225 l1tpf::HGC3DClusterEgID VsPuId;
0226
0227 double EcalEtMinForClustering;
0228 double HcalEtMinForClustering;
0229 double EtMinForSeeding;
0230 double EtaRestriction;
0231 double CB_CE_split;
0232 double PuidThr;
0233
0234 double IdWp90_CB;
0235 double IdWp95_CB;
0236 double IdWp99_CB;
0237
0238 double IdWp90_CE;
0239 double IdWp95_CE;
0240 double IdWp99_CE;
0241
0242 PUid_t intPuidThr;
0243 IEta_t intEtaRestriction;
0244 IEta_t intCB_CE_split;
0245
0246 bool DEBUG;
0247
0248
0249 class SimpleTowerHit {
0250 public:
0251 IEta_t towerIeta = 0;
0252 IPhi_t towerIphi = 0;
0253 Et_t towerEm = 0.;
0254 Et_t towerHad = 0.;
0255 Et_t l1egTowerEt = 0.;
0256 Et_t towerEt = 0.;
0257 ap_uint<1> isBarrel = 0x1;
0258 ap_uint<1> stale = 0x0;
0259 ap_uint<1> stale4seed = 0x0;
0260 };
0261
0262
0263 class SimpleHGCluster {
0264 public:
0265 Pt_t pt;
0266 EtaPhi_t eta;
0267 EtaPhi_t phi;
0268 ShowLen_t showerlength;
0269 ShowLen_t coreshowerlength;
0270 ShapeFeat_t spptot;
0271 ShapeFeat_t szz;
0272 ShapeFeat_t srrtot;
0273 Meanz_t meanz;
0274 PUid_t PUid;
0275 ap_uint<1> stale = 0x0;
0276 };
0277
0278
0279 class SimplifiedTower {
0280 public:
0281 Et_t towerEm = 0.;
0282 Et_t towerHad = 0.;
0283 Et_t l1egTowerEt = 0.;
0284
0285 void fill(SimpleTowerHit Tower) {
0286 towerEm = Tower.towerEm;
0287 towerHad = Tower.towerHad;
0288 l1egTowerEt = Tower.l1egTowerEt;
0289 }
0290 };
0291
0292 class InputTowerCluster {
0293 public:
0294 SimplifiedTower towerHits[45];
0295 ap_uint<1> barrelSeeded = 0x0;
0296 ap_uint<1> filled[45];
0297
0298 void fill(int idx, SimpleTowerHit Tower) {
0299 towerHits[idx].fill(Tower);
0300 filled[idx] = 0x1;
0301 }
0302
0303 void init() {
0304 SimplifiedTower emptyT;
0305 std::fill(towerHits, towerHits + 44, emptyT);
0306 std::fill(filled, filled + 44, 0x0);
0307 }
0308 };
0309
0310 class InputTowerCluster_pstn {
0311 public:
0312 IEta_t seedIeta = 0;
0313 IPhi_t seedIphi = 0;
0314
0315 void fill(SimpleTowerHit Tower) {
0316 seedIeta = Tower.towerIeta;
0317 seedIphi = Tower.towerIphi;
0318 }
0319 };
0320
0321
0322
0323
0324 class InputHGCluster {
0325 public:
0326 Pt_t pt;
0327 EtaPhi_t eta;
0328 ShowLen_t showerlength;
0329 ShowLen_t coreshowerlength;
0330 ShapeFeat_t spptot;
0331 ShapeFeat_t szz;
0332 ShapeFeat_t srrtot;
0333 Meanz_t meanz;
0334
0335 void fill(SimpleHGCluster Cluster) {
0336 pt = Cluster.pt;
0337 eta = Cluster.eta;
0338 showerlength = Cluster.showerlength;
0339 coreshowerlength = Cluster.coreshowerlength;
0340 spptot = Cluster.spptot;
0341 szz = Cluster.szz;
0342 srrtot = Cluster.srrtot;
0343 meanz = Cluster.meanz;
0344 }
0345 };
0346
0347 l1t::Tau MakeTauCandidate(bool isBarrel,
0348 int clNxMIdx,
0349 std::vector<tensorflow::Tensor> outputsIdent,
0350 std::vector<tensorflow::Tensor> outputsCalib,
0351 std::vector<InputTowerCluster_pstn> clustersNxM_pstn);
0352 };
0353
0354
0355
0356
0357
0358
0359
0360
0361
0362 std::unique_ptr<NNmodels_GlobalCache> L1NNCaloTauEmulator::initializeGlobalCache(const edm::ParameterSet& iConfig) {
0363 edm::LogInfo("Initialization") << "Init NN models Global Cache " << std::endl;
0364
0365 std::unique_ptr<NNmodels_GlobalCache> GlobalCache(new NNmodels_GlobalCache);
0366
0367 GlobalCache->CNNmodel_CB_path = iConfig.getParameter<std::string>("CNNmodel_CB_path");
0368 GlobalCache->DNNident_CB_path = iConfig.getParameter<std::string>("DNNident_CB_path");
0369 GlobalCache->DNNcalib_CB_path = iConfig.getParameter<std::string>("DNNcalib_CB_path");
0370 GlobalCache->CNNmodel_CE_path = iConfig.getParameter<std::string>("CNNmodel_CE_path");
0371 GlobalCache->DNNident_CE_path = iConfig.getParameter<std::string>("DNNident_CE_path");
0372 GlobalCache->DNNcalib_CE_path = iConfig.getParameter<std::string>("DNNcalib_CE_path");
0373 GlobalCache->FeatScaler_CE_path = iConfig.getParameter<std::string>("FeatScaler_CE_path");
0374
0375
0376 (GlobalCache->CNNmodel_CB) = tensorflow::loadGraphDef(edm::FileInPath((GlobalCache->CNNmodel_CB_path)).fullPath());
0377 (GlobalCache->CNNmodel_CBsession) = tensorflow::createSession((GlobalCache->CNNmodel_CB));
0378
0379 (GlobalCache->DNNident_CB) = tensorflow::loadGraphDef(edm::FileInPath((GlobalCache->DNNident_CB_path)).fullPath());
0380 (GlobalCache->DNNident_CBsession) = tensorflow::createSession((GlobalCache->DNNident_CB));
0381
0382 (GlobalCache->DNNcalib_CB) = tensorflow::loadGraphDef(edm::FileInPath((GlobalCache->DNNcalib_CB_path)).fullPath());
0383 (GlobalCache->DNNcalib_CBsession) = tensorflow::createSession((GlobalCache->DNNcalib_CB));
0384
0385 (GlobalCache->CNNmodel_CE) = tensorflow::loadGraphDef(edm::FileInPath((GlobalCache->CNNmodel_CE_path)).fullPath());
0386 (GlobalCache->CNNmodel_CEsession) = tensorflow::createSession((GlobalCache->CNNmodel_CE));
0387
0388 (GlobalCache->DNNident_CE) = tensorflow::loadGraphDef(edm::FileInPath((GlobalCache->DNNident_CE_path)).fullPath());
0389 (GlobalCache->DNNident_CEsession) = tensorflow::createSession((GlobalCache->DNNident_CE));
0390
0391 (GlobalCache->DNNcalib_CE) = tensorflow::loadGraphDef(edm::FileInPath((GlobalCache->DNNcalib_CE_path)).fullPath());
0392 (GlobalCache->DNNcalib_CEsession) = tensorflow::createSession((GlobalCache->DNNcalib_CE));
0393
0394
0395 boost::property_tree::read_json(edm::FileInPath((GlobalCache->FeatScaler_CE_path)).fullPath(),
0396 (GlobalCache->FeatScaler_CE));
0397
0398 return GlobalCache;
0399 }
0400
0401
0402 L1NNCaloTauEmulator::L1NNCaloTauEmulator(const edm::ParameterSet& iConfig, const NNmodels_GlobalCache* globalCache)
0403 : l1TowersToken(consumes<l1tp2::CaloTowerCollection>(iConfig.getParameter<edm::InputTag>("l1CaloTowers"))),
0404 hgcalTowersToken(consumes<l1t::HGCalTowerBxCollection>(iConfig.getParameter<edm::InputTag>("hgcalTowers"))),
0405
0406 HGClusterToken(
0407 consumes<l1t::HGCalMulticlusterBxCollection>(iConfig.getParameter<edm::InputTag>("HgcalClusters"))),
0408 scenario(UseEmInterp::No),
0409 preEmId(iConfig.getParameter<std::string>("preEmId")),
0410 VsPuId(iConfig.getParameter<edm::ParameterSet>("VsPuId")),
0411
0412 EcalEtMinForClustering(iConfig.getParameter<double>("EcalEtMinForClustering")),
0413 HcalEtMinForClustering(iConfig.getParameter<double>("HcalEtMinForClustering")),
0414 EtMinForSeeding(iConfig.getParameter<double>("EtMinForSeeding")),
0415 EtaRestriction(iConfig.getParameter<double>("EtaRestriction")),
0416 CB_CE_split(iConfig.getParameter<double>("CB_CE_split")),
0417 PuidThr(iConfig.getParameter<double>("PuidThr")),
0418
0419 IdWp90_CB(iConfig.getParameter<double>("IdWp90_CB")),
0420 IdWp95_CB(iConfig.getParameter<double>("IdWp95_CB")),
0421 IdWp99_CB(iConfig.getParameter<double>("IdWp99_CB")),
0422
0423 IdWp90_CE(iConfig.getParameter<double>("IdWp90_CE")),
0424 IdWp95_CE(iConfig.getParameter<double>("IdWp95_CE")),
0425 IdWp99_CE(iConfig.getParameter<double>("IdWp99_CE")),
0426
0427 DEBUG(iConfig.getParameter<bool>("DEBUG")) {
0428
0429 if (!VsPuId.method().empty()) {
0430 VsPuId.prepareTMVA();
0431 }
0432
0433 intPuidThr = apintQuantizer(PuidThr, PUID_LSB, PUID_W);
0434 intEtaRestriction = apintQuantizer(EtaRestriction, IETAPHI_LSB, IETAPHI_W);
0435 intCB_CE_split = apintQuantizer(CB_CE_split, IETAPHI_LSB, IETAPHI_W) + 1;
0436
0437
0438 produces<BXVector<l1t::Tau>>("L1NNCaloTauCollectionBXV");
0439
0440
0441 edm::LogInfo("Settings") << "EtaRestriction = " << EtaRestriction << " (" << intEtaRestriction << ")"
0442 << " , CB_CE_split = " << CB_CE_split << "(" << intCB_CE_split
0443 << ") , EtMinForSeeding = " << EtMinForSeeding
0444 << " , HcalTpEtMin = " << HcalEtMinForClustering
0445 << " , EcalTpEtMin = " << EcalEtMinForClustering << " , PuidThr = " << PuidThr << "("
0446 << intPuidThr << ")" << std::endl;
0447 }
0448
0449 void L1NNCaloTauEmulator::produce(edm::Event& iEvent, const edm::EventSetup& eSetup) {
0450
0451 std::unique_ptr<BXVector<l1t::Tau>> L1NNCaloTauCollectionBXV(new l1t::TauBxCollection);
0452
0453
0454 std::vector<SimpleTowerHit> l1CaloTowers;
0455
0456 iEvent.getByToken(l1TowersToken, l1CaloTowerHandle);
0457 int warnings = 0;
0458 for (auto& hit : *l1CaloTowerHandle.product()) {
0459
0460 if (hit.towerIEta() == -1016 && hit.towerIPhi() == -962) {
0461 warnings += 1;
0462 continue;
0463 }
0464
0465 SimpleTowerHit l1Hit;
0466 l1Hit.isBarrel = 0x1;
0467 l1Hit.l1egTowerEt = apfixedQuantizer(hit.l1egTowerEt(), PTET_LSB, ET_W);
0468 l1Hit.towerEm = apfixedQuantizer(hit.ecalTowerEt(), PTET_LSB, ET_W);
0469 l1Hit.towerHad = apfixedQuantizer(hit.hcalTowerEt(), PTET_LSB, ET_W);
0470 l1Hit.towerEt = apfixedQuantizer(hit.ecalTowerEt() + hit.hcalTowerEt() + hit.l1egTowerEt(), PTET_LSB, ET_W);
0471 l1Hit.towerIeta = hit.towerIEta();
0472 l1Hit.towerIphi = hit.towerIPhi();
0473
0474 l1CaloTowers.push_back(l1Hit);
0475 }
0476 if (warnings != 0 && DEBUG) {
0477 edm::LogWarning("BrokenTowers") << " ** WARNING : FOUND " << warnings
0478 << " TOWERS WITH towerIeta=-1016 AND towerIphi=-962" << std::endl;
0479 }
0480
0481 iEvent.getByToken(hgcalTowersToken, hgcalTowersHandle);
0482 for (auto& hit : *hgcalTowersHandle.product()) {
0483 SimpleTowerHit l1Hit;
0484 l1Hit.isBarrel = 0x0;
0485 l1Hit.l1egTowerEt = 0.0;
0486 l1Hit.towerEm = apfixedQuantizer(hit.etEm(), PTET_LSB, ET_W);
0487 l1Hit.towerHad = apfixedQuantizer(hit.etHad(), PTET_LSB, ET_W);
0488 l1Hit.towerEt = apfixedQuantizer(hit.etEm() + hit.etHad(), PTET_LSB, ET_W);
0489 l1Hit.towerIeta = makeEndcapHwIEta(hit.eta());
0490 l1Hit.towerIphi = makeEndcapHwIPhi(hit.phi());
0491
0492 l1CaloTowers.push_back(l1Hit);
0493 }
0494
0495
0496 std::sort(begin(l1CaloTowers), end(l1CaloTowers), [](const SimpleTowerHit& a, SimpleTowerHit& b) {
0497 return a.towerEt > b.towerEt;
0498 });
0499
0500
0501 std::vector<SimpleHGCluster> AllHGClusters;
0502 iEvent.getByToken(HGClusterToken, HGClusterHandle);
0503
0504 for (auto cl3dIt = HGClusterHandle->begin(0); cl3dIt != HGClusterHandle->end(0); ++cl3dIt) {
0505 auto& cl3d = *cl3dIt;
0506
0507
0508
0509 bool isEM = preEmId(*cl3dIt);
0510 l1t::PFCluster cluster(cl3d.pt(), cl3d.eta(), cl3d.phi(), cl3d.hOverE());
0511 if (scenario == UseEmInterp::EmOnly)
0512 {
0513 if (isEM) {
0514 float pt_new = cl3d.iPt(l1t::HGCalMulticluster::EnergyInterpretation::EM);
0515 float hoe_new = 0.;
0516 cluster = l1t::PFCluster(pt_new, cl3d.eta(), cl3d.phi(), hoe_new, isEM);
0517 }
0518 } else if (scenario == UseEmInterp::AllKeepHad)
0519 {
0520 float had_old = cl3d.pt() - cluster.emEt();
0521 float em_new = cl3d.iPt(l1t::HGCalMulticluster::EnergyInterpretation::EM);
0522 float pt_new = had_old + em_new;
0523 float hoe_new = em_new > 0 ? (had_old / em_new) : -1;
0524 cluster = l1t::PFCluster(pt_new, cl3d.eta(), cl3d.phi(), hoe_new, isEM);
0525 } else if (scenario == UseEmInterp::AllKeepTot)
0526 {
0527 float em_new = cl3d.iPt(l1t::HGCalMulticluster::EnergyInterpretation::EM);
0528 float hoe_new = em_new > 0 ? (cl3d.pt() / em_new - 1) : -1;
0529 cluster = l1t::PFCluster(cl3d.pt(), cl3d.eta(), cl3d.phi(), hoe_new, isEM);
0530 }
0531
0532 float idScore = -1.;
0533 if (!VsPuId.method().empty()) {
0534 idScore = VsPuId.passID(*cl3dIt, cluster);
0535 idScore = cluster.egVsPUMVAOut();
0536 }
0537
0538 float eta_hgcalCoord = correctInputEtaCl3d(cl3d.eta());
0539 float meanz_hgcalCoord = correctInputMeanzCl3d(cl3d.zBarycenter());
0540
0541 SimpleHGCluster HGCluster;
0542 HGCluster.pt = apfixedQuantizer(cl3d.pt(), PTET_LSB, PT_W);
0543 HGCluster.eta = apintQuantizer(eta_hgcalCoord, ETAPHI_LSB, ETAPHI_W);
0544 HGCluster.phi = apintQuantizer(cl3d.phi(), ETAPHI_LSB, ETAPHI_W);
0545 HGCluster.showerlength = cl3d.showerLength();
0546 HGCluster.coreshowerlength = cl3d.coreShowerLength();
0547 HGCluster.spptot = apintQuantizer(cl3d.sigmaPhiPhiTot(), SHAPEFEAT_LSB, SHAPEFEAT_W);
0548 HGCluster.szz = apintQuantizer(cl3d.sigmaZZ(), SZZ_LSB, SHAPEFEAT_W);
0549 HGCluster.srrtot = apintQuantizer(cl3d.sigmaRRTot(), SHAPEFEAT_LSB, SHAPEFEAT_W);
0550 HGCluster.meanz = apintQuantizer(meanz_hgcalCoord, MEANZ_LSB, MEANZ_W);
0551 HGCluster.PUid = apintQuantizer(idScore, PUID_LSB, PUID_W);
0552
0553 AllHGClusters.push_back(HGCluster);
0554 }
0555
0556
0557 std::sort(begin(AllHGClusters), end(AllHGClusters), [](const SimpleHGCluster& a, SimpleHGCluster& b) {
0558 return a.pt > b.pt;
0559 });
0560
0561
0562
0563
0564
0565
0566
0567
0568
0569 std::vector<InputTowerCluster> l1TowerClustersNxM_CB;
0570 std::vector<InputTowerCluster_pstn> l1TowerClustersNxM_CB_pstn;
0571 std::vector<InputTowerCluster> l1TowerClustersNxM_CE;
0572 std::vector<InputTowerCluster_pstn> l1TowerClustersNxM_CE_pstn;
0573 std::vector<InputHGCluster> HGClusters;
0574
0575
0576 std::vector<InputTowerCluster> AllL1TowerClustersNxM_CE;
0577 std::vector<InputTowerCluster_pstn> AllL1TowerClustersNxM_CE_pstn;
0578
0579 int Nclusters_CB = 0;
0580 int AllNclusters_CE = 0;
0581 bool caloTauSeedingFinished = false;
0582
0583 while (!caloTauSeedingFinished) {
0584 InputTowerCluster clNxM;
0585 clNxM.init();
0586 InputTowerCluster_pstn clNxM_pstn;
0587 bool seeded = false;
0588
0589 for (auto& l1CaloTower : l1CaloTowers) {
0590
0591
0592 if (ap_abs(l1CaloTower.towerIeta) > Eta_limit || ap_abs(l1CaloTower.towerIeta) > intEtaRestriction ||
0593 l1CaloTower.stale4seed) {
0594 continue;
0595 }
0596
0597
0598 if (!seeded) {
0599
0600 if (l1CaloTower.towerEt < EtMinForSeeding) {
0601 caloTauSeedingFinished = true;
0602 continue;
0603 }
0604
0605 clNxM.fill(seedIdx, l1CaloTower);
0606 clNxM_pstn.fill(l1CaloTower);
0607 if (l1CaloTower.isBarrel) {
0608 clNxM.barrelSeeded = 0x1;
0609 }
0610
0611 l1CaloTower.stale4seed = 0x1;
0612 l1CaloTower.stale = 0x1;
0613 seeded = true;
0614
0615 continue;
0616 }
0617
0618 dIEtaPhi_t d_iEta = tower_dIEta(l1CaloTower.towerIeta, clNxM_pstn.seedIeta);
0619 dIEtaPhi_t d_iPhi = dPhi<dIEtaPhi_t, IPhi_t>(l1CaloTower.towerIphi, clNxM_pstn.seedIphi);
0620
0621
0622 if ((ap_abs(d_iEta) <= IEta_dim - 1 && ap_abs(d_iPhi) <= IPhi_dim - 1)) {
0623 l1CaloTower.stale4seed = 0x1;
0624 }
0625
0626 }
0627
0628
0629 if (seeded) {
0630 if (ap_abs(clNxM_pstn.seedIeta) <= intCB_CE_split) {
0631 l1TowerClustersNxM_CB.push_back(clNxM);
0632 l1TowerClustersNxM_CB_pstn.push_back(clNxM_pstn);
0633 Nclusters_CB++;
0634 } else {
0635 AllL1TowerClustersNxM_CE.push_back(clNxM);
0636 AllL1TowerClustersNxM_CE_pstn.push_back(clNxM_pstn);
0637 AllNclusters_CE++;
0638 }
0639 }
0640
0641 }
0642
0643
0644 for (int clNxMIdx = 0; clNxMIdx < Nclusters_CB; clNxMIdx++) {
0645 for (auto& l1CaloTower : l1CaloTowers) {
0646
0647 if (l1CaloTower.stale) {
0648 continue;
0649 }
0650
0651 dIEtaPhi_t d_iEta = tower_dIEta(l1CaloTower.towerIeta, l1TowerClustersNxM_CB_pstn[clNxMIdx].seedIeta);
0652 dIEtaPhi_t d_iPhi =
0653 dPhi<dIEtaPhi_t, IPhi_t>(l1CaloTower.towerIphi, l1TowerClustersNxM_CB_pstn[clNxMIdx].seedIphi);
0654 int hitIdx = d_iEta * 9 + d_iPhi + seedIdx;
0655
0656
0657 if ((ap_abs(d_iEta) <= (IEta_dim - 1) / 2 && ap_abs(d_iPhi) <= (IPhi_dim - 1) / 2)) {
0658 l1TowerClustersNxM_CB[clNxMIdx].fill(hitIdx, l1CaloTower);
0659 l1CaloTower.stale = 0x1;
0660 }
0661
0662 }
0663
0664 }
0665
0666
0667
0668 int Nclusters_CE = 0;
0669 for (int clNxMIdx = 0; clNxMIdx < AllNclusters_CE; clNxMIdx++) {
0670 bool matched = false;
0671 for (auto& HGCluster : AllHGClusters) {
0672
0673
0674 if (matched || HGCluster.stale || HGCluster.pt < Pt_t(4.) || HGCluster.PUid < intPuidThr) {
0675 continue;
0676 }
0677
0678 dEtaPhi_t d_iEta = tw2cl_dEta(HGCluster.eta, AllL1TowerClustersNxM_CE_pstn[clNxMIdx].seedIeta);
0679 dEtaPhi_t d_iPhi = tw2cl_dPhi(HGCluster.phi, AllL1TowerClustersNxM_CE_pstn[clNxMIdx].seedIphi);
0680 matched = d_iEta * d_iEta + d_iPhi * d_iPhi < R2cone;
0681
0682 if (matched) {
0683 HGCluster.stale = 0x1;
0684 InputHGCluster cl3d;
0685 cl3d.fill(HGCluster);
0686 HGClusters.push_back(cl3d);
0687 l1TowerClustersNxM_CE.push_back(AllL1TowerClustersNxM_CE[clNxMIdx]);
0688 l1TowerClustersNxM_CE_pstn.push_back(AllL1TowerClustersNxM_CE_pstn[clNxMIdx]);
0689 Nclusters_CE++;
0690 }
0691
0692 }
0693
0694 }
0695
0696
0697 for (int clNxMIdx = 0; clNxMIdx < Nclusters_CE; clNxMIdx++) {
0698 for (auto& l1CaloTower : l1CaloTowers) {
0699
0700 if (l1CaloTower.stale) {
0701 continue;
0702 }
0703
0704 dIEtaPhi_t d_iEta = tower_dIEta(l1CaloTower.towerIeta, l1TowerClustersNxM_CE_pstn[clNxMIdx].seedIeta);
0705 dIEtaPhi_t d_iPhi =
0706 dPhi<dIEtaPhi_t, IPhi_t>(l1CaloTower.towerIphi, l1TowerClustersNxM_CE_pstn[clNxMIdx].seedIphi);
0707 int hitIdx = d_iEta * 9 + d_iPhi + seedIdx;
0708
0709
0710 if ((ap_abs(d_iEta) <= (IEta_dim - 1) / 2 && ap_abs(d_iPhi) <= (IPhi_dim - 1) / 2)) {
0711 l1TowerClustersNxM_CE[clNxMIdx].fill(hitIdx, l1CaloTower);
0712 l1CaloTower.stale = 0x1;
0713 }
0714
0715 }
0716
0717 }
0718
0719
0720 int batchSize_CB = (int)(Nclusters_CB);
0721 tensorflow::TensorShape imageShape_CB({batchSize_CB, IEta_dim, IPhi_dim, 2});
0722 tensorflow::TensorShape positionShape_CB({batchSize_CB, 2});
0723 tensorflow::Tensor TowerClusterImage_CB(tensorflow::DT_FLOAT, imageShape_CB);
0724 tensorflow::Tensor TowerClusterPosition_CB(tensorflow::DT_FLOAT, positionShape_CB);
0725
0726 for (int clNxMIdx = 0; clNxMIdx < Nclusters_CB; clNxMIdx++) {
0727
0728 for (int eta = 0; eta < IEta_dim; ++eta) {
0729 for (int phi = 0; phi < IPhi_dim; ++phi) {
0730 int towerIdx = eta * IPhi_dim + phi;
0731 TowerClusterImage_CB.tensor<float, 4>()(clNxMIdx, eta, phi, 0) =
0732 (l1TowerClustersNxM_CB[clNxMIdx].towerHits[towerIdx].l1egTowerEt.to_float() +
0733 l1TowerClustersNxM_CB[clNxMIdx].towerHits[towerIdx].towerEm.to_float());
0734 TowerClusterImage_CB.tensor<float, 4>()(clNxMIdx, eta, phi, 1) =
0735 (l1TowerClustersNxM_CB[clNxMIdx].towerHits[towerIdx].towerHad.to_float());
0736 }
0737 }
0738
0739 TowerClusterPosition_CB.tensor<float, 2>()(clNxMIdx, 0) = floatIEta(l1TowerClustersNxM_CB_pstn[clNxMIdx].seedIeta);
0740 TowerClusterPosition_CB.tensor<float, 2>()(clNxMIdx, 1) = floatIPhi(l1TowerClustersNxM_CB_pstn[clNxMIdx].seedIphi);
0741 }
0742
0743 if (batchSize_CB >
0744 0)
0745 {
0746
0747 tensorflow::NamedTensorList CNNmodel_CBinputList = {{"TowerClusterImage", TowerClusterImage_CB},
0748 {"TowerClusterPosition", TowerClusterPosition_CB}};
0749 std::vector<tensorflow::Tensor> CNNmodel_CBoutputs;
0750 tensorflow::run((globalCache()->CNNmodel_CBsession),
0751 CNNmodel_CBinputList,
0752 {"TauMinator_CB_conv/middleMan/concat"},
0753 &CNNmodel_CBoutputs);
0754 tensorflow::NamedTensorList DNN_CBinputsList = {{"middleMan", CNNmodel_CBoutputs[0]}};
0755
0756
0757 std::vector<tensorflow::Tensor> DNN_CBoutputsIdent;
0758 tensorflow::run((globalCache()->DNNident_CBsession),
0759 DNN_CBinputsList,
0760 {"TauMinator_CB_ident/sigmoid_IDout/Sigmoid"},
0761 &DNN_CBoutputsIdent);
0762
0763
0764 std::vector<tensorflow::Tensor> DNN_CBoutputsCalib;
0765 tensorflow::run((globalCache()->DNNcalib_CBsession),
0766 DNN_CBinputsList,
0767 {"TauMinator_CB_calib/DNNout/MatMul"},
0768 &DNN_CBoutputsCalib);
0769
0770
0771 for (int clNxMIdx = 0; clNxMIdx < Nclusters_CB; clNxMIdx++) {
0772 l1t::Tau l1Tau =
0773 MakeTauCandidate(true, clNxMIdx, DNN_CBoutputsIdent, DNN_CBoutputsCalib, l1TowerClustersNxM_CB_pstn);
0774 if (l1Tau.pt() < 0) {
0775 continue;
0776 }
0777 L1NNCaloTauCollectionBXV->push_back(0, l1Tau);
0778 }
0779 }
0780
0781
0782 int batchSize_CE = (int)(Nclusters_CE);
0783 tensorflow::TensorShape imageShape_CE({batchSize_CE, IEta_dim, IPhi_dim, 2});
0784 tensorflow::TensorShape positionShape_CE({batchSize_CE, 2});
0785 tensorflow::TensorShape cl3dfeatShape_CE({batchSize_CE, 8});
0786 tensorflow::Tensor TowerClusterImage_CE(tensorflow::DT_FLOAT, imageShape_CE);
0787 tensorflow::Tensor TowerClusterPosition_CE(tensorflow::DT_FLOAT, positionShape_CE);
0788 tensorflow::Tensor Cl3dShapeFeatures_CE(tensorflow::DT_FLOAT, cl3dfeatShape_CE);
0789
0790 for (int clNxMIdx = 0; clNxMIdx < Nclusters_CE; clNxMIdx++) {
0791
0792 InputHGCluster HGClu = HGClusters[clNxMIdx];
0793
0794
0795 for (int eta = 0; eta < IEta_dim; ++eta) {
0796 for (int phi = 0; phi < IPhi_dim; ++phi) {
0797 int towerIdx = eta * IPhi_dim + phi;
0798 TowerClusterImage_CE.tensor<float, 4>()(clNxMIdx, eta, phi, 0) =
0799 (l1TowerClustersNxM_CE[clNxMIdx].towerHits[towerIdx].l1egTowerEt.to_float() +
0800 l1TowerClustersNxM_CE[clNxMIdx].towerHits[towerIdx].towerEm.to_float());
0801 TowerClusterImage_CE.tensor<float, 4>()(clNxMIdx, eta, phi, 1) =
0802 (l1TowerClustersNxM_CE[clNxMIdx].towerHits[towerIdx].towerHad.to_float());
0803 }
0804 }
0805
0806 TowerClusterPosition_CE.tensor<float, 2>()(clNxMIdx, 0) = floatIEta(l1TowerClustersNxM_CE_pstn[clNxMIdx].seedIeta);
0807 TowerClusterPosition_CE.tensor<float, 2>()(clNxMIdx, 1) = floatIPhi(l1TowerClustersNxM_CE_pstn[clNxMIdx].seedIphi);
0808
0809 Cl3dShapeFeatures_CE.tensor<float, 2>()(clNxMIdx, 0) = inputScaler(HGClu.pt.to_float(), "pt");
0810 Cl3dShapeFeatures_CE.tensor<float, 2>()(clNxMIdx, 1) = inputScaler(abs(floatEta(HGClu.eta)), "eta");
0811 Cl3dShapeFeatures_CE.tensor<float, 2>()(clNxMIdx, 2) = inputScaler(HGClu.showerlength.to_float(), "showerlength");
0812 Cl3dShapeFeatures_CE.tensor<float, 2>()(clNxMIdx, 3) =
0813 inputScaler(HGClu.coreshowerlength.to_float(), "coreshowerlength");
0814 Cl3dShapeFeatures_CE.tensor<float, 2>()(clNxMIdx, 4) = inputScaler(floatShape(HGClu.spptot), "spptot");
0815 Cl3dShapeFeatures_CE.tensor<float, 2>()(clNxMIdx, 5) = inputScaler(floatSzz(HGClu.szz), "szz");
0816 Cl3dShapeFeatures_CE.tensor<float, 2>()(clNxMIdx, 6) = inputScaler(floatShape(HGClu.srrtot), "srrtot");
0817 Cl3dShapeFeatures_CE.tensor<float, 2>()(clNxMIdx, 7) = inputScaler(floatMeanZHgcalCoord(HGClu.meanz), "meanz");
0818 }
0819
0820 if (batchSize_CE >
0821 0)
0822 {
0823
0824 tensorflow::NamedTensorList CNNmodel_CEinputList = {{"TowerClusterImage", TowerClusterImage_CE},
0825 {"TowerClusterPosition", TowerClusterPosition_CE},
0826 {"AssociatedCl3dFeatures", Cl3dShapeFeatures_CE}};
0827 std::vector<tensorflow::Tensor> CNNmodel_CEoutputs;
0828 tensorflow::run((globalCache()->CNNmodel_CEsession),
0829 CNNmodel_CEinputList,
0830 {"TauMinator_CE_conv/middleMan/concat"},
0831 &CNNmodel_CEoutputs);
0832 tensorflow::NamedTensorList DNN_CEinputsList = {{"middleMan", CNNmodel_CEoutputs[0]}};
0833
0834
0835 std::vector<tensorflow::Tensor> DNN_CEoutputsIdent;
0836 tensorflow::run((globalCache()->DNNident_CEsession),
0837 DNN_CEinputsList,
0838 {"TauMinator_CE_ident/sigmoid_IDout/Sigmoid"},
0839 &DNN_CEoutputsIdent);
0840
0841
0842 std::vector<tensorflow::Tensor> DNN_CEoutputsCalib;
0843 tensorflow::run((globalCache()->DNNcalib_CEsession),
0844 DNN_CEinputsList,
0845 {"TauMinator_CE_calib/LIN_DNNout/Relu"},
0846 &DNN_CEoutputsCalib);
0847
0848
0849 for (int clNxMIdx = 0; clNxMIdx < Nclusters_CE; clNxMIdx++) {
0850 l1t::Tau l1Tau =
0851 MakeTauCandidate(false, clNxMIdx, DNN_CEoutputsIdent, DNN_CEoutputsCalib, l1TowerClustersNxM_CE_pstn);
0852 if (l1Tau.pt() < 0) {
0853 continue;
0854 }
0855 L1NNCaloTauCollectionBXV->push_back(0, l1Tau);
0856 }
0857 }
0858
0859
0860 iEvent.put(std::move(L1NNCaloTauCollectionBXV), "L1NNCaloTauCollectionBXV");
0861
0862 }
0863
0864 template <class outPrecision, class inPrecision>
0865 outPrecision L1NNCaloTauEmulator::dPhi(inPrecision iPhi_1, inPrecision iPhi_2) {
0866 outPrecision dphi = iPhi_1 - iPhi_2;
0867
0868 outPrecision dphi0 = dphi > outPrecision(INTPHI_PI) ? outPrecision(dphi - INTPHI_2PI) : dphi;
0869 outPrecision dphi1 = dphi <= outPrecision(-INTPHI_PI) ? outPrecision(dphi + INTPHI_2PI) : dphi;
0870
0871 outPrecision result = dphi > outPrecision(0) ? dphi0 : dphi1;
0872
0873 return result;
0874 }
0875
0876 L1NNCaloTauEmulator::dIEtaPhi_t L1NNCaloTauEmulator::tower_dIEta(IEta_t iEta_1, IEta_t iEta_2) {
0877 ap_int<12> mult = iEta_1 * iEta_2;
0878 dIEtaPhi_t result = iEta_1 - iEta_2;
0879 if (mult < 0) {
0880 result = iEta_1 > 0 ? result - 1 : result + 1;
0881 }
0882
0883 return result;
0884 }
0885
0886 L1NNCaloTauEmulator::dEtaPhi_t L1NNCaloTauEmulator::tw2cl_dPhi(EtaPhi_t iPhi_1, IPhi_t iPhi_2) {
0887 EtaPhi_t shiftediPhi_2 = iPhi_2 <= IPhi_t(36) ? EtaPhi_t(iPhi_2) : EtaPhi_t(iPhi_2 - INTPHI_2PI + 1);
0888
0889 EtaPhi_t fineiPhi_2 = shiftediPhi_2 * (IETAPHI_LSB / ETAPHI_LSB);
0890
0891 fineiPhi_2 = fineiPhi_2 > EtaPhi_t(0) ? EtaPhi_t(fineiPhi_2 - (IETAPHI_LSB / ETAPHI_LSB) / 2)
0892 : EtaPhi_t(fineiPhi_2 + (IETAPHI_LSB / ETAPHI_LSB) / 2);
0893
0894 return dPhi<dEtaPhi_t, EtaPhi_t>(iPhi_1, fineiPhi_2);
0895 }
0896
0897 L1NNCaloTauEmulator::dEtaPhi_t L1NNCaloTauEmulator::tw2cl_dEta(EtaPhi_t iEta_1, IEta_t iEta_2) {
0898
0899 EtaPhi_t framechangeCl3d = 303;
0900 iEta_1 = iEta_1 > EtaPhi_t(0) ? EtaPhi_t(iEta_1 + framechangeCl3d) : EtaPhi_t(iEta_1 - framechangeCl3d);
0901
0902
0903 EtaPhi_t barrelEtaDepth = 329;
0904 EtaPhi_t fineiEta_2 = barrelEtaDepth + (iEta_2 - IETAHGCAL_OFFSET) * (IETAHGCAL_LSB / ETAPHI_LSB);
0905
0906 return iEta_1 - fineiEta_2;
0907 }
0908
0909 L1NNCaloTauEmulator::IEta_t L1NNCaloTauEmulator::makeEndcapHwIEta(float eta) {
0910 IEta_t ieta = floor(eta / IETAHGCAL_LSB);
0911
0912 ieta = ieta < IEta_t(0) ? IEta_t(ieta + 1) : ieta;
0913
0914 return ieta;
0915 }
0916
0917 L1NNCaloTauEmulator::IPhi_t L1NNCaloTauEmulator::makeEndcapHwIPhi(float phi) {
0918 phi = phi < 0 ? phi + 2 * M_PI : phi;
0919
0920
0921 return floor(phi / IETAPHI_LSB) + 1;
0922 }
0923
0924 template <int W>
0925 ap_int<W> L1NNCaloTauEmulator::ap_abs(ap_int<W> x) {
0926 ap_int<W> result;
0927 if (x < 0) {
0928 result = -x;
0929 } else {
0930 result = x;
0931 }
0932
0933 return result;
0934 }
0935
0936 template <int W, int I, ap_q_mode _AP_Q, ap_o_mode _AP_O>
0937 ap_ufixed<W, I> L1NNCaloTauEmulator::ap_abs(ap_fixed<W, I, _AP_Q, _AP_O> x) {
0938 ap_ufixed<W, I> result;
0939 if (x < 0) {
0940 result = -x;
0941 } else {
0942 result = x;
0943 }
0944
0945 return result;
0946 }
0947
0948 float L1NNCaloTauEmulator::apfixedQuantizer(float inputF, float LSB, int nbits) {
0949 return min(floor(inputF / LSB), float(pow(2, nbits) - 1)) * LSB;
0950 }
0951
0952 int L1NNCaloTauEmulator::apintQuantizer(float inputF, float LSB, int nbits) {
0953 return min(floor(inputF / LSB), float(pow(2, nbits) - 1));
0954 }
0955
0956 float L1NNCaloTauEmulator::inputScaler(float inputF, std::string feature) {
0957 float mean = (globalCache()->FeatScaler_CE).get_child(feature).get<float>("mean");
0958 float std = (globalCache()->FeatScaler_CE).get_child(feature).get<float>("std");
0959
0960 return (inputF - mean) / std;
0961 }
0962
0963 float L1NNCaloTauEmulator::correctInputEtaCl3d(float eta) {
0964 return eta > 0 ? eta - ETAHGCAL_OFFSET : eta + ETAHGCAL_OFFSET;
0965 }
0966
0967 float L1NNCaloTauEmulator::correctInputMeanzCl3d(float meanz) { return CM2MM * (abs(meanz) - MEANZ_OFFSET); }
0968
0969 float L1NNCaloTauEmulator::floatIEta(IEta_t eta) {
0970
0971 float feta;
0972 if (abs(eta) > IETAHGCAL_OFFSET) {
0973 if (eta > 0) {
0974 feta = IETAHGCAL_OFFSET * IETAPHI_LSB - (IETAHGCAL_LSB - IETAHGCAL_LSBp) +
0975 (eta.to_float() - IETAHGCAL_OFFSET) * IETAHGCAL_LSB;
0976 } else {
0977 feta = -IETAHGCAL_OFFSET * IETAPHI_LSB + (IETAHGCAL_LSB - IETAHGCAL_LSBp) +
0978 (eta.to_float() + IETAHGCAL_OFFSET) * IETAHGCAL_LSB;
0979 }
0980 } else {
0981 feta = eta.to_float() * IETAPHI_LSB;
0982 }
0983
0984
0985 return feta > 0 ? feta - IETAPHI_LSB / 2 : feta + IETAPHI_LSB / 2;
0986 }
0987
0988 float L1NNCaloTauEmulator::floatIPhi(IPhi_t phi) {
0989 float fphi = phi.to_float();
0990
0991 fphi = fphi > INTPHI_PI ? fphi - INTPHI_2PI + 1 : fphi;
0992 fphi *= IETAPHI_LSB;
0993
0994
0995 return fphi > 0 ? fphi - IETAPHI_LSB / 2 : fphi + IETAPHI_LSB / 2;
0996 }
0997
0998 l1t::Tau L1NNCaloTauEmulator::MakeTauCandidate(
0999 bool isBarrel,
1000 int clNxMIdx,
1001 std::vector<tensorflow::Tensor> outputsIdent,
1002 std::vector<tensorflow::Tensor> outputsCalib,
1003 std::vector<L1NNCaloTauEmulator::InputTowerCluster_pstn> clustersNxM_pstn) {
1004 int seedIeta = clustersNxM_pstn[clNxMIdx].seedIeta;
1005 int seedIphi = clustersNxM_pstn[clNxMIdx].seedIphi;
1006
1007 if (seedIeta > intEtaRestriction) {
1008 return l1t::Tau(reco::Candidate::PolarLorentzVector(-1, 0, 0, 0), -1, 0, 0, 0, 0);
1009 ;
1010 }
1011
1012 float tau_IDscore = outputsIdent[0].matrix<float>()(0, clNxMIdx);
1013 float tau_calibPt = outputsCalib[0].matrix<float>()(0, clNxMIdx);
1014 float tau_eta = floatIEta(seedIeta);
1015 float tau_phi = floatIPhi(seedIphi);
1016
1017
1018 int quality = 0;
1019 if (isBarrel) {
1020
1021 if (tau_IDscore > IdWp99_CB) {
1022 quality = 1;
1023 }
1024
1025 if (tau_IDscore > IdWp95_CB) {
1026 quality = 2;
1027 }
1028
1029 if (tau_IDscore > IdWp90_CB) {
1030 quality = 3;
1031 }
1032 } else {
1033
1034 if (tau_IDscore > IdWp99_CE) {
1035 quality = 1;
1036 }
1037
1038 if (tau_IDscore > IdWp95_CE) {
1039 quality = 2;
1040 }
1041
1042 if (tau_IDscore > IdWp90_CE) {
1043 quality = 3;
1044 }
1045 }
1046
1047 reco::Candidate::PolarLorentzVector tauP4 = reco::Candidate::PolarLorentzVector(tau_calibPt, tau_eta, tau_phi, 0);
1048
1049
1050
1051
1052 l1t::Tau l1Tau = l1t::Tau(tauP4, tau_calibPt, tau_eta, tau_phi, quality, tau_IDscore * 10E4);
1053 l1Tau.setTowerIEta(seedIeta);
1054 l1Tau.setTowerIPhi(seedIphi);
1055
1056 return l1Tau;
1057 }
1058
1059 void L1NNCaloTauEmulator::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
1060 edm::ParameterSetDescription desc;
1061
1062 desc.add<edm::InputTag>("l1CaloTowers", edm::InputTag("l1tEGammaClusterEmuProducer", "L1CaloTowerCollection"));
1063 desc.add<edm::InputTag>("hgcalTowers", edm::InputTag("l1tHGCalTowerProducer", "HGCalTowerProcessor"));
1064 desc.add<edm::InputTag>("HgcalClusters",
1065 edm::InputTag("l1tHGCalBackEndLayer2Producer", "HGCalBackendLayer2Processor3DClustering"));
1066
1067 desc.add<std::string>("preEmId", "hOverE < 0.3 && hOverE >= 0");
1068 {
1069 edm::ParameterSetDescription psd0;
1070 psd0.add<bool>("isPUFilter", true);
1071 psd0.add<std::string>("preselection", "");
1072 psd0.add<std::string>("method", "BDT");
1073 {
1074 edm::ParameterSetDescription vpsd2;
1075 vpsd2.add<std::string>("name");
1076 vpsd2.add<std::string>("value");
1077 std::vector<edm::ParameterSet> temp2;
1078 temp2.reserve(5);
1079 {
1080 edm::ParameterSet temp3;
1081 temp3.addParameter<std::string>("name", "eMax");
1082 temp3.addParameter<std::string>("value", "eMax()");
1083 temp2.push_back(temp3);
1084 }
1085 {
1086 edm::ParameterSet temp3;
1087 temp3.addParameter<std::string>("name", "eMaxOverE");
1088 temp3.addParameter<std::string>("value", "eMax()/energy()");
1089 temp2.push_back(temp3);
1090 }
1091 {
1092 edm::ParameterSet temp3;
1093 temp3.addParameter<std::string>("name", "sigmaPhiPhiTot");
1094 temp3.addParameter<std::string>("value", "sigmaPhiPhiTot()");
1095 temp2.push_back(temp3);
1096 }
1097 {
1098 edm::ParameterSet temp3;
1099 temp3.addParameter<std::string>("name", "sigmaRRTot");
1100 temp3.addParameter<std::string>("value", "sigmaRRTot()");
1101 temp2.push_back(temp3);
1102 }
1103 {
1104 edm::ParameterSet temp3;
1105 temp3.addParameter<std::string>("name", "triggerCells90percent");
1106 temp3.addParameter<std::string>("value", "triggerCells90percent()");
1107 temp2.push_back(temp3);
1108 }
1109 psd0.addVPSet("variables", vpsd2, temp2);
1110 }
1111 psd0.add<std::string>(
1112 "weightsFile", "L1Trigger/Phase2L1ParticleFlow/data/hgcal_egID/Photon_Pion_vs_Neutrino_BDTweights_1116.xml.gz");
1113 psd0.add<std::string>("wp", "-0.10");
1114 desc.add<edm::ParameterSetDescription>("VsPuId", psd0);
1115 }
1116
1117 desc.add<double>("EcalEtMinForClustering", 0.0);
1118 desc.add<double>("HcalEtMinForClustering", 0.0);
1119 desc.add<double>("EtMinForSeeding", 2.5);
1120 desc.add<double>("EtaRestriction", 2.4);
1121 desc.add<double>("CB_CE_split", 1.55);
1122 desc.add<double>("PuidThr", -0.1);
1123
1124 desc.add<std::string>("CNNmodel_CB_path", "L1Trigger/L1CaloTrigger/data/Phase2_NNCaloTaus/v22/CNNmodel_CB.pb");
1125 desc.add<std::string>("DNNident_CB_path", "L1Trigger/L1CaloTrigger/data/Phase2_NNCaloTaus/v22/DNNident_CB.pb");
1126 desc.add<std::string>("DNNcalib_CB_path", "L1Trigger/L1CaloTrigger/data/Phase2_NNCaloTaus/v22/DNNcalib_CB.pb");
1127 desc.add<std::string>("CNNmodel_CE_path", "L1Trigger/L1CaloTrigger/data/Phase2_NNCaloTaus/v22/CNNmodel_CE.pb");
1128 desc.add<std::string>("DNNident_CE_path", "L1Trigger/L1CaloTrigger/data/Phase2_NNCaloTaus/v22/DNNident_CE.pb");
1129 desc.add<std::string>("DNNcalib_CE_path", "L1Trigger/L1CaloTrigger/data/Phase2_NNCaloTaus/v22/DNNcalib_CE.pb");
1130 desc.add<std::string>("FeatScaler_CE_path", "L1Trigger/L1CaloTrigger/data/Phase2_NNCaloTaus/Cl3dFeatScaler_CE.json");
1131
1132 desc.add<double>("IdWp90_CB", 0.706);
1133 desc.add<double>("IdWp95_CB", 0.3432);
1134 desc.add<double>("IdWp99_CB", 0.0337);
1135 desc.add<double>("IdWp90_CE", 0.5711);
1136 desc.add<double>("IdWp95_CE", 0.2742);
1137 desc.add<double>("IdWp99_CE", 0.0394);
1138
1139 desc.add<bool>("DEBUG", false);
1140
1141 descriptions.add("l1tNNCaloTauEmulator", desc);
1142 }
1143
1144 DEFINE_FWK_MODULE(L1NNCaloTauEmulator);