EcalSelectiveReadoutValidation.h

Go to the documentation of this file.

#ifndef EcalSelectiveReadoutValidation_H
#define EcalSelectiveReadoutValidation_H

/*
 * \file EcalSelectiveReadoutValidation.h
 *
 *
 */

#include "DQMServices/Core/interface/DQMOneEDAnalyzer.h"

#include "DQMServices/Core/interface/DQMStore.h"

#include "DataFormats/EcalDigi/interface/EcalDigiCollections.h"
#include "SimDataFormats/CaloHit/interface/PCaloHit.h"

#include "DataFormats/EcalDigi/interface/EcalDigiCollections.h"
#include "DataFormats/EcalRecHit/interface/EcalRecHitCollections.h"
#include "DataFormats/FEDRawData/interface/FEDRawDataCollection.h"
#include "DataFormats/EcalDetId/interface/EcalScDetId.h"
#include "DataFormats/EcalDetId/interface/EcalTrigTowerDetId.h"
#include "Geometry/CaloGeometry/interface/CaloGeometry.h"
#include "Geometry/Records/interface/CaloGeometryRecord.h"
#include "Geometry/CaloTopology/interface/EcalTrigTowerConstituentsMap.h"
#include "Geometry/EcalMapping/interface/EcalElectronicsMapping.h"
#include "Geometry/EcalMapping/interface/EcalMappingRcd.h"

#include "CondFormats/EcalObjects/interface/EcalTPGLutIdMap.h"
#include "CondFormats/EcalObjects/interface/EcalTPGLutGroup.h"
#include "CondFormats/EcalObjects/interface/EcalTPGPhysicsConst.h"
#include "CondFormats/DataRecord/interface/EcalTPGLutIdMapRcd.h"
#include "CondFormats/DataRecord/interface/EcalTPGLutGroupRcd.h"
#include "CondFormats/DataRecord/interface/EcalTPGPhysicsConstRcd.h"

#include "CollHandle.h"

#include <string>
#include <set>
#include <fstream>

class EBDetId;
class EEDetId;
class EcalElectronicsMapping;
class EcalTrigTowerConstituentsMap;

class EcalSelectiveReadoutValidation : public DQMOneEDAnalyzer<> {
  typedef EcalRecHitCollection RecHitCollection;
  typedef EcalRecHit RecHit;

public:
  EcalSelectiveReadoutValidation(const edm::ParameterSet& ps);

  ~EcalSelectiveReadoutValidation() override;
  void dqmBeginRun(edm::Run const&, edm::EventSetup const&) override;
  void bookHistograms(DQMStore::IBooker& i, edm::Run const&, edm::EventSetup const&) override;

protected:
  void analyze(edm::Event const& e, edm::EventSetup const& c) override;

  void dqmEndRun(const edm::Run& r, const edm::EventSetup& c) override;

private:
  enum subdet_t { EB, EE };

  template <class T, class U>
  void anaDigi(const T& frame, const U& srFlagColl);

  void anaDigiInit();

  void analyzeDataVolume(const edm::Event& e, const edm::EventSetup& es);

  void analyzeEB(const edm::Event& event, const edm::EventSetup& es);

  void analyzeEE(const edm::Event& event, const edm::EventSetup& es);

  void analyzeTP(const edm::Event& event, const edm::EventSetup& es);

  //  /** Selective Readout decisions Validation
  //    * @param event EDM event
  //    * @param es event setup
  //    */
  //   void SRFlagValidation(const edm::Event& event, const edm::EventSetup& es);

  double frame2Energy(const EcalDataFrame& frame) const;

  template <class T>
  double frame2EnergyForTp(const T& frame, int offset = 0) const;

  //   double getEcalEventSize(double nReadXtals) const{
  //     return getDccOverhead(EB)*nEbDccs+getDccOverhead(EE)*nEeDccs
  //       + nReadXtals*getBytesPerCrystal()
  //       + (nEeRus+nEbRus)*8;
  //   }

  double getEbEventSize(double nReadXtals) const;

  double getEeEventSize(double nReadXtals) const;

  double getDccOverhead(subdet_t subdet) const {
    //  return (subdet==EB?34:25)*8;
    return (subdet == EB ? 34 : 52) * 8;
  }

  double getBytesPerCrystal() const { return 3 * 8; }

  double getDccEventSize(int iDcc0, double nReadXtals) const {
    subdet_t subdet;
    if (iDcc0 < 9 || iDcc0 >= 45) {
      subdet = EE;
    } else {
      subdet = EB;
    }
    //     return getDccOverhead(subdet)+nReadXtals*getBytesPerCrystal()
    //       + getRuCount(iDcc0)*8;
    return getDccOverhead(subdet) + getDccSrDependentPayload(iDcc0, getRuCount(iDcc0), nReadXtals);
  }

  double getDccSrDependentPayload(int iDcc0, double nReadRus, double nReadXtals) const {
    return nReadXtals * getBytesPerCrystal() + nReadRus * 8;
  }

  int getRuCount(int iDcc0) const;

  void readAllCollections(const edm::Event& e);

  void setTtEtSums(const edm::EventSetup& es, const EBDigiCollection& ebDigis, const EEDigiCollection& eeDigis);

  //   /** Retrieves the logical number of the DCC reading a given crystal channel.
  //    * @param xtarId crystal channel identifier
  //    * @return the DCC logical number starting from 1.
  //    */
  //   unsigned dccNum(const DetId& xtalId) const;

  std::pair<int, int> dccCh(const DetId& xtalId) const;

  int iEta2cIndex(int iEta) const { return (iEta < 0) ? iEta + 85 : iEta + 84; }

  int iPhi2cIndex(int iPhi) const {
    //    return iPhi-1;
    int iPhi0 = iPhi - 11;
    if (iPhi0 < 0)
      iPhi0 += 360;
    return iPhi0;
  }

  int iXY2cIndex(int iX) const { return iX - 1; }

  int cIndex2iXY(int iX0) const { return iX0 + 1; }

  int cIndex2iEta(int i) const { return (i < 85) ? i - 85 : i - 84; }

  int cIndex2iPhi(int i) const { return (i + 11) % 360; }

  int iTtEta2cIndex(int iEta) const { return (iEta < 0) ? iEta + 28 : iEta + 27; }

  int iTtPhi2cIndex(int iPhi) const {
    return iPhi - 1;
    //int iPhi0 = iPhi - 3;
    //if(iPhi0<0) iPhi0 += 72;
    //return iPhi0;
  }

  int cIndex2iTtEta(int i) const { return (i < 27) ? i - 28 : i - 27; }

  int cIndex2iTtPhi(int i) const { return i + 1; }


  EcalTrigTowerDetId readOutUnitOf(const EBDetId& xtalId) const;

  EcalScDetId readOutUnitOf(const EEDetId& xtalId) const;

  static int dccZsFIR(const EcalDataFrame& frame,
                      const std::vector<int>& firWeights,
                      int firstFIRSample,
                      bool* saturated = nullptr);

  static std::vector<int> getFIRWeights(const std::vector<double>& normalizedWeights);


  MonitorElement* bookFloat(DQMStore::IBooker&, const std::string& name);

  MonitorElement* book1D(
      DQMStore::IBooker&, const std::string& name, const std::string& title, int nbins, double xmin, double xmax);

  MonitorElement* book2D(DQMStore::IBooker&,
                         const std::string& name,
                         const std::string& title,
                         int nxbins,
                         double xmin,
                         double xmax,
                         int nybins,
                         double ymin,
                         double ymax);

  MonitorElement* bookProfile(
      DQMStore::IBooker&, const std::string& name, const std::string& title, int nbins, double xmin, double xmax);

  MonitorElement* bookProfile2D(DQMStore::IBooker&,
                                const std::string& name,
                                const std::string& title,
                                int nbinx,
                                double xmin,
                                double xmax,
                                int nbiny,
                                double ymin,
                                double ymax,
                                const char* option = "");


  void fill(MonitorElement* me, float x) {
    if (me)
      me->Fill(x);
  }
  void fill(MonitorElement* me, float x, float yw) {
    if (me)
      me->Fill(x, yw);
  }
  void fill(MonitorElement* me, float x, float y, float zw) {
    if (me)
      me->Fill(x, y, zw);
  }
  void fill(MonitorElement* me, float x, float y, float z, float w) {
    if (me)
      me->Fill(x, y, z, w);
  }

  void initAsciiFile();

  void updateL1aRate(const edm::Event& event);

  double getL1aRate() const;

private:
  struct energiesEb_t {
    double simE;      
    double noZsRecE;  
    double recE;      
    //    EBDigiCollection::const_iterator itNoZsFrame; //
    int simHit;   
    double phi;   
    double eta;   
    bool gain12;  //all MGPA samples at gain 12?
  };

  struct energiesEe_t {
    double simE;      
    double noZsRecE;  
    double recE;      
    //    EEDigiCollection::const_iterator itNoZsFrame;
    int simHit;   
    double phi;   
    double eta;   
    bool gain12;  //all MGPA samples at gain 12?
  };

  edm::ESGetToken<CaloGeometry, CaloGeometryRecord> geoToken;
  edm::ESGetToken<EcalElectronicsMapping, EcalMappingRcd> ecalmapping;
  edm::ESGetToken<EcalTrigTowerConstituentsMap, IdealGeometryRecord> hTriggerTowerMap;
  edm::ESGetToken<EcalTPGPhysicsConst, EcalTPGPhysicsConstRcd> physHandle;
  edm::ESGetToken<EcalTPGLutGroup, EcalTPGLutGroupRcd> lutGrpHandle;
  edm::ESGetToken<EcalTPGLutIdMap, EcalTPGLutIdMapRcd> lutMapHandle;

  static const int kByte_ = 1024;

  static const unsigned nDccs_ = 54;

  // = maximum number of RUs read by a DCC
  static const unsigned nDccChs_ = 68;

  //Lower bound of DCC ID range
  static const int minDccId_ = 1;

  //Upper bound of DCC ID range
  static const int maxDccId_ = minDccId_ + nDccs_ - 1;

  static const int nEbDccs = 36;

  static const int nEeDccs = 18;

  static const int nEbRus = 36 * 68;

  static const int nEeRus = 2 * (34 + 32 + 33 + 33 + 32 + 34 + 33 + 34 + 33);

  static const int nDccRus_[nDccs_];

  static const int nEndcaps = 2;

  static const int nEbEta = 170;

  static const int nEbPhi = 360;

  static const int nEeX = 100;

  static const int nEeY = 100;

  static const int ebTtEdge = 5;

  static const int scEdge = 5;

  static const int nOneEeTtEta = 11;

  static const int nEbTtEta = 34;

  static const int nTtEta = 2 * nOneEeTtEta + nEbTtEta;

  static const int nTtPhi = 72;

  static const int nMaxXtalPerRu = 25;
  static const double rad2deg;

  bool verbose_;

  std::string outputFile_;

  bool collNotFoundWarn_;

  std::string srpAlgoErrorLogFileName_;

  std::string srApplicationErrorLogFileName_;

  std::ofstream srpAlgoErrorLog_;

  std::ofstream srApplicationErrorLog_;

  std::ofstream zsErrorLog_;


  CollHandle<EBDigiCollection> ebDigis_;
  CollHandle<EEDigiCollection> eeDigis_;
  CollHandle<EBDigiCollection> ebNoZsDigis_;
  CollHandle<EEDigiCollection> eeNoZsDigis_;
  CollHandle<EBSrFlagCollection> ebSrFlags_;
  CollHandle<EESrFlagCollection> eeSrFlags_;
  CollHandle<EBSrFlagCollection> ebComputedSrFlags_;
  CollHandle<EESrFlagCollection> eeComputedSrFlags_;
  CollHandle<std::vector<PCaloHit>> ebSimHits_;
  CollHandle<std::vector<PCaloHit>> eeSimHits_;
  CollHandle<EcalTrigPrimDigiCollection> tps_;
  CollHandle<RecHitCollection> ebRecHits_;
  CollHandle<RecHitCollection> eeRecHits_;
  CollHandle<FEDRawDataCollection> fedRaw_;


  int64_t tmax;
  int64_t tmin;
  int64_t l1aOfTmin;
  int64_t l1aOfTmax;
  bool l1aRateErr;


  MonitorElement* meDccVol_;
  MonitorElement* meDccLiVol_;
  MonitorElement* meDccHiVol_;
  MonitorElement* meDccVolFromData_;
  MonitorElement* meVol_;
  MonitorElement* meVolB_;
  MonitorElement* meVolE_;
  MonitorElement* meVolBLI_;
  MonitorElement* meVolELI_;
  MonitorElement* meVolLI_;
  MonitorElement* meVolBHI_;
  MonitorElement* meVolEHI_;
  MonitorElement* meVolHI_;
  MonitorElement* meChOcc_;

  MonitorElement* meTp_;
  MonitorElement* meTtf_;
  MonitorElement* meTtfVsTp_;
  MonitorElement* meTtfVsEtSum_;
  MonitorElement* meTpVsEtSum_;

  MonitorElement* meEbRecE_;
  MonitorElement* meEbEMean_;
  MonitorElement* meEbNoise_;
  MonitorElement* meEbSimE_;
  MonitorElement* meEbRecEHitXtal_;
  MonitorElement* meEbRecVsSimE_;
  MonitorElement* meEbNoZsRecVsSimE_;

  MonitorElement* meEeRecE_;
  MonitorElement* meEeEMean_;
  MonitorElement* meEeNoise_;
  MonitorElement* meEeSimE_;
  MonitorElement* meEeRecEHitXtal_;
  MonitorElement* meEeRecVsSimE_;
  MonitorElement* meEeNoZsRecVsSimE_;

  MonitorElement* meFullRoRu_;
  MonitorElement* meZs1Ru_;
  MonitorElement* meForcedRu_;

  MonitorElement* meLiTtf_;
  MonitorElement* meMiTtf_;
  MonitorElement* meHiTtf_;
  MonitorElement* meForcedTtf_;

  MonitorElement* meTpMap_;

  MonitorElement* meFullRoCnt_;
  MonitorElement* meEbFullRoCnt_;
  MonitorElement* meEeFullRoCnt_;

  MonitorElement* meEbLiZsFir_;
  MonitorElement* meEbHiZsFir_;
  MonitorElement* meEbIncompleteRUZsFir_;

  MonitorElement* meEeLiZsFir_;
  MonitorElement* meEeHiZsFir_;
  MonitorElement* meSRFlagsFromData_;
  MonitorElement* meSRFlagsComputed_;
  MonitorElement* meSRFlagsConsistency_;

  MonitorElement* meIncompleteFRO_;
  MonitorElement* meDroppedFRO_;
  MonitorElement* meCompleteZS_;

  MonitorElement* meIncompleteFROMap_;
  MonitorElement* meDroppedFROMap_;
  MonitorElement* meCompleteZSMap_;

  MonitorElement* meIncompleteFRORateMap_;
  MonitorElement* meDroppedFRORateMap_;
  MonitorElement* meCompleteZSRateMap_;

  MonitorElement* meIncompleteFROCnt_;
  MonitorElement* meDroppedFROCnt_;
  MonitorElement* meCompleteZSCnt_;
  MonitorElement* meEbZsErrCnt_;
  MonitorElement* meEeZsErrCnt_;
  MonitorElement* meZsErrCnt_;
  MonitorElement* meEbZsErrType1Cnt_;
  MonitorElement* meEeZsErrType1Cnt_;
  MonitorElement* meZsErrType1Cnt_;


  MonitorElement* meEbFixedPayload_;
  MonitorElement* meEeFixedPayload_;
  MonitorElement* meFixedPayload_;

  MonitorElement* meL1aRate_;

  int nDroppedFRO_;

  int nIncompleteFRO_;

  int nCompleteZS_;

  int nEbFROCnt_;

  int nEeFROCnt_;

  int nEbZsErrors_;

  int nEeZsErrors_;

  int nEbZsErrorsType1_;

  int nEeZsErrorsType1_;

  const EcalTrigTowerConstituentsMap* triggerTowerMap_;

  const EcalElectronicsMapping* elecMap_;

  bool localReco_;

  std::vector<double> weights_;

  std::vector<int> firWeights_;

  int ebZsThr_;

  int eeZsThr_;

  bool tpInGeV_;

  int firstFIRSample_;

  bool useEventRate_;

  std::vector<bool> logErrForDccs_;

  int nEb_;

  int nEe_;

  int nEeLI_;

  int nEeHI_;

  int nEbLI_;

  int nEbHI_;

  int nPerDcc_[nDccs_];

  int nLiPerDcc_[nDccs_];

  int nHiPerDcc_[nDccs_];

  int nRuPerDcc_[nDccs_];

  int nLiRuPerDcc_[nDccs_];

  int nHiRuPerDcc_[nDccs_];


  bool ebRuActive_[nEbEta / ebTtEdge][nEbPhi / ebTtEdge];
  bool eeRuActive_[nEndcaps][nEeX / scEdge][nEeY / scEdge];

  bool isRuComplete_[nDccs_][nDccChs_];

  int nPerRu_[nDccs_][nDccChs_];

  int ievt_;

  double ttEtSums[nTtEta][nTtPhi];

  bool SkipInnerSC_;

  std::set<std::string> histList_;

  bool allHists_;

  std::string histDir_;

  std::map<std::string, std::string> availableHistList_;

  bool withEeSimHit_;

  bool withEbSimHit_;

  bool registerHist(const std::string& name, const std::string& title);

  void printAvailableHists();

  void configFirWeights(const std::vector<double>& weightsForZsFIR);

  bool logSrpAlgoErrors_;

  bool logSrApplicationErrors_;

  template <class T>
  void compareSrfColl(const edm::Event& event, T& srfFromData, T& computedSrf);

  template <class T>
  void checkSrApplication(const edm::Event& event, T& srfs);

  int ruGraphX(const EcalScDetId& id) const { return id.ix() + (id.zside() > 0 ? 20 : -40); }

  int ruGraphY(const EcalScDetId& id) const { return id.iy(); }

  int ruGraphX(const EcalTrigTowerDetId& id) const { return id.ieta(); }

  int ruGraphY(const EcalTrigTowerDetId& id) const { return id.iphi(); }

  int xtalGraphX(const EEDetId& id) const { return id.ix() + (id.zside() > 0 ? 100 : -200); }

  int xtalGraphY(const EEDetId& id) const { return id.iy(); }

  int xtalGraphX(const EBDetId& id) const { return id.ieta(); }

  int xtalGraphY(const EBDetId& id) const { return id.iphi(); }



  int dccId(const EcalScDetId& detId) const;
  int dccId(const EcalTrigTowerDetId& detId) const;

  void selectFedsForLog();

  int getCrystalCount(int iDcc, int iDccCh);
};

#endif  //EcalSelectiveReadoutValidation_H not defined