Back to home page

Project CMSSW displayed by LXR

 
 

    


File indexing completed on 2022-05-31 22:25:56

0001 #include "FWCore/Framework/interface/one/EDAnalyzer.h"
0002 #include "FWCore/Framework/interface/Event.h"
0003 #include "FWCore/ParameterSet/interface/ParameterSet.h"
0004 #include "FWCore/MessageLogger/interface/MessageLogger.h"
0005 
0006 #include "FWCore/Framework/interface/EventSetup.h"
0007 #include "FWCore/Framework/interface/ESHandle.h"
0008 
0009 #include "CondFormats/DataRecord/interface/L1TCaloParamsRcd.h"
0010 #include "CondFormats/DataRecord/interface/L1TCaloStage2ParamsRcd.h"
0011 #include "CondFormats/L1TObjects/interface/CaloParams.h"
0012 #include "L1Trigger/L1TCalorimeter/interface/CaloParamsHelper.h"
0013 #include <iomanip>
0014 
0015 class L1TCaloParamsViewer : public edm::one::EDAnalyzer<> {
0016 private:
0017   edm::ESGetToken<l1t::CaloParams, L1TCaloStage2ParamsRcd> stage2ParamsToken_;
0018   edm::ESGetToken<l1t::CaloParams, L1TCaloParamsRcd> paramsToken_;
0019   bool printPUSParams;
0020   bool printTauCalibLUT;
0021   bool printTauCompressLUT;
0022   bool printJetCalibLUT;
0023   bool printJetCalibPar;
0024   bool printJetPUSPar;
0025   bool printJetCompressPtLUT;
0026   bool printJetCompressEtaLUT;
0027   bool printEgCalibLUT;
0028   bool printEgIsoLUT;
0029   bool printEtSumMetPUSLUT;
0030   bool printHfSF;
0031   bool printHcalSF;
0032   bool printEcalSF;
0033   bool printEtSumEttPUSLUT;
0034   bool printEtSumEcalSumPUSLUT;
0035   bool printMetCalibrationLUT;
0036   bool printMetHFCalibrationLUT;
0037   bool printMetPhiCalibrationLUT;
0038   bool printMetHFPhiCalibrationLUT;
0039   bool printEtSumEttCalibrationLUT;
0040   bool printEtSumEcalSumCalibrationLUT;
0041 
0042   bool useStage2Rcd;
0043 
0044   std::string hash(void* buf, size_t len) const;
0045 
0046 public:
0047   void analyze(const edm::Event&, const edm::EventSetup&) override;
0048 
0049   explicit L1TCaloParamsViewer(const edm::ParameterSet& pset) {
0050     printPUSParams = pset.getUntrackedParameter<bool>("printPUSParams", false);
0051     printTauCalibLUT = pset.getUntrackedParameter<bool>("printTauCalibLUT", false);
0052     printTauCompressLUT = pset.getUntrackedParameter<bool>("printTauCompressLUT", false);
0053     printJetCalibLUT = pset.getUntrackedParameter<bool>("printJetCalibLUT", false);
0054     printJetCalibPar = pset.getUntrackedParameter<bool>("printJetCalibParams", false);
0055     printJetPUSPar = pset.getUntrackedParameter<bool>("printJetPUSPar", false);
0056     printJetCompressPtLUT = pset.getUntrackedParameter<bool>("printJetCompressPtLUT", false);
0057     printJetCompressEtaLUT = pset.getUntrackedParameter<bool>("printJetCompressEtaLUT", false);
0058     printEgCalibLUT = pset.getUntrackedParameter<bool>("printEgCalibLUT", false);
0059     printEgIsoLUT = pset.getUntrackedParameter<bool>("printEgIsoLUT", false);
0060     printEtSumMetPUSLUT = pset.getUntrackedParameter<bool>("printEtSumMetPUSLUT", false);
0061     printHfSF = pset.getUntrackedParameter<bool>("printHfSF", false);
0062     printHcalSF = pset.getUntrackedParameter<bool>("printHcalSF", false);
0063     printEcalSF = pset.getUntrackedParameter<bool>("printEcalSF", false);
0064     printEtSumEttPUSLUT = pset.getUntrackedParameter<bool>("printEtSumEttPUSLUT", false);
0065     printEtSumEcalSumPUSLUT = pset.getUntrackedParameter<bool>("printEtSumEcalSumPUSLUT", false);
0066     printMetCalibrationLUT = pset.getUntrackedParameter<bool>("printMetCalibrationLUT", false);
0067     printMetHFCalibrationLUT = pset.getUntrackedParameter<bool>("printMetHFCalibrationLUT", false);
0068     printEtSumEttCalibrationLUT = pset.getUntrackedParameter<bool>("printEtSumEttCalibrationLUT", false);
0069     printEtSumEcalSumCalibrationLUT = pset.getUntrackedParameter<bool>("printEtSumEcalSumCalibrationLUT", false);
0070 
0071     useStage2Rcd = pset.getUntrackedParameter<bool>("useStage2Rcd", false);
0072 
0073     if (useStage2Rcd)
0074       stage2ParamsToken_ = esConsumes();
0075     else
0076       paramsToken_ = esConsumes();
0077   }
0078 
0079   ~L1TCaloParamsViewer(void) override {}
0080 };
0081 
0082 #include "Utilities/OpenSSL/interface/openssl_init.h"
0083 #include <cmath>
0084 #include <iostream>
0085 using namespace std;
0086 
0087 std::string L1TCaloParamsViewer::hash(void* buf, size_t len) const {
0088   cms::openssl_init();
0089   EVP_MD_CTX* mdctx = EVP_MD_CTX_new();
0090   const EVP_MD* md = EVP_get_digestbyname("SHA1");
0091   if (!EVP_DigestInit_ex(mdctx, md, nullptr))
0092     throw cms::Exception("L1TCaloParamsViewer::hash") << "SHA1 initialization error";
0093 
0094   if (!EVP_DigestUpdate(mdctx, buf, len))
0095     throw cms::Exception("L1TCaloParamsViewer::hash") << "SHA1 processing error";
0096 
0097   unsigned char hash[EVP_MAX_MD_SIZE];
0098   unsigned int md_len = 0;
0099   if (!EVP_DigestFinal_ex(mdctx, hash, &md_len))
0100     throw cms::Exception("L1TCaloParamsViewer::hash") << "SHA1 finalization error";
0101 
0102   EVP_MD_CTX_free(mdctx);
0103 
0104   // re-write bytes in hex
0105   char tmp[EVP_MAX_MD_SIZE * 2 + 1];
0106   if (md_len > 20)
0107     md_len = 20;
0108   for (unsigned int i = 0; i < md_len; i++)
0109     ::sprintf(&tmp[i * 2], "%02x", hash[i]);
0110 
0111   tmp[md_len * 2] = 0;
0112   return std::string(tmp);
0113 }
0114 
0115 void L1TCaloParamsViewer::analyze(const edm::Event& iEvent, const edm::EventSetup& evSetup) {
0116   edm::ESHandle<l1t::CaloParams> handle1;
0117   if (useStage2Rcd)
0118     handle1 = evSetup.getHandle(stage2ParamsToken_);
0119   else
0120     handle1 = evSetup.getHandle(paramsToken_);
0121 
0122   l1t::CaloParams const& ptr = *handle1;
0123 
0124   l1t::CaloParamsHelper const* ptr1 = nullptr;
0125   ptr1 = (l1t::CaloParamsHelper const*)(&(ptr));
0126 
0127   edm::LogInfo("") << "L1TCaloParamsViewer:";
0128 
0129   cout << endl << " Towers: " << endl;
0130   cout << "  towerLsbH=       " << ptr1->towerLsbH() << endl;
0131   cout << "  towerLsbE=       " << ptr1->towerLsbE() << endl;
0132   cout << "  towerLsbSum=     " << ptr1->towerLsbSum() << endl;
0133   cout << "  towerNBitsH=     " << ptr1->towerNBitsH() << endl;
0134   cout << "  towerNBitsE=     " << ptr1->towerNBitsE() << endl;
0135   cout << "  towerNBitsSum=   " << ptr1->towerNBitsSum() << endl;
0136   cout << "  towerNBitsRatio= " << ptr1->towerNBitsRatio() << endl;
0137   cout << "  towerMaskE=      " << ptr1->towerMaskE() << endl;
0138   cout << "  towerMaskH=      " << ptr1->towerMaskH() << endl;
0139   cout << "  towerMaskSum=    " << ptr1->towerMaskSum() << endl;
0140   cout << "  towerEncoding=    " << ptr1->doTowerEncoding() << endl;
0141 
0142   cout << endl << " Regions: " << endl;
0143   cout << "  regionLsb=       " << ptr1->regionLsb() << endl;
0144   cout << "  regionPUSType=   " << ptr1->regionPUSType() << endl;
0145   cout << "  regionPUSParams= [" << ptr1->regionPUSParams().size() << "] ";
0146   float pusParams[ptr1->regionPUSParams().size()];
0147   for (unsigned int i = 0; i < ptr1->regionPUSParams().size(); i++) {
0148     pusParams[i] = ceil(2 * ptr1->regionPUSParams()[i]);
0149     if (printPUSParams)
0150       cout << "   " << ceil(2 * pusParams[i]) << endl;
0151   }
0152 
0153   if (!ptr1->regionPUSParams().empty())
0154     cout << hash(pusParams, sizeof(float) * ptr1->regionPUSParams().size()) << endl;
0155   else
0156     cout << endl;
0157 
0158   if (!ptr1->regionPUSLUT()->empty()) {
0159     cout << "  regionPUSLUT=         [" << ptr1->regionPUSLUT()->maxSize() << "] ";
0160     int regionPUSLUT[ptr1->regionPUSLUT()->maxSize()];
0161     for (unsigned int i = 0; i < ptr1->regionPUSLUT()->maxSize(); i++)
0162       regionPUSLUT[i] = ptr1->regionPUSLUT()->data(i);
0163     cout << hash(regionPUSLUT, sizeof(int) * ptr1->regionPUSLUT()->maxSize()) << endl;
0164   } else {
0165     cout << "  regionPUSLUT=         [0]" << endl;
0166   }
0167 
0168   cout << "  pileUpTowerThreshold= " << ptr1->pileUpTowerThreshold() << endl;
0169 
0170   cout << endl << " EG: " << endl;
0171   cout << "  egLsb=                  " << ptr1->egLsb() << endl;
0172   cout << "  egSeedThreshold=        " << ptr1->egSeedThreshold() << endl;
0173   cout << "  egNeighbourThreshold=   " << ptr1->egNeighbourThreshold() << endl;
0174   cout << "  egHcalThreshold=        " << ptr1->egHcalThreshold() << endl;
0175 
0176   if (!ptr1->egTrimmingLUT()->empty()) {
0177     cout << "  egTrimmingLUT=          [" << ptr1->egTrimmingLUT()->maxSize() << "] " << flush;
0178     int egTrimming[ptr1->egTrimmingLUT()->maxSize()];
0179     for (unsigned int i = 0; i < ptr1->egTrimmingLUT()->maxSize(); i++)
0180       egTrimming[i] = ptr1->egTrimmingLUT()->data(i);
0181     cout << hash(egTrimming, sizeof(int) * ptr1->egTrimmingLUT()->maxSize()) << endl;
0182   } else {
0183     cout << "  egTrimmingLUT=          [0] " << endl;
0184   }
0185 
0186   cout << "  egMaxHcalEt=            " << ptr1->egMaxHcalEt() << endl;
0187   cout << "  egMaxPtHOverE=          " << ptr1->egMaxPtHOverE() << endl;
0188   cout << "  egMinPtJetIsolation=    " << ptr1->egMinPtJetIsolation() << endl;
0189   cout << "  egMaxPtJetIsolation=    " << ptr1->egMaxPtJetIsolation() << endl;
0190   cout << "  egMinPtHOverEIsolation= " << ptr1->egMinPtHOverEIsolation() << endl;
0191   cout << "  egMaxPtHOverEIsolation= " << ptr1->egMaxPtHOverEIsolation() << endl;
0192 
0193   if (!ptr1->egMaxHOverELUT()->empty()) {
0194     cout << "  egMaxHOverELUT=         [" << ptr1->egMaxHOverELUT()->maxSize() << "] ";
0195     int egMaxHOverE[ptr1->egMaxHOverELUT()->maxSize()];
0196     for (unsigned int i = 0; i < ptr1->egMaxHOverELUT()->maxSize(); i++)
0197       egMaxHOverE[i] = ptr1->egMaxHOverELUT()->data(i);
0198     cout << hash(egMaxHOverE, sizeof(int) * ptr1->egMaxHOverELUT()->maxSize()) << endl;
0199   } else {
0200     cout << "  egMaxHOverELUT=         [0]" << endl;
0201   }
0202 
0203   if (!ptr1->egCompressShapesLUT()->empty()) {
0204     cout << "  egCompressShapesLUT=    [" << ptr1->egCompressShapesLUT()->maxSize() << "] ";
0205     int egCompressShapes[ptr1->egCompressShapesLUT()->maxSize()];
0206     for (unsigned int i = 0; i < ptr1->egCompressShapesLUT()->maxSize(); i++)
0207       egCompressShapes[i] = ptr1->egCompressShapesLUT()->data(i);
0208     cout << hash(egCompressShapes, sizeof(int) * ptr1->egCompressShapesLUT()->maxSize()) << endl;
0209   } else {
0210     cout << "  egCompressShapesLUT=    [0]" << endl;
0211   }
0212 
0213   cout << "  egShapeIdType=          " << ptr1->egShapeIdType() << endl;
0214   cout << "  egShapeIdVersion=       " << ptr1->egShapeIdVersion() << endl;
0215   if (!ptr1->egShapeIdLUT()->empty()) {
0216     cout << "  egShapeIdLUT=           [" << ptr1->egShapeIdLUT()->maxSize() << "] " << flush;
0217     int egShapeId[ptr1->egShapeIdLUT()->maxSize()];
0218     for (unsigned int i = 0; i < ptr1->egShapeIdLUT()->maxSize(); i++)
0219       egShapeId[i] = ptr1->egShapeIdLUT()->data(i);
0220     cout << hash(egShapeId, sizeof(int) * ptr1->egShapeIdLUT()->maxSize()) << endl;
0221   } else {
0222     cout << "  egShapeIdLUT=           [0]" << endl;
0223   }
0224 
0225   cout << "  egBypassEGVetos=        " << ptr1->egBypassEGVetos() << endl;
0226   cout << "  egBypassShape=          " << ptr1->egBypassShape() << endl;
0227   cout << "  egBypassExtHoverE=      " << ptr1->egBypassExtHOverE() << endl;
0228   cout << "  egBypassECALFG=         " << ptr1->egBypassECALFG() << endl;
0229   cout << "  egHOverEcutBarrel=      " << ptr1->egHOverEcutBarrel() << endl;
0230   cout << "  egHOverEcutEndcap=      " << ptr1->egHOverEcutEndcap() << endl;
0231 
0232   cout << "  egPUSType=              " << ptr1->egPUSType() << endl;
0233 
0234   cout << "  egIsolationType=        " << ptr1->egIsolationType() << endl;
0235   if (!ptr1->egIsolationLUT()->empty()) {
0236     cout << "  egIsoLUT=               [" << ptr1->egIsolationLUT()->maxSize() << "] " << flush;
0237     int egIsolation[ptr1->egIsolationLUT()->maxSize()];
0238     for (unsigned int i = 0; i < ptr1->egIsolationLUT()->maxSize(); i++)
0239       egIsolation[i] = ptr1->egIsolationLUT()->data(i);
0240     cout << hash(egIsolation, sizeof(int) * ptr1->egIsolationLUT()->maxSize()) << endl;
0241     if (printEgIsoLUT)
0242       for (unsigned int i = 0; i < ptr1->egIsolationLUT()->maxSize(); i++)
0243         cout << i << " " << egIsolation[i] << endl;
0244   } else {
0245     cout << "  egIsoLUT=               [0]" << endl;
0246   }
0247   if (!ptr1->egIsolationLUT2()->empty()) {
0248     cout << "  egIsoLUT2=              [" << ptr1->egIsolationLUT2()->maxSize() << "] " << flush;
0249     int egIsolation2[ptr1->egIsolationLUT2()->maxSize()];
0250     for (unsigned int i = 0; i < ptr1->egIsolationLUT2()->maxSize(); i++)
0251       egIsolation2[i] = ptr1->egIsolationLUT2()->data(i);
0252     cout << hash(egIsolation2, sizeof(int) * ptr1->egIsolationLUT2()->maxSize()) << endl;
0253     if (printEgIsoLUT)
0254       for (unsigned int i = 0; i < ptr1->egIsolationLUT2()->maxSize(); i++)
0255         cout << i << " " << egIsolation2[i] << endl;
0256   } else {
0257     cout << "  egIsoLUT2=              [0]" << endl;
0258   }
0259 
0260   cout << "  egIsoAreaNrTowersEta=   " << ptr1->egIsoAreaNrTowersEta() << endl;
0261   cout << "  egIsoAreaNrTowersPhi=   " << ptr1->egIsoAreaNrTowersPhi() << endl;
0262   cout << "  egIsoVetoNrTowersPhi=   " << ptr1->egIsoVetoNrTowersPhi() << endl;
0263   cout << "  egPUSParams=            [" << ptr1->egPUSParams().size() << "] " << flush;
0264   float egPUSParams[ptr1->egPUSParams().size()];
0265   for (unsigned int i = 0; i < ptr1->egPUSParams().size(); i++)
0266     egPUSParams[i] = ptr1->egPUSParams()[i];
0267 
0268   if (!ptr1->egPUSParams().empty())
0269     cout << hash(egPUSParams, sizeof(float) * ptr1->egPUSParams().size()) << endl;
0270   else
0271     cout << endl;
0272 
0273   cout << "  egCalibrationParams=    [" << ptr1->egCalibrationParams().size() << "] " << flush;
0274   double egCalibrationParams[ptr1->egCalibrationParams().size()];
0275   for (unsigned int i = 0; i < ptr1->egCalibrationParams().size(); i++)
0276     egCalibrationParams[i] = ptr1->egCalibrationParams()[i];
0277 
0278   if (!ptr1->egCalibrationParams().empty())
0279     cout << hash(egCalibrationParams, sizeof(double) * ptr1->egCalibrationParams().size()) << endl;
0280   else
0281     cout << endl;
0282 
0283   cout << "  egCalibrationType=      " << ptr1->egCalibrationType() << endl;
0284   cout << "  egCalibrationVersion=   " << ptr1->egCalibrationVersion() << endl;
0285   if (!ptr1->egCalibrationLUT()->empty()) {
0286     cout << "  egCalibrationLUT=       [" << ptr1->egCalibrationLUT()->maxSize() << "] " << flush;
0287     int egCalibration[ptr1->egCalibrationLUT()->maxSize()];
0288     for (unsigned int i = 0; i < ptr1->egCalibrationLUT()->maxSize(); i++)
0289       egCalibration[i] = ptr1->egCalibrationLUT()->data(i);
0290     cout << hash(egCalibration, sizeof(int) * ptr1->egCalibrationLUT()->maxSize()) << endl;
0291     if (printEgCalibLUT)
0292       for (unsigned int i = 0; i < ptr1->egCalibrationLUT()->maxSize(); i++)
0293         cout << i << " " << egCalibration[i] << endl;
0294   } else {
0295     cout << "  egCalibrationLUT=       [0]" << endl;
0296   }
0297 
0298   cout << endl << " Tau: " << endl;
0299   cout << "  tauLsb=                 " << ptr1->tauLsb() << endl;
0300   //cout<<"  tauSeedThreshold=       "<<ptr1->tauSeedThreshold()<<endl;
0301   //cout<<"  tauNeighbourThreshold=  "<<ptr1->tauNeighbourThreshold()<<endl;
0302   cout << "  tauMaxPtTauVeto=        " << ptr1->tauMaxPtTauVeto() << endl;
0303   cout << "  tauMinPtJetIsolationB=  " << ptr1->tauMinPtJetIsolationB() << endl;
0304   cout << "  tauPUSType=             " << ptr1->tauPUSType() << endl;
0305   cout << "  tauMaxJetIsolationB=    " << ptr1->tauMaxJetIsolationB() << endl;
0306   cout << "  tauMaxJetIsolationA=    " << ptr1->tauMaxJetIsolationA() << endl;
0307   cout << "  tauIsoAreaNrTowersEta=  " << ptr1->tauIsoAreaNrTowersEta() << endl;
0308   cout << "  tauIsoAreaNrTowersPhi=  " << ptr1->tauIsoAreaNrTowersPhi() << endl;
0309   cout << "  tauIsoVetoNrTowersPhi=  " << ptr1->tauIsoVetoNrTowersPhi() << endl;
0310   if (!ptr1->tauIsolationLUT()->empty()) {
0311     cout << "  tauIsoLUT=              [" << ptr1->tauIsolationLUT()->maxSize() << "] " << flush;
0312     int tauIsolation[ptr1->tauIsolationLUT()->maxSize()];
0313     for (unsigned int i = 0; i < ptr1->tauIsolationLUT()->maxSize(); i++)
0314       tauIsolation[i] = ptr1->tauIsolationLUT()->data(i);
0315     cout << hash(tauIsolation, sizeof(int) * ptr1->tauIsolationLUT()->maxSize()) << endl;
0316   } else {
0317     cout << "  tauIsoLUT=              [0]" << endl;
0318   }
0319   if (!ptr1->tauIsolationLUT2()->empty()) {
0320     cout << "  tauIsoLUT2=             [" << ptr1->tauIsolationLUT2()->maxSize() << "] " << flush;
0321     int tauIsolation2[ptr1->tauIsolationLUT2()->maxSize()];
0322     for (unsigned int i = 0; i < ptr1->tauIsolationLUT2()->maxSize(); i++)
0323       tauIsolation2[i] = ptr1->tauIsolationLUT2()->data(i);
0324     cout << hash(tauIsolation2, sizeof(int) * ptr1->tauIsolationLUT2()->maxSize()) << endl;
0325   } else {
0326     cout << "  tauIsoLUT2=             [0]" << endl;
0327   }
0328   if (!ptr1->tauTrimmingShapeVetoLUT()->empty()) {
0329     cout << "  tauTrimmingShapeVetoLUT=[" << ptr1->tauTrimmingShapeVetoLUT()->maxSize() << "] " << flush;
0330     int tauTrimmingShapeVetoLUT[ptr1->tauTrimmingShapeVetoLUT()->maxSize()];
0331     for (unsigned int i = 0; i < ptr1->tauTrimmingShapeVetoLUT()->maxSize(); i++)
0332       tauTrimmingShapeVetoLUT[i] = ptr1->tauTrimmingShapeVetoLUT()->data(i);
0333     cout << hash(tauTrimmingShapeVetoLUT, sizeof(int) * ptr1->tauTrimmingShapeVetoLUT()->maxSize()) << endl;
0334   } else {
0335     cout << "  tauTrimmingShapeVetoLUT=[0]" << endl;
0336   }
0337 
0338   if (!ptr1->tauCalibrationLUT()->empty()) {
0339     cout << "  tauCalibrationLUT=      [" << ptr1->tauCalibrationLUT()->maxSize() << "] " << flush;
0340     int tauCalibration[512];                //ptr1->tauCalibrationLUT()->maxSize()];
0341     for (unsigned int i = 0; i < 512; i++)  //ptr1->tauCalibrationLUT()->maxSize(); i++)
0342       tauCalibration[i] = ptr1->tauCalibrationLUT()->data(i);
0343     cout << hash(tauCalibration, sizeof(int) * 512 /*ptr1->tauCalibrationLUT()->maxSize() */) << endl;
0344 
0345     if (printTauCalibLUT)
0346       for (unsigned int i = 0; i < 512 /*ptr1->tauCalibrationLUT()->maxSize()*/; i++)
0347         cout << i << " " << tauCalibration[i] << endl;
0348 
0349   } else {
0350     cout << "  tauCalibrationLUT=      [0]" << endl;
0351   }
0352 
0353   cout << "  tauCalibrationType=     " << ptr1->tauCalibrationType() << endl;
0354 
0355   cout << "  tauCalibrationParams=   [" << ptr1->tauCalibrationParams().size() << "] " << flush;
0356   double tauCalibrationParams[ptr1->tauCalibrationParams().size()];
0357   for (unsigned int i = 0; i < ptr1->tauCalibrationParams().size(); i++)
0358     tauCalibrationParams[i] = ptr1->tauCalibrationParams()[i];
0359 
0360   if (!ptr1->tauCalibrationParams().empty())
0361     cout << hash(tauCalibrationParams, sizeof(double) * ptr1->tauCalibrationParams().size()) << endl;
0362   else
0363     cout << endl;
0364 
0365   if (!ptr1->tauCompressLUT()->empty()) {
0366     cout << "  tauCompressLUT=         [" << ptr1->tauCompressLUT()->maxSize() << "] " << flush;
0367     int tauCompress[ptr1->tauCompressLUT()->maxSize()];
0368     for (unsigned int i = 0; i < ptr1->tauCompressLUT()->maxSize(); i++)
0369       tauCompress[i] = ptr1->tauCompressLUT()->data(i);
0370     cout << hash(tauCompress, sizeof(int) * ptr1->tauCompressLUT()->maxSize()) << endl;
0371 
0372     if (printTauCompressLUT)
0373       for (unsigned int i = 0; i < ptr1->tauCompressLUT()->maxSize(); i++)
0374         cout << i << " " << tauCompress[i] << endl;
0375 
0376   } else {
0377     cout << "  tauCompressLUT=         [0]" << endl;
0378   }
0379 
0380   if (!ptr1->tauEtToHFRingEtLUT()->empty()) {
0381     cout << "  tauEtToHFRingEtLUT=     [" << ptr1->tauEtToHFRingEtLUT()->maxSize() << "] " << flush;
0382     int tauEtToHFRingEt[ptr1->tauEtToHFRingEtLUT()->maxSize()];
0383     for (unsigned int i = 0; i < ptr1->tauEtToHFRingEtLUT()->maxSize(); i++)
0384       tauEtToHFRingEt[i] = ptr1->tauEtToHFRingEtLUT()->data(i);
0385 
0386     cout << hash(tauEtToHFRingEt, sizeof(int) * ptr1->tauEtToHFRingEtLUT()->maxSize()) << endl;
0387   } else {
0388     cout << "  tauEtToHFRingEtLUT=     [0]" << endl;
0389   }
0390 
0391   cout << "  isoTauEtaMin=           " << ptr1->isoTauEtaMin() << endl;
0392   cout << "  isoTauEtaMax=           " << ptr1->isoTauEtaMax() << endl;
0393   cout << "  tauPUSParams=           [" << ptr1->tauPUSParams().size() << "] " << flush;
0394   float tauPUSParams[ptr1->tauPUSParams().size()];
0395   for (unsigned int i = 0; i < ptr1->tauPUSParams().size(); i++)
0396     tauPUSParams[i] = ptr1->tauPUSParams()[i];
0397 
0398   if (!ptr1->tauPUSParams().empty())
0399     cout << hash(tauPUSParams, sizeof(float) * ptr1->tauPUSParams().size()) << endl;
0400   else
0401     cout << endl;
0402 
0403   cout << endl << " Jets: " << endl;
0404   cout << "  jetLsb=                 " << ptr1->jetLsb() << endl;
0405   cout << "  jetSeedThreshold=       " << ptr1->jetSeedThreshold() << endl;
0406   cout << "  jetNeighbourThreshold=  " << ptr1->jetNeighbourThreshold() << endl;
0407   cout << "  jetRegionMask=          " << ptr1->jetRegionMask() << endl;
0408   cout << "  jetBypassPUS=           " << ptr1->jetBypassPUS() << endl;
0409   //cout<<"  jetPUSType=             "<<ptr1->jetPUSType()<<endl;
0410   cout << "  jetPUSUsePhiRing=       " << ptr1->jetPUSUsePhiRing() << endl;
0411   cout << "  jetCalibrationType=     " << ptr1->jetCalibrationType() << endl;
0412   //cout<<"  jetCalibrationParams=   ["<<ptr1->jetCalibrationParams().size()<<"] "<<flush;
0413   //float jetCalibrationParams[ptr1->jetCalibrationParams().size()]; // deliberately drop double precision
0414   //for(unsigned int i=0; i<ptr1->jetCalibrationParams().size(); i++) jetCalibrationParams[i] = ptr1->jetCalibrationParams()[i];
0415 
0416   /*if( !ptr1->jetCalibrationParams().empty() ){
0417         cout << hash( jetCalibrationParams, sizeof(float)*ptr1->jetCalibrationParams().size() ) << endl;
0418         if( printJetCalibPar )
0419             for(unsigned int i=0; i<ptr1->jetCalibrationParams().size(); i++)
0420                 cout<<i<<" " << std::setprecision(14) << jetCalibrationParams[i]<<endl;
0421 
0422     } else cout<<endl;
0423 
0424     cout<<"  jetPUSParams=           ["<<ptr1->jetPUSParams().size()<<"] "<<flush;
0425     float jetPUSParams[ptr1->jetPUSParams().size()]; // deliberately drop double precision
0426     for(unsigned int i=0; i<ptr1->jetPUSParams().size(); i++) jetPUSParams[i] = ptr1->jetPUSParams()[i];
0427     if( !ptr1->jetPUSParams().empty() ){
0428         cout << hash( jetPUSParams, sizeof(float)*ptr1->jetPUSParams().size() ) << endl;
0429         if( printJetPUSPar )
0430             for(unsigned int i=0; i<ptr1->jetPUSParams().size(); i++)
0431                 cout<<i<<" " << std::setprecision(14) << jetPUSParams[i]<<endl;
0432 
0433     } else cout<<endl;
0434     */
0435 
0436   if (!ptr1->jetCalibrationLUT()->empty()) {
0437     cout << "  jetCalibrationLUT=      [" << ptr1->jetCalibrationLUT()->maxSize() << "] " << flush;
0438     int jetCalibration[ptr1->jetCalibrationLUT()->maxSize()];
0439     for (unsigned int i = 0; i < ptr1->jetCalibrationLUT()->maxSize(); i++)
0440       jetCalibration[i] = ptr1->jetCalibrationLUT()->data(i);
0441 
0442     cout << hash(jetCalibration, sizeof(int) * ptr1->jetCalibrationLUT()->maxSize()) << endl;
0443 
0444     if (printJetCalibLUT)
0445       for (unsigned int i = 0; i < ptr1->jetCalibrationLUT()->maxSize(); i++)
0446         cout << i << " " << jetCalibration[i] << endl;
0447 
0448   } else {
0449     cout << "  jetCalibrationLUT=      [0]" << endl;
0450   }
0451 
0452   if (!ptr1->jetCompressPtLUT()->empty()) {
0453     cout << "  jetCompressPtLUT=       [" << ptr1->jetCompressPtLUT()->maxSize() << "] " << flush;
0454     int jetCompressPt[ptr1->jetCompressPtLUT()->maxSize()];
0455     for (unsigned int i = 0; i < ptr1->jetCompressPtLUT()->maxSize(); i++)
0456       jetCompressPt[i] = ptr1->jetCompressPtLUT()->data(i);
0457 
0458     cout << hash(jetCompressPt, sizeof(int) * ptr1->jetCompressPtLUT()->maxSize()) << endl;
0459 
0460     if (printJetCompressPtLUT)
0461       for (unsigned int i = 0; i < ptr1->jetCompressPtLUT()->maxSize(); i++)
0462         cout << i << " " << jetCompressPt[i] << endl;
0463 
0464   } else {
0465     cout << "  jetCompressPtLUT=       [0]" << endl;
0466   }
0467 
0468   if (!ptr1->jetCompressEtaLUT()->empty()) {
0469     cout << "  jetCompressEtaLUT=      [" << ptr1->jetCompressEtaLUT()->maxSize() << "] " << flush;
0470     int jetCompressEta[ptr1->jetCompressEtaLUT()->maxSize()];
0471     for (unsigned int i = 0; i < ptr1->jetCompressEtaLUT()->maxSize(); i++)
0472       jetCompressEta[i] = ptr1->jetCompressEtaLUT()->data(i);
0473 
0474     cout << hash(jetCompressEta, sizeof(int) * ptr1->jetCompressEtaLUT()->maxSize()) << endl;
0475 
0476     if (printJetCompressEtaLUT)
0477       for (unsigned int i = 0; i < ptr1->jetCompressEtaLUT()->maxSize(); i++)
0478         cout << i << " " << jetCompressEta[i] << endl;
0479 
0480   } else {
0481     cout << "  jetCompressEtaLUT=      [0]" << endl;
0482   }
0483 
0484   cout << endl << " Sums: " << endl;
0485   unsigned int nEntities = 0;
0486   cout << "  etSumLsb=               " << ptr1->etSumLsb() << endl;
0487   cout << "  etSumEtaMin=            [";
0488   for (unsigned int i = 0; ptr1->etSumEtaMin(i) > 0.001; i++)
0489     cout << (i == 0 ? "" : ",") << ptr1->etSumEtaMin(i);
0490   cout << "]" << endl;
0491   cout << "  etSumEtaMax=            [";
0492   for (unsigned int i = 0; ptr1->etSumEtaMax(i) > 0.001; i++, nEntities++)
0493     cout << (i == 0 ? "" : ",") << ptr1->etSumEtaMax(i);
0494   cout << "]" << endl;
0495   cout << "  etSumEtThreshold=       [";
0496   for (unsigned int i = 0; i < nEntities; i++)
0497     cout << (i == 0 ? "" : ",") << ptr1->etSumEtThreshold(i);
0498   cout << "]" << endl;
0499 
0500   cout << "  etSumBypassMetPUS=      " << ptr1->etSumBypassMetPUS() << endl;
0501   cout << "  etSumBypassEttPUS=      " << ptr1->etSumBypassEttPUS() << endl;
0502   cout << "  etSumBypassEcalSumPUS   " << ptr1->etSumBypassEcalSumPUS() << endl;
0503 
0504   cout << "  etSumMetPUSType=        " << ptr1->etSumMetPUSType() << endl;
0505   cout << "  etSumEttPUSType=        " << ptr1->etSumEttPUSType() << endl;
0506   cout << "  etSumEcalSumPUSType=    " << ptr1->etSumEcalSumPUSType() << endl;
0507 
0508   cout << "  etSumCentralityUpper=   [";
0509   for (unsigned int i = 0; ptr1->etSumCentUpper(i) > 0.001; i++)
0510     cout << (i == 0 ? "" : ",") << ptr1->etSumCentUpper(i);
0511   cout << "]" << endl;
0512   cout << "  etSumCentralityLower=   [";
0513   for (unsigned int i = 0; ptr1->etSumCentLower(i) > 0.001; i++)
0514     cout << (i == 0 ? "" : ",") << ptr1->etSumCentLower(i);
0515   cout << "]" << endl;
0516 
0517   cout << "  metCalibrationType=  " << ptr1->metCalibrationType() << endl;
0518   cout << "  metHFCalibrationType=  " << ptr1->metHFCalibrationType() << endl;
0519   cout << "  etSumEttCalibrationType=" << ptr1->etSumEttCalibrationType() << endl;
0520   cout << "  etSumEcalSumCalibrationType=" << ptr1->etSumEcalSumCalibrationType() << endl;
0521 
0522   if (!ptr1->etSumMetPUSLUT()->empty()) {
0523     cout << "  etSumMetPUSLUT=         [" << ptr1->etSumMetPUSLUT()->maxSize() << "] " << flush;
0524     int etSumMetPUSLUT[ptr1->etSumMetPUSLUT()->maxSize()];
0525     for (unsigned int i = 0; i < ptr1->etSumMetPUSLUT()->maxSize(); i++)
0526       etSumMetPUSLUT[i] = ptr1->etSumMetPUSLUT()->data(i);
0527 
0528     cout << hash(etSumMetPUSLUT, sizeof(int) * ptr1->etSumMetPUSLUT()->maxSize()) << endl;
0529 
0530     if (printEtSumMetPUSLUT)
0531       for (unsigned int i = 0; i < ptr1->etSumMetPUSLUT()->maxSize(); i++)
0532         cout << i << " " << etSumMetPUSLUT[i] << endl;
0533 
0534   } else {
0535     cout << "  etSumMetPUSLUT=         [0]" << endl;
0536   }
0537 
0538   if (!ptr1->etSumEttPUSLUT()->empty()) {
0539     cout << "  etSumEttPUSLUT=         [" << ptr1->etSumEttPUSLUT()->maxSize() << "] " << flush;
0540     int etSumEttPUSLUT[ptr1->etSumEttPUSLUT()->maxSize()];
0541     for (unsigned int i = 0; i < ptr1->etSumEttPUSLUT()->maxSize(); i++)
0542       etSumEttPUSLUT[i] = ptr1->etSumEttPUSLUT()->data(i);
0543 
0544     cout << hash(etSumEttPUSLUT, sizeof(int) * ptr1->etSumEttPUSLUT()->maxSize()) << endl;
0545 
0546     if (printEtSumEttPUSLUT)
0547       for (unsigned int i = 0; i < ptr1->etSumEttPUSLUT()->maxSize(); i++)
0548         cout << i << " " << etSumEttPUSLUT[i] << endl;
0549 
0550   } else {
0551     cout << "  etSumEttPUSLUT=         [0]" << endl;
0552   }
0553 
0554   if (!ptr1->etSumEcalSumPUSLUT()->empty()) {
0555     cout << "  etSumEcalSumPUSLUT=     [" << ptr1->etSumEcalSumPUSLUT()->maxSize() << "] " << flush;
0556     int etSumEcalSumPUSLUT[ptr1->etSumEcalSumPUSLUT()->maxSize()];
0557     for (unsigned int i = 0; i < ptr1->etSumEcalSumPUSLUT()->maxSize(); i++)
0558       etSumEcalSumPUSLUT[i] = ptr1->etSumEcalSumPUSLUT()->data(i);
0559 
0560     cout << hash(etSumEcalSumPUSLUT, sizeof(int) * ptr1->etSumEcalSumPUSLUT()->maxSize()) << endl;
0561 
0562     if (printEtSumEcalSumPUSLUT)
0563       for (unsigned int i = 0; i < ptr1->etSumEcalSumPUSLUT()->maxSize(); i++)
0564         cout << i << " " << etSumEcalSumPUSLUT[i] << endl;
0565 
0566   } else {
0567     cout << "  etSumEcalSumPUSLUT=     [0]" << endl;
0568   }
0569 
0570   if (!ptr1->metCalibrationLUT()->empty()) {
0571     cout << "  metCalibrationLUT=   [" << ptr1->metCalibrationLUT()->maxSize() << "] " << flush;
0572     int metCalibrationLUT[ptr1->metCalibrationLUT()->maxSize()];
0573     for (unsigned int i = 0; i < ptr1->metCalibrationLUT()->maxSize(); i++)
0574       metCalibrationLUT[i] = ptr1->metCalibrationLUT()->data(i);
0575 
0576     cout << hash(metCalibrationLUT, sizeof(int) * ptr1->metCalibrationLUT()->maxSize()) << endl;
0577 
0578     if (printMetCalibrationLUT)
0579       for (unsigned int i = 0; i < ptr1->metCalibrationLUT()->maxSize(); i++)
0580         cout << i << " " << metCalibrationLUT[i] << endl;
0581 
0582   } else {
0583     cout << "  metCalibrationLUT=   [0]" << endl;
0584   }
0585 
0586   if (!ptr1->metHFCalibrationLUT()->empty()) {
0587     cout << "  metHFCalibrationLUT=   [" << ptr1->metHFCalibrationLUT()->maxSize() << "] " << flush;
0588     int metHFCalibrationLUT[ptr1->metHFCalibrationLUT()->maxSize()];
0589     for (unsigned int i = 0; i < ptr1->metHFCalibrationLUT()->maxSize(); i++)
0590       metHFCalibrationLUT[i] = ptr1->metHFCalibrationLUT()->data(i);
0591 
0592     cout << hash(metHFCalibrationLUT, sizeof(int) * ptr1->metHFCalibrationLUT()->maxSize()) << endl;
0593 
0594     if (printMetHFCalibrationLUT)
0595       for (unsigned int i = 0; i < ptr1->metHFCalibrationLUT()->maxSize(); i++)
0596         cout << i << " " << metHFCalibrationLUT[i] << endl;
0597 
0598   } else {
0599     cout << "  metHFCalibrationLUT=   [0]" << endl;
0600   }
0601 
0602   if (!ptr1->metPhiCalibrationLUT()->empty()) {
0603     cout << "  metPhiCalibrationLUT=   [" << ptr1->metPhiCalibrationLUT()->maxSize() << "] " << flush;
0604     int metPhiCalibrationLUT[ptr1->metPhiCalibrationLUT()->maxSize()];
0605     for (unsigned int i = 0; i < ptr1->metPhiCalibrationLUT()->maxSize(); i++)
0606       metPhiCalibrationLUT[i] = ptr1->metPhiCalibrationLUT()->data(i);
0607 
0608     cout << hash(metPhiCalibrationLUT, sizeof(int) * ptr1->metPhiCalibrationLUT()->maxSize()) << endl;
0609 
0610     if (printMetPhiCalibrationLUT)
0611       for (unsigned int i = 0; i < ptr1->metPhiCalibrationLUT()->maxSize(); i++)
0612         cout << i << " " << metPhiCalibrationLUT[i] << endl;
0613 
0614   } else {
0615     cout << "  metPhiCalibrationLUT=   [0]" << endl;
0616   }
0617 
0618   if (!ptr1->metHFPhiCalibrationLUT()->empty()) {
0619     cout << "  metHFPhiCalibrationLUT=   [" << ptr1->metHFPhiCalibrationLUT()->maxSize() << "] " << flush;
0620     int metHFPhiCalibrationLUT[ptr1->metHFPhiCalibrationLUT()->maxSize()];
0621     for (unsigned int i = 0; i < ptr1->metHFPhiCalibrationLUT()->maxSize(); i++)
0622       metHFPhiCalibrationLUT[i] = ptr1->metHFPhiCalibrationLUT()->data(i);
0623 
0624     cout << hash(metHFPhiCalibrationLUT, sizeof(int) * ptr1->metHFPhiCalibrationLUT()->maxSize()) << endl;
0625 
0626     if (printMetHFCalibrationLUT)
0627       for (unsigned int i = 0; i < ptr1->metHFPhiCalibrationLUT()->maxSize(); i++)
0628         cout << i << " " << metHFPhiCalibrationLUT[i] << endl;
0629 
0630   } else {
0631     cout << "  metHFPhiCalibrationLUT=   [0]" << endl;
0632   }
0633 
0634   if (!ptr1->etSumEttCalibrationLUT()->empty()) {
0635     cout << "  etSumEttCalibrationLUT= [" << ptr1->etSumEttCalibrationLUT()->maxSize() << "] " << flush;
0636     int etSumEttCalibrationLUT[ptr1->etSumEttCalibrationLUT()->maxSize()];
0637     for (unsigned int i = 0; i < ptr1->etSumEttCalibrationLUT()->maxSize(); i++)
0638       etSumEttCalibrationLUT[i] = ptr1->etSumEttCalibrationLUT()->data(i);
0639 
0640     cout << hash(etSumEttCalibrationLUT, sizeof(int) * ptr1->etSumEttCalibrationLUT()->maxSize()) << endl;
0641 
0642     if (printEtSumEttCalibrationLUT)
0643       for (unsigned int i = 0; i < ptr1->etSumEttCalibrationLUT()->maxSize(); i++)
0644         cout << i << " " << etSumEttCalibrationLUT[i] << endl;
0645 
0646   } else {
0647     cout << "  etSumEttCalibrationLUT= [0]" << endl;
0648   }
0649 
0650   if (!ptr1->etSumEcalSumCalibrationLUT()->empty()) {
0651     cout << "  etSumEcalSumCalibrationLUT=[" << ptr1->etSumEttCalibrationLUT()->maxSize() << "] " << flush;
0652     int etSumEcalSumCalibrationLUT[ptr1->etSumEcalSumCalibrationLUT()->maxSize()];
0653     for (unsigned int i = 0; i < ptr1->etSumEcalSumCalibrationLUT()->maxSize(); i++)
0654       etSumEcalSumCalibrationLUT[i] = ptr1->etSumEcalSumCalibrationLUT()->data(i);
0655 
0656     cout << hash(etSumEcalSumCalibrationLUT, sizeof(int) * ptr1->etSumEcalSumCalibrationLUT()->maxSize()) << endl;
0657 
0658     if (printEtSumEcalSumCalibrationLUT)
0659       for (unsigned int i = 0; i < ptr1->etSumEcalSumCalibrationLUT()->maxSize(); i++)
0660         cout << i << " " << etSumEcalSumCalibrationLUT[i] << endl;
0661 
0662   } else {
0663     cout << "  etSumEcalSumCalibrationLUT=[0]" << endl;
0664   }
0665 
0666   cout << endl << " HI centrality trigger: " << endl;
0667   cout << "  centralityLUT=          [";
0668   for (unsigned int i = 0; i < ptr1->centralityLUT()->maxSize(); i++)
0669     cout << (i == 0 ? "" : ",") << ptr1->centralityLUT()->data(i);
0670   cout << "]" << endl;
0671 
0672   std::vector<int> mbt = ptr1->minimumBiasThresholds();
0673   cout << "  minimumBiasThresholds=  [";
0674   for (unsigned int i = 0; i < mbt.size(); i++)
0675     cout << mbt[i];
0676   cout << "]" << endl;
0677 
0678   cout << endl << "centralityRegionMask() = " << ptr1->centralityRegionMask() << endl;
0679   cout << endl << "jetRegionMask() = " << ptr1->jetRegionMask() << endl;
0680   cout << endl << "tauRegionMask() = " << ptr1->tauRegionMask() << endl;
0681 
0682   cout << endl << " HI Q2 trigger: " << endl;
0683   cout << "  q2LUT=                  [";
0684   for (unsigned int i = 0; i < ptr1->q2LUT()->maxSize(); i++)
0685     cout << (i == 0 ? "" : ",") << ptr1->q2LUT()->data(i);
0686   cout << "]" << endl;
0687 
0688   cout << endl << " Layer1: " << endl;
0689   std::vector<double> ecalSF = ptr1->layer1ECalScaleFactors();
0690   cout << "  layer1ECalScaleFactors= [" << ecalSF.size() << "] " << flush;
0691   int _ecalSF[ecalSF.size()];
0692   for (unsigned int i = 0; i < ecalSF.size(); i++)
0693     _ecalSF[i] = int(ecalSF[i] * 100000.);
0694   cout << hash(_ecalSF, sizeof(int) * ecalSF.size()) << endl;
0695   if (printEcalSF) {
0696     cout << endl << "    [" << endl;
0697     for (unsigned int i = 0; i < ecalSF.size(); i++)
0698       cout << (i == 0 ? "" : ",") << int(ecalSF[i] * 1000.) / 1000.;
0699     cout << "]" << endl;
0700   }
0701   std::vector<double> hcalSF = ptr1->layer1HCalScaleFactors();
0702   cout << "  layer1HCalScaleFactors= [" << hcalSF.size() << "] " << flush;
0703   int _hcalSF[hcalSF.size()];
0704   for (unsigned int i = 0; i < hcalSF.size(); i++) {
0705     // round false precision
0706     //        double significand;
0707     //        int    exponent;
0708     //        significand = frexp( hcalSF[i],  &exponent );
0709     //         _hcalSF[i] = ldexp( int(significand*10000)/10000., exponent );
0710     _hcalSF[i] = int(hcalSF[i] * 100000.);
0711   }
0712   cout << hash(_hcalSF, sizeof(int) * hcalSF.size()) << endl;
0713   if (printHcalSF) {
0714     cout << endl << "    [" << endl;
0715     for (unsigned int i = 0; i < hcalSF.size(); i++)
0716       cout << (i == 0 ? "" : ",") << int(hcalSF[i] * 1000.) / 1000.;
0717     cout << "]" << endl;
0718   }
0719   std::vector<double> hfSF = ptr1->layer1HFScaleFactors();
0720   cout << "  layer1HFScaleFactors=   [" << hfSF.size() << "] " << flush;
0721   int _hfSF[hfSF.size()];
0722   for (unsigned int i = 0; i < hfSF.size(); i++)
0723     _hfSF[i] = int(hfSF[i] * 100000.);
0724   cout << hash(_hfSF, sizeof(int) * hfSF.size()) << endl;
0725   if (printHfSF) {
0726     cout << endl << "    [" << endl;
0727     for (unsigned int i = 0; i < hfSF.size(); i++)
0728       cout << (i == 0 ? "" : ",") << int(hfSF[i] * 1000.) / 1000.;
0729     cout << "]" << endl;
0730   }
0731 
0732   std::vector<int> ecalScaleET = ptr1->layer1ECalScaleETBins();
0733   cout << "  layer1ECalScaleETBins=  [";
0734   for (unsigned int i = 0; i < ecalScaleET.size(); i++)
0735     cout << (i == 0 ? "" : ",") << ecalScaleET[i];
0736   cout << "]" << endl;
0737   std::vector<int> hcalScaleET = ptr1->layer1HCalScaleETBins();
0738   cout << "  layer1HCalScaleETBins=  [";
0739   for (unsigned int i = 0; i < hcalScaleET.size(); i++)
0740     cout << (i == 0 ? "" : ",") << hcalScaleET[i];
0741   cout << "]" << endl;
0742   std::vector<int> hfScaleET = ptr1->layer1HFScaleETBins();
0743   cout << "  layer1HFScaleETBins=    [";
0744   for (unsigned int i = 0; i < hfScaleET.size(); i++)
0745     cout << (i == 0 ? "" : ",") << hfScaleET[i];
0746   cout << "]" << endl;
0747 
0748   std::vector<unsigned> layer1ECalScalePhi = ptr1->layer1ECalScalePhiBins();
0749   cout << "  layer1ECalScalePhi=     [";
0750   for (unsigned int i = 0; i < layer1ECalScalePhi.size(); i++)
0751     cout << (i == 0 ? "" : ",") << layer1ECalScalePhi[i];
0752   cout << "]" << endl;
0753   std::vector<unsigned> layer1HCalScalePhi = ptr1->layer1HCalScalePhiBins();
0754   cout << "  layer1HCalScalePhi=     [";
0755   for (unsigned int i = 0; i < layer1HCalScalePhi.size(); i++)
0756     cout << (i == 0 ? "" : ",") << layer1HCalScalePhi[i];
0757   cout << "]" << endl;
0758   std::vector<unsigned> layer1HFScalePhiBins = ptr1->layer1HFScalePhiBins();
0759   cout << "  layer1HFScalePhiBins=   [";
0760   for (unsigned int i = 0; i < layer1HFScalePhiBins.size(); i++)
0761     cout << (i == 0 ? "" : ",") << layer1HFScalePhiBins[i];
0762   cout << "]" << endl;
0763 
0764   //    std::vector<unsigned> layer1SecondStageLUT = ptr1->layer1SecondStageLUT();
0765   //    cout<<"  layer1HFScalePhiBins=   ["; for(unsigned int i=0; i<layer1SecondStageLUT.size(); i++) cout<<(i==0?"":",")<<layer1SecondStageLUT[i]; cout<<"]"<<endl;
0766 }
0767 
0768 #include "FWCore/PluginManager/interface/ModuleDef.h"
0769 #include "FWCore/Framework/interface/MakerMacros.h"
0770 #include "FWCore/Framework/interface/ModuleFactory.h"
0771 
0772 DEFINE_FWK_MODULE(L1TCaloParamsViewer);