EESelectiveReadoutTask.h

Go to the documentation of this file.

#ifndef EESelectiveReadoutTask_H
#define EESelectiveReadoutTask_H

/*
 * \file EESelectiveReadoutTask.h
 *
 * \author P. Gras
 * \author E. Di Marco
 *
*/

#include "FWCore/Framework/interface/EDAnalyzer.h"
#include "FWCore/Framework/interface/Event.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "DataFormats/EcalDetId/interface/EcalScDetId.h"
#include "DataFormats/EcalDetId/interface/EcalTrigTowerDetId.h"

#include "DataFormats/FEDRawData/interface/FEDRawDataCollection.h"
#include "DataFormats/EcalRawData/interface/EcalRawDataCollections.h"
#include "DataFormats/EcalDigi/interface/EcalDigiCollections.h"

class MonitorElement;
class DQMStore;
class EcalSRSettings;

static const char endcapDccMap[401] = {
  "       777777       "      
  "    666777777888    "      
  "   66667777778888   "      
  "  6666667777888888  "
  " 666666677778888888 "
  " 566666677778888880 "             //    Z          
  " 555666667788888000 "             //     x-----> X 
  "55555566677888000000"             //     |         
  "555555566  880000000"             //     |         
  "55555555    00000000"//_          //     |         
  "55555554    10000000"             //     V Y       
  "554444444  111111100"
  "44444444332211111111"
  " 444444333222111111 "
  " 444443333222211111 "
  " 444433333222221111 "
  "  4443333322222111  "
  "   43333332222221   "
  "    333333222222    "
  "       333222       "};

class EESelectiveReadoutTask: public edm::EDAnalyzer{

public:

EESelectiveReadoutTask(const edm::ParameterSet& ps);

virtual ~EESelectiveReadoutTask();

protected:

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

void beginJob(void);

void endJob(void);

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

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

void reset(void);

void setup(void);

void cleanup(void);

static const int nECALDcc = 54;
static const int nEEDcc = 18;
static const int nEBDcc = 36;
static const int kByte = 1024;

static const int nDccChs = 68;

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

static const int nEndcaps = 2;

static const int nEeX = 100;

static const int nEeY = 100;
 
static const int scEdge = 5;

static const int nTtEta = 56;

static const int nTtPhi = 72;

static const int bytesPerCrystal = 24;

int nCrySC[20][20][2];

int nCryTT[108][41];

int nEvtFullReadout[20][20][2];

int nEvtRUForced[20][20][2];

int nEvtZS1Readout[20][20][2];

int nEvtZSReadout[20][20][2];

int nEvtCompleteReadoutIfZS[20][20][2];

int nEvtDroppedReadoutIfFR[20][20][2];

int nEvtAnyReadout[20][20][2];

int nEvtHighInterest[100][100][2];

int nEvtMediumInterest[100][100][2];

int nEvtLowInterest[100][100][2];

int nEvtAnyInterest[100][100][2];


private:

enum subdet_t {EB, EE};

 void anaDigi(const EEDataFrame& frame, const EESrFlagCollection& srFlagColl, uint16_t statusCode);

void anaDigiInit();

unsigned dccNum(const DetId& xtalId) const;

unsigned dccNumOfRU(const EcalScDetId& scId) const;

const EcalScDetId readOutUnitOf(const EEDetId& xtalId) const;
  
int iXY2cIndex(int iX) const{
  return iX-1;
}

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

double getEeEventSize(double nReadXtals) const;

double getDccOverhead(subdet_t subdet) const{
  //  return (subdet==EB?34:25)*8;
  return (subdet==EB?34:52)*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*bytesPerCrystal+nRuPerDcc_[iDcc0]*8;
}

int dccPhiIndexOfRU(int i, int j) const;

inline int dccPhiIndex(int i, int j) const {
  return dccPhiIndexOfRU(i/5, j/5);
}

int dccIndex(int iDet, int i, int j) const;

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

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

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


int getCrystalCount(int iDcc, int iDccCh);

int nEe_[2];

int nEeLI_[2];

int nEeHI_[2];

int nPerDcc_[nECALDcc];

int nPerRu_[nECALDcc][nDccChs];   

int nRuPerDcc_[nECALDcc];

bool eeRuActive_[nEndcaps][nEeX/scEdge][nEeY/scEdge];

std::vector<int> firWeights_;

int firstFIRSample_;

int ievt_;

DQMStore* dqmStore_;

std::string prefixME_;

bool enableCleanup_;

bool mergeRuns_;

edm::EDGetTokenT<EEDigiCollection> EEDigiCollection_;
edm::EDGetTokenT<EcalRecHitCollection> EcalRecHitCollection_;
edm::EDGetTokenT<EESrFlagCollection> EESRFlagCollection_;
edm::EDGetTokenT<EcalTrigPrimDigiCollection> EcalTrigPrimDigiCollection_;
edm::EDGetTokenT<FEDRawDataCollection> FEDRawDataCollection_;

float xbins[19];
float ybins[133];

MonitorElement* EEDccEventSize_;
MonitorElement* EEDccEventSizeMap_;
MonitorElement* EETowerSize_[2];
MonitorElement* EETTFMismatch_[2];
MonitorElement* EEReadoutUnitForcedBitMap_[2];
MonitorElement* EEFullReadoutSRFlagMap_[2];
MonitorElement* EEFullReadoutSRFlagCount_[2];
MonitorElement* EEZeroSuppression1SRFlagMap_[2];
MonitorElement* EEHighInterestTriggerTowerFlagMap_[2];
MonitorElement* EEMediumInterestTriggerTowerFlagMap_[2];
MonitorElement* EELowInterestTriggerTowerFlagMap_[2];
MonitorElement* EETTFlags_[2];
MonitorElement* EECompleteZSMap_[2];
MonitorElement* EECompleteZSCount_[2];
MonitorElement* EEDroppedFRMap_[2];
MonitorElement* EEDroppedFRCount_[2];
MonitorElement* EEEventSize_[2];
MonitorElement* EEHighInterestPayload_[2];
MonitorElement* EELowInterestPayload_[2];
MonitorElement* EEHighInterestZsFIR_[2];
MonitorElement* EELowInterestZsFIR_[2];

bool init_;

bool useCondDb_;
const EcalSRSettings* settings_;

};

#endif