Back to home page

Project CMSSW displayed by LXR
 
 

    

File indexing completed on 2025-03-26 01:51:22 

0001 // -*- C++ -*-
0002 //
0003 // Package:    L1Trigger/L1CaloTrigger
0004 // Class:      L1TCaloBarrelToCorrelator
0005 //
0006 /*
0007  Description: Creates digitized EGamma and ParticleFlow clusters to be sent to correlator. 
0008 
0009  Implementation: To be run together with Phase2L1CaloEGammaEmulator.
0010 */
0011 
0012 // system include files
0013 #include <memory>
0014 
0015 // user include files
0016 #include "FWCore/Framework/interface/Frameworkfwd.h"
0017 #include "FWCore/Framework/interface/stream/EDProducer.h"
0018 
0019 #include "FWCore/Framework/interface/Event.h"
0020 #include "FWCore/Framework/interface/MakerMacros.h"
0021 
0022 #include "FWCore/ParameterSet/interface/ParameterSet.h"
0023 #include "FWCore/Utilities/interface/StreamID.h"
0024 
0025 #include "DataFormats/L1TCalorimeterPhase2/interface/CaloPFCluster.h"
0026 #include "DataFormats/L1TCalorimeterPhase2/interface/DigitizedClusterCorrelator.h"
0027 
0028 #include "DataFormats/L1TCalorimeterPhase2/interface/GCTEmDigiCluster.h"
0029 #include "DataFormats/L1TCalorimeterPhase2/interface/GCTHadDigiCluster.h"
0030 
0031 #include <ap_int.h>
0032 #include <fstream>
0033 #include <iomanip>
0034 #include <iostream>
0035 #include <cstdio>
0036 #include "L1Trigger/L1CaloTrigger/interface/Phase2L1CaloBarrelToCorrelator.h"
0037 #include "L1Trigger/L1CaloTrigger/interface/Phase2L1CaloEGammaUtils.h"
0038 
0039 //
0040 // class declaration
0041 //
0042 
0043 class Phase2GCTBarrelToCorrelatorLayer1 : public edm::stream::EDProducer<> {
0044 public:
0045   explicit Phase2GCTBarrelToCorrelatorLayer1(const edm::ParameterSet&);
0046   ~Phase2GCTBarrelToCorrelatorLayer1() override = default;
0047 
0048 private:
0049   void produce(edm::Event&, const edm::EventSetup&) override;
0050 
0051   // ----------member data ---------------------------
0052   const edm::EDGetTokenT<l1tp2::CaloCrystalClusterCollection> gctClusterSrc_;
0053   const edm::EDGetTokenT<l1tp2::DigitizedClusterCorrelatorCollection> digiInputClusterSrc_;
0054   const edm::EDGetTokenT<l1tp2::CaloPFClusterCollection> caloPFClustersSrc_;
0055 };
0056 
0057 //
0058 // constructors and destructor
0059 //
0060 Phase2GCTBarrelToCorrelatorLayer1::Phase2GCTBarrelToCorrelatorLayer1(const edm::ParameterSet& iConfig)
0061     : gctClusterSrc_(
0062           consumes<l1tp2::CaloCrystalClusterCollection>(iConfig.getParameter<edm::InputTag>("gctClustersInput"))),
0063       digiInputClusterSrc_(consumes<l1tp2::DigitizedClusterCorrelatorCollection>(
0064           iConfig.getParameter<edm::InputTag>("gctDigiClustersInput"))),
0065       caloPFClustersSrc_(
0066           consumes<l1tp2::CaloPFClusterCollection>(iConfig.getParameter<edm::InputTag>("gctPFclusters"))) {
0067   produces<l1tp2::GCTEmDigiClusterCollection>("GCTEmDigiClusters");
0068   produces<l1tp2::GCTHadDigiClusterCollection>("GCTHadDigiClusters");
0069 }
0070 
0071 void Phase2GCTBarrelToCorrelatorLayer1::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) {
0072   using namespace edm;
0073 
0074   //***************************************************//
0075   // Get the GCT digitized clusters and PF clusters
0076   //***************************************************//
0077   edm::Handle<l1tp2::CaloCrystalClusterCollection> inputGCTClusters;
0078   iEvent.getByToken(gctClusterSrc_, inputGCTClusters);
0079 
0080   edm::Handle<l1tp2::DigitizedClusterCorrelatorCollection> inputGCTDigiClusters;
0081   iEvent.getByToken(digiInputClusterSrc_, inputGCTDigiClusters);
0082 
0083   edm::Handle<l1tp2::CaloPFClusterCollection> inputPFClusters;
0084   iEvent.getByToken(caloPFClustersSrc_, inputPFClusters);
0085 
0086   //***************************************************//
0087   // Initialize outputs
0088   //***************************************************//
0089 
0090   // Em digi cluster output
0091   auto outputEmClusters = std::make_unique<l1tp2::GCTEmDigiClusterCollection>();
0092   // Had digi cluster output
0093   auto outputHadClusters = std::make_unique<l1tp2::GCTHadDigiClusterCollection>();
0094 
0095   // EG Clusters output by GCT SLR (duplicates included)
0096   l1tp2::GCTEmDigiClusterLink out_eg_GCT1_SLR1_posEta;
0097   l1tp2::GCTEmDigiClusterLink out_eg_GCT1_SLR1_negEta;
0098   l1tp2::GCTEmDigiClusterLink out_eg_GCT1_SLR3_posEta;
0099   l1tp2::GCTEmDigiClusterLink out_eg_GCT1_SLR3_negEta;
0100   l1tp2::GCTEmDigiClusterLink out_eg_GCT2_SLR1_posEta;
0101   l1tp2::GCTEmDigiClusterLink out_eg_GCT2_SLR1_negEta;
0102   l1tp2::GCTEmDigiClusterLink out_eg_GCT2_SLR3_posEta;
0103   l1tp2::GCTEmDigiClusterLink out_eg_GCT2_SLR3_negEta;
0104   l1tp2::GCTEmDigiClusterLink out_eg_GCT3_SLR1_posEta;
0105   l1tp2::GCTEmDigiClusterLink out_eg_GCT3_SLR1_negEta;
0106   l1tp2::GCTEmDigiClusterLink out_eg_GCT3_SLR3_posEta;
0107   l1tp2::GCTEmDigiClusterLink out_eg_GCT3_SLR3_negEta;
0108 
0109   // Temporary arrays used to represent the four RCT cards in one SLR one side of eta (positive or eta)
0110   l1tp2::GCTEmDigiClusterLink buffer_eg_GCT1_SLR1_posEta[4];
0111   l1tp2::GCTEmDigiClusterLink buffer_eg_GCT1_SLR1_negEta[4];
0112   l1tp2::GCTEmDigiClusterLink buffer_eg_GCT1_SLR3_posEta[4];
0113   l1tp2::GCTEmDigiClusterLink buffer_eg_GCT1_SLR3_negEta[4];
0114   l1tp2::GCTEmDigiClusterLink buffer_eg_GCT2_SLR1_posEta[4];
0115   l1tp2::GCTEmDigiClusterLink buffer_eg_GCT2_SLR1_negEta[4];
0116   l1tp2::GCTEmDigiClusterLink buffer_eg_GCT2_SLR3_posEta[4];
0117   l1tp2::GCTEmDigiClusterLink buffer_eg_GCT2_SLR3_negEta[4];
0118   l1tp2::GCTEmDigiClusterLink buffer_eg_GCT3_SLR1_posEta[4];
0119   l1tp2::GCTEmDigiClusterLink buffer_eg_GCT3_SLR1_negEta[4];
0120   l1tp2::GCTEmDigiClusterLink buffer_eg_GCT3_SLR3_posEta[4];
0121   l1tp2::GCTEmDigiClusterLink buffer_eg_GCT3_SLR3_negEta[4];
0122 
0123   // PF Clusters output by GCT SLR (duplicates included)
0124   l1tp2::GCTHadDigiClusterLink out_had_GCT1_SLR1_posEta;
0125   l1tp2::GCTHadDigiClusterLink out_had_GCT1_SLR1_negEta;
0126   l1tp2::GCTHadDigiClusterLink out_had_GCT1_SLR3_posEta;
0127   l1tp2::GCTHadDigiClusterLink out_had_GCT1_SLR3_negEta;
0128   l1tp2::GCTHadDigiClusterLink out_had_GCT2_SLR1_posEta;
0129   l1tp2::GCTHadDigiClusterLink out_had_GCT2_SLR1_negEta;
0130   l1tp2::GCTHadDigiClusterLink out_had_GCT2_SLR3_posEta;
0131   l1tp2::GCTHadDigiClusterLink out_had_GCT2_SLR3_negEta;
0132   l1tp2::GCTHadDigiClusterLink out_had_GCT3_SLR1_posEta;
0133   l1tp2::GCTHadDigiClusterLink out_had_GCT3_SLR1_negEta;
0134   l1tp2::GCTHadDigiClusterLink out_had_GCT3_SLR3_posEta;
0135   l1tp2::GCTHadDigiClusterLink out_had_GCT3_SLR3_negEta;
0136 
0137   // Temporary arrays used to represent the four RCT cards in one SLR one side of eta (positive or eta)
0138   l1tp2::GCTHadDigiClusterLink buffer_had_GCT1_SLR1_posEta[4];
0139   l1tp2::GCTHadDigiClusterLink buffer_had_GCT1_SLR1_negEta[4];
0140   l1tp2::GCTHadDigiClusterLink buffer_had_GCT1_SLR3_posEta[4];
0141   l1tp2::GCTHadDigiClusterLink buffer_had_GCT1_SLR3_negEta[4];
0142   l1tp2::GCTHadDigiClusterLink buffer_had_GCT2_SLR1_posEta[4];
0143   l1tp2::GCTHadDigiClusterLink buffer_had_GCT2_SLR1_negEta[4];
0144   l1tp2::GCTHadDigiClusterLink buffer_had_GCT2_SLR3_posEta[4];
0145   l1tp2::GCTHadDigiClusterLink buffer_had_GCT2_SLR3_negEta[4];
0146   l1tp2::GCTHadDigiClusterLink buffer_had_GCT3_SLR1_posEta[4];
0147   l1tp2::GCTHadDigiClusterLink buffer_had_GCT3_SLR1_negEta[4];
0148   l1tp2::GCTHadDigiClusterLink buffer_had_GCT3_SLR3_posEta[4];
0149   l1tp2::GCTHadDigiClusterLink buffer_had_GCT3_SLR3_negEta[4];
0150 
0151   //***************************************************//
0152   // Loop over the regions: in order: GCT1 SLR1, GCT1 SLR3, GCT2 SLR1, GCT2 SLR3, GCT3 SLR1, GCT3SLR3
0153   //***************************************************//
0154 
0155   const int nRegions = 6;
0156   float regionCentersInDegrees[nRegions] = {10.0, 70.0, 130.0, -170.0, -110.0, -50.0};
0157 
0158   for (int iRegion = 0; iRegion < nRegions; iRegion++) {
0159     // EM digi clusters
0160     for (size_t iCluster = 0; iCluster < inputGCTDigiClusters->size(); ++iCluster) {
0161       l1tp2::DigitizedClusterCorrelator clusterIn = inputGCTDigiClusters->at(iCluster);
0162 
0163       // Check if this cluster falls into each SLR region, i.e. if the cluster is within 120/2 = 60 degrees of the center of the SLR in phi
0164       float clusterRealPhiAsDegree = clusterIn.realPhi() * 180 / M_PI;
0165       float phiDifference = p2eg::deltaPhiInDegrees(clusterRealPhiAsDegree, regionCentersInDegrees[iRegion]);
0166       if (std::abs(phiDifference) < (p2eg::PHI_RANGE_PER_SLR_DEGREES / 2)) {
0167         // Go from real phi to an index in the SLR
0168         // The crystal directly above the region center in phi, is iPhi 0. The crystal directly below the region center in phi, is iPhi -1.
0169         int iPhiCrystalDifference = std::floor(phiDifference);
0170 
0171         // For eta, the eta is already digitized, just needs to be converted from [0, +2*17*5) to [-17*5, +17*5)
0172         int temp_iEta_signed = clusterIn.eta() - (p2eg::CRYSTALS_IN_TOWER_ETA * p2eg::n_towers_per_link);
0173 
0174         // Default value: for clusters in positive eta, values go from 0, 1, 2, 3, 4
0175         int iEta = temp_iEta_signed;
0176         // If cluster is in negative eta, instead of from -5, -4, -3, -2, -1, we want 4, 3, 2, 1, 0
0177         if (temp_iEta_signed < 0) {
0178           // If in negative eta, convert to an absolute value, with 0 being the crystal nearest real eta = 0
0179           iEta = std::abs(temp_iEta_signed + 1);
0180         }
0181 
0182         // Initialize the new cluster and set the edm::Ref pointing to the underlying float
0183         l1tp2::GCTEmDigiCluster clusterOut = l1tp2::GCTEmDigiCluster(clusterIn.pt(),
0184                                                                      iEta,
0185                                                                      iPhiCrystalDifference,
0186                                                                      clusterIn.hoe(),
0187                                                                      clusterIn.hoeFlag(),
0188                                                                      clusterIn.iso(),
0189                                                                      clusterIn.isoFlags(),
0190                                                                      clusterIn.fb(),
0191                                                                      clusterIn.timing(),
0192                                                                      clusterIn.shapeFlags(),
0193                                                                      clusterIn.brems());
0194         // there is a 1-to-1 mapping between the original float clusters and the first step of digitization, so we can build a ref to the same cluster
0195         edm::Ref<l1tp2::CaloCrystalClusterCollection> thisRef(inputGCTClusters, iCluster);
0196         clusterOut.setRef(thisRef);
0197         edm::Ref<l1tp2::DigitizedClusterCorrelatorCollection> thisDigiRef(inputGCTDigiClusters, iCluster);
0198         clusterOut.setDigiRef(thisDigiRef);
0199 
0200         // Check which RCT card this falls into, ordered 0, 1, 2, 3 counting from the most negative phi (real phi or iPhi) to the most positive
0201         // so RCT card 0 is -60 to -30 degrees in phi from the center, RCT card 1 is -30 to 0 degrees in phi from the center, RCT card 2 is 0 to +30 degrees in phi from the center, RCT card 3 is +30 to +60 degrees in phi from the center
0202         int whichRCTcard = 0;
0203         if (phiDifference < -30) {
0204           whichRCTcard = 0;
0205         } else if (phiDifference < 0) {
0206           whichRCTcard = 1;
0207         } else if (phiDifference < 30) {
0208           whichRCTcard = 2;
0209         } else {
0210           whichRCTcard = 3;
0211         }
0212 
0213         if (iRegion == 0) {
0214           if (temp_iEta_signed < 0) {
0215             buffer_eg_GCT1_SLR1_negEta[whichRCTcard].push_back(clusterOut);
0216           } else {
0217             buffer_eg_GCT1_SLR1_posEta[whichRCTcard].push_back(clusterOut);
0218           }
0219         } else if (iRegion == 1) {
0220           if (temp_iEta_signed < 0) {
0221             buffer_eg_GCT1_SLR3_negEta[whichRCTcard].push_back(clusterOut);
0222           } else {
0223             buffer_eg_GCT1_SLR3_posEta[whichRCTcard].push_back(clusterOut);
0224           }
0225         } else if (iRegion == 2) {
0226           if (temp_iEta_signed < 0) {
0227             buffer_eg_GCT2_SLR1_negEta[whichRCTcard].push_back(clusterOut);
0228           } else {
0229             buffer_eg_GCT2_SLR1_posEta[whichRCTcard].push_back(clusterOut);
0230           }
0231         } else if (iRegion == 3) {
0232           if (temp_iEta_signed < 0) {
0233             buffer_eg_GCT2_SLR3_negEta[whichRCTcard].push_back(clusterOut);
0234           } else {
0235             buffer_eg_GCT2_SLR3_posEta[whichRCTcard].push_back(clusterOut);
0236           }
0237         } else if (iRegion == 4) {
0238           if (temp_iEta_signed < 0) {
0239             buffer_eg_GCT3_SLR1_negEta[whichRCTcard].push_back(clusterOut);
0240           } else {
0241             buffer_eg_GCT3_SLR1_posEta[whichRCTcard].push_back(clusterOut);
0242           }
0243         } else if (iRegion == 5) {
0244           if (temp_iEta_signed < 0) {
0245             buffer_eg_GCT3_SLR3_negEta[whichRCTcard].push_back(clusterOut);
0246           } else {
0247             buffer_eg_GCT3_SLR3_posEta[whichRCTcard].push_back(clusterOut);
0248           }
0249         }
0250       }
0251     }
0252 
0253     // Repeat for PF Clusters
0254     for (size_t iCluster = 0; iCluster < inputPFClusters->size(); ++iCluster) {
0255       l1tp2::CaloPFCluster pfIn = inputPFClusters->at(iCluster);
0256 
0257       // Skip zero-energy clusters
0258       if (pfIn.clusterEt() == 0)
0259         continue;
0260 
0261       // Check if this cluster falls into each GCT card
0262       float clusterRealPhiAsDegree = pfIn.clusterPhi() * 180 / M_PI;
0263       float differenceInPhi = p2eg::deltaPhiInDegrees(clusterRealPhiAsDegree, regionCentersInDegrees[iRegion]);
0264       if (std::abs(differenceInPhi) < (p2eg::PHI_RANGE_PER_SLR_DEGREES / 2)) {
0265         // Go from real phi to an index in the SLR
0266         // Calculate the distance in phi from the center of the region
0267         float phiDifference = clusterRealPhiAsDegree - regionCentersInDegrees[iRegion];
0268         int iPhiCrystalDifference = std::floor(phiDifference);
0269 
0270         // For PFClusters, the method clusterEta returns a float, so we need to digitize this
0271         float eta_LSB = p2eg::ECAL_eta_range / (p2eg::N_GCTTOWERS_FIBER * p2eg::CRYSTALS_IN_TOWER_ETA);
0272         int temp_iEta_signed = std::floor(pfIn.clusterEta() / eta_LSB);
0273         // Default value (for positive eta)
0274         int iEta = temp_iEta_signed;
0275         // If cluster is in negative eta, instead of from -5, -4, -3, -2, -1 we want 4, 3, 2, 1, 0
0276         if (temp_iEta_signed < 0) {
0277           // If in negative eta, convert to an absolute value, with 0 being the crystal nearest real eta = 0
0278           iEta = std::abs(temp_iEta_signed + 1);
0279         }
0280 
0281         // Initialize the new cluster
0282         l1tp2::GCTHadDigiCluster pfOut =
0283             l1tp2::GCTHadDigiCluster(pfIn.clusterEt() / p2eg::ECAL_LSB,  // convert to integer
0284                                      iEta,
0285                                      iPhiCrystalDifference,
0286                                      0  // no HoE value in PF Cluster
0287             );
0288         pfOut.setRef(edm::Ref<l1tp2::CaloPFClusterCollection>(inputPFClusters, iCluster));
0289 
0290         // Check which RCT card this falls into, ordered 0, 1, 2, 3 counting from the most negative phi (real phi or iPhi) to the most positive
0291         // so RCT card 0 is -60 to -30 degrees in phi from the center, RCT card 1 is -30 to 0 degrees in phi from the center, RCT card 2 is 0 to +30 degrees in phi from the center, RCT card 3 is +30 to +60 degrees in phi from the center
0292         int whichRCTcard = 0;
0293         if (phiDifference < -30) {
0294           whichRCTcard = 0;
0295         } else if (phiDifference < 0) {
0296           whichRCTcard = 1;
0297         } else if (phiDifference < 30) {
0298           whichRCTcard = 2;
0299         } else {
0300           whichRCTcard = 3;
0301         }
0302 
0303         if (iRegion == 0) {
0304           if (temp_iEta_signed < 0) {
0305             buffer_had_GCT1_SLR1_negEta[whichRCTcard].push_back(pfOut);
0306           } else {
0307             buffer_had_GCT1_SLR1_posEta[whichRCTcard].push_back(pfOut);
0308           }
0309         } else if (iRegion == 1) {
0310           if (temp_iEta_signed < 0) {
0311             buffer_had_GCT1_SLR3_negEta[whichRCTcard].push_back(pfOut);
0312           } else {
0313             buffer_had_GCT1_SLR3_posEta[whichRCTcard].push_back(pfOut);
0314           }
0315         } else if (iRegion == 2) {
0316           if (temp_iEta_signed < 0) {
0317             buffer_had_GCT2_SLR1_negEta[whichRCTcard].push_back(pfOut);
0318           } else {
0319             buffer_had_GCT2_SLR1_posEta[whichRCTcard].push_back(pfOut);
0320           }
0321         } else if (iRegion == 3) {
0322           if (temp_iEta_signed < 0) {
0323             buffer_had_GCT2_SLR3_negEta[whichRCTcard].push_back(pfOut);
0324           } else {
0325             buffer_had_GCT2_SLR3_posEta[whichRCTcard].push_back(pfOut);
0326           }
0327         } else if (iRegion == 4) {
0328           if (temp_iEta_signed < 0) {
0329             buffer_had_GCT3_SLR1_negEta[whichRCTcard].push_back(pfOut);
0330           } else {
0331             buffer_had_GCT3_SLR1_posEta[whichRCTcard].push_back(pfOut);
0332           }
0333         } else if (iRegion == 5) {
0334           if (temp_iEta_signed < 0) {
0335             buffer_had_GCT3_SLR3_negEta[whichRCTcard].push_back(pfOut);
0336           } else {
0337             buffer_had_GCT3_SLR3_posEta[whichRCTcard].push_back(pfOut);
0338           }
0339         }
0340       }
0341     }
0342   }
0343 
0344   // Within each RCT card, sort the egamma clusters in descending pT order and add zero-padding
0345   for (int iRCT = 0; iRCT < 4; iRCT++) {
0346     p2eg::sortAndPadSLR(buffer_eg_GCT1_SLR1_negEta[iRCT], p2eg::N_EG_CLUSTERS_PER_RCT_CARD);
0347     p2eg::sortAndPadSLR(buffer_eg_GCT1_SLR3_negEta[iRCT], p2eg::N_EG_CLUSTERS_PER_RCT_CARD);
0348     p2eg::sortAndPadSLR(buffer_eg_GCT2_SLR1_negEta[iRCT], p2eg::N_EG_CLUSTERS_PER_RCT_CARD);
0349     p2eg::sortAndPadSLR(buffer_eg_GCT2_SLR3_negEta[iRCT], p2eg::N_EG_CLUSTERS_PER_RCT_CARD);
0350     p2eg::sortAndPadSLR(buffer_eg_GCT3_SLR1_negEta[iRCT], p2eg::N_EG_CLUSTERS_PER_RCT_CARD);
0351     p2eg::sortAndPadSLR(buffer_eg_GCT3_SLR3_negEta[iRCT], p2eg::N_EG_CLUSTERS_PER_RCT_CARD);
0352     p2eg::sortAndPadSLR(buffer_eg_GCT1_SLR1_posEta[iRCT], p2eg::N_EG_CLUSTERS_PER_RCT_CARD);
0353     p2eg::sortAndPadSLR(buffer_eg_GCT1_SLR3_posEta[iRCT], p2eg::N_EG_CLUSTERS_PER_RCT_CARD);
0354     p2eg::sortAndPadSLR(buffer_eg_GCT2_SLR1_posEta[iRCT], p2eg::N_EG_CLUSTERS_PER_RCT_CARD);
0355     p2eg::sortAndPadSLR(buffer_eg_GCT2_SLR3_posEta[iRCT], p2eg::N_EG_CLUSTERS_PER_RCT_CARD);
0356     p2eg::sortAndPadSLR(buffer_eg_GCT3_SLR1_posEta[iRCT], p2eg::N_EG_CLUSTERS_PER_RCT_CARD);
0357     p2eg::sortAndPadSLR(buffer_eg_GCT3_SLR3_posEta[iRCT], p2eg::N_EG_CLUSTERS_PER_RCT_CARD);
0358   }
0359 
0360   // Then build the container for each egamma SLR, by pushing back, in order, the four RCT cards (starting from most negative phi to most positive phi)
0361   for (int iRCT = 0; iRCT < 4; iRCT++) {
0362     for (int iCluster = 0; iCluster < p2eg::N_EG_CLUSTERS_PER_RCT_CARD; iCluster++) {
0363       // outer loop is over RCT cards, inner loop is over the clusters in each RCT card
0364       out_eg_GCT1_SLR1_posEta.push_back(buffer_eg_GCT1_SLR1_posEta[iRCT][iCluster]);
0365       out_eg_GCT1_SLR1_negEta.push_back(buffer_eg_GCT1_SLR1_negEta[iRCT][iCluster]);
0366       out_eg_GCT1_SLR3_posEta.push_back(buffer_eg_GCT1_SLR3_posEta[iRCT][iCluster]);
0367       out_eg_GCT1_SLR3_negEta.push_back(buffer_eg_GCT1_SLR3_negEta[iRCT][iCluster]);
0368       out_eg_GCT2_SLR1_posEta.push_back(buffer_eg_GCT2_SLR1_posEta[iRCT][iCluster]);
0369       out_eg_GCT2_SLR1_negEta.push_back(buffer_eg_GCT2_SLR1_negEta[iRCT][iCluster]);
0370       out_eg_GCT2_SLR3_posEta.push_back(buffer_eg_GCT2_SLR3_posEta[iRCT][iCluster]);
0371       out_eg_GCT2_SLR3_negEta.push_back(buffer_eg_GCT2_SLR3_negEta[iRCT][iCluster]);
0372       out_eg_GCT3_SLR1_posEta.push_back(buffer_eg_GCT3_SLR1_posEta[iRCT][iCluster]);
0373       out_eg_GCT3_SLR1_negEta.push_back(buffer_eg_GCT3_SLR1_negEta[iRCT][iCluster]);
0374       out_eg_GCT3_SLR3_posEta.push_back(buffer_eg_GCT3_SLR3_posEta[iRCT][iCluster]);
0375       out_eg_GCT3_SLR3_negEta.push_back(buffer_eg_GCT3_SLR3_negEta[iRCT][iCluster]);
0376     }
0377   }
0378 
0379   // Repeat for PF: Within each RCT card, sort the PF clusters in descending pT order and add zero-padding
0380   for (int iRCT = 0; iRCT < 4; iRCT++) {
0381     p2eg::sortAndPadSLR(buffer_had_GCT1_SLR1_negEta[iRCT], p2eg::N_PF_CLUSTERS_PER_RCT_CARD);
0382     p2eg::sortAndPadSLR(buffer_had_GCT1_SLR3_negEta[iRCT], p2eg::N_PF_CLUSTERS_PER_RCT_CARD);
0383     p2eg::sortAndPadSLR(buffer_had_GCT2_SLR1_negEta[iRCT], p2eg::N_PF_CLUSTERS_PER_RCT_CARD);
0384     p2eg::sortAndPadSLR(buffer_had_GCT2_SLR3_negEta[iRCT], p2eg::N_PF_CLUSTERS_PER_RCT_CARD);
0385     p2eg::sortAndPadSLR(buffer_had_GCT3_SLR1_negEta[iRCT], p2eg::N_PF_CLUSTERS_PER_RCT_CARD);
0386     p2eg::sortAndPadSLR(buffer_had_GCT3_SLR3_negEta[iRCT], p2eg::N_PF_CLUSTERS_PER_RCT_CARD);
0387     p2eg::sortAndPadSLR(buffer_had_GCT1_SLR1_posEta[iRCT], p2eg::N_PF_CLUSTERS_PER_RCT_CARD);
0388     p2eg::sortAndPadSLR(buffer_had_GCT1_SLR3_posEta[iRCT], p2eg::N_PF_CLUSTERS_PER_RCT_CARD);
0389     p2eg::sortAndPadSLR(buffer_had_GCT2_SLR1_posEta[iRCT], p2eg::N_PF_CLUSTERS_PER_RCT_CARD);
0390     p2eg::sortAndPadSLR(buffer_had_GCT2_SLR3_posEta[iRCT], p2eg::N_PF_CLUSTERS_PER_RCT_CARD);
0391     p2eg::sortAndPadSLR(buffer_had_GCT3_SLR1_posEta[iRCT], p2eg::N_PF_CLUSTERS_PER_RCT_CARD);
0392     p2eg::sortAndPadSLR(buffer_had_GCT3_SLR3_posEta[iRCT], p2eg::N_PF_CLUSTERS_PER_RCT_CARD);
0393   }
0394 
0395   // Then build the container for each PF SLR, by pushing back, in order, the four RCT cards (starting from most negative phi to most positive phi)
0396   for (int iRCT = 0; iRCT < 4; iRCT++) {
0397     for (int iCluster = 0; iCluster < p2eg::N_PF_CLUSTERS_PER_RCT_CARD; iCluster++) {
0398       // outer loop is over RCT cards, inner loop is over clusters
0399       out_had_GCT1_SLR1_posEta.push_back(buffer_had_GCT1_SLR1_posEta[iRCT][iCluster]);
0400       out_had_GCT1_SLR1_negEta.push_back(buffer_had_GCT1_SLR1_negEta[iRCT][iCluster]);
0401       out_had_GCT1_SLR3_posEta.push_back(buffer_had_GCT1_SLR3_posEta[iRCT][iCluster]);
0402       out_had_GCT1_SLR3_negEta.push_back(buffer_had_GCT1_SLR3_negEta[iRCT][iCluster]);
0403       out_had_GCT2_SLR1_posEta.push_back(buffer_had_GCT2_SLR1_posEta[iRCT][iCluster]);
0404       out_had_GCT2_SLR1_negEta.push_back(buffer_had_GCT2_SLR1_negEta[iRCT][iCluster]);
0405       out_had_GCT2_SLR3_posEta.push_back(buffer_had_GCT2_SLR3_posEta[iRCT][iCluster]);
0406       out_had_GCT2_SLR3_negEta.push_back(buffer_had_GCT2_SLR3_negEta[iRCT][iCluster]);
0407       out_had_GCT3_SLR1_posEta.push_back(buffer_had_GCT3_SLR1_posEta[iRCT][iCluster]);
0408       out_had_GCT3_SLR1_negEta.push_back(buffer_had_GCT3_SLR1_negEta[iRCT][iCluster]);
0409       out_had_GCT3_SLR3_posEta.push_back(buffer_had_GCT3_SLR3_posEta[iRCT][iCluster]);
0410       out_had_GCT3_SLR3_negEta.push_back(buffer_had_GCT3_SLR3_negEta[iRCT][iCluster]);
0411     }
0412   }
0413 
0414   // Finally, push back the SLR containers
0415   outputEmClusters->push_back(out_eg_GCT1_SLR1_posEta);
0416   outputEmClusters->push_back(out_eg_GCT1_SLR1_negEta);
0417   outputEmClusters->push_back(out_eg_GCT1_SLR3_posEta);
0418   outputEmClusters->push_back(out_eg_GCT1_SLR3_negEta);
0419   outputEmClusters->push_back(out_eg_GCT2_SLR1_posEta);
0420   outputEmClusters->push_back(out_eg_GCT2_SLR1_negEta);
0421   outputEmClusters->push_back(out_eg_GCT2_SLR3_posEta);
0422   outputEmClusters->push_back(out_eg_GCT2_SLR3_negEta);
0423   outputEmClusters->push_back(out_eg_GCT3_SLR1_posEta);
0424   outputEmClusters->push_back(out_eg_GCT3_SLR1_negEta);
0425   outputEmClusters->push_back(out_eg_GCT3_SLR3_posEta);
0426   outputEmClusters->push_back(out_eg_GCT3_SLR3_negEta);
0427 
0428   outputHadClusters->push_back(out_had_GCT1_SLR1_posEta);
0429   outputHadClusters->push_back(out_had_GCT1_SLR1_negEta);
0430   outputHadClusters->push_back(out_had_GCT1_SLR3_posEta);
0431   outputHadClusters->push_back(out_had_GCT1_SLR3_negEta);
0432   outputHadClusters->push_back(out_had_GCT2_SLR1_posEta);
0433   outputHadClusters->push_back(out_had_GCT2_SLR1_negEta);
0434   outputHadClusters->push_back(out_had_GCT2_SLR3_posEta);
0435   outputHadClusters->push_back(out_had_GCT2_SLR3_negEta);
0436   outputHadClusters->push_back(out_had_GCT3_SLR1_posEta);
0437   outputHadClusters->push_back(out_had_GCT3_SLR1_negEta);
0438   outputHadClusters->push_back(out_had_GCT3_SLR3_posEta);
0439   outputHadClusters->push_back(out_had_GCT3_SLR3_negEta);
0440 
0441   iEvent.put(std::move(outputEmClusters), "GCTEmDigiClusters");
0442   iEvent.put(std::move(outputHadClusters), "GCTHadDigiClusters");
0443 }
0444 
0445 //define this as a plug-in
0446 DEFINE_FWK_MODULE(Phase2GCTBarrelToCorrelatorLayer1);
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.2.1 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!