EcalSelectiveReadoutValidation Class Reference

#include <EcalSelectiveReadoutValidation.h>

Inheritance diagram for EcalSelectiveReadoutValidation:

Classes
struct	energiesEb_t
struct	energiesEe_t
class	Sorter

Public Member Functions
	EcalSelectiveReadoutValidation (const edm::ParameterSet &ps)
	Constructor. More...
	~EcalSelectiveReadoutValidation ()
	Destructor. More...
Public Member Functions inherited from edm::EDAnalyzer
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)
	EDAnalyzer ()
ModuleDescription const &	moduleDescription () const
std::string	workerType () const
virtual	~EDAnalyzer ()
Public Member Functions inherited from edm::EDConsumerBase
	EDConsumerBase ()
ProductHolderIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const
void	itemsMayGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const
void	itemsToGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const
std::vector < ProductHolderIndexAndSkipBit > const &	itemsToGetFromEvent () const
void	labelsForToken (EDGetToken iToken, Labels &oLabels) const
void	modulesDependentUpon (const std::string &iProcessName, std::vector< const char * > &oModuleLabels) const
bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const
bool	registeredToConsumeMany (TypeID const &, BranchType) const
void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)
virtual	~EDConsumerBase ()

Protected Member Functions
void	analyze (edm::Event const &e, edm::EventSetup const &c)
	Analyzes the event. More...
void	beginRun (const edm::Run &r, const edm::EventSetup &c)
	Calls at begin of run. More...
void	endRun (const edm::Run &r, const edm::EventSetup &c)
	Calls at end of run. More...
Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)
EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)
template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)
ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...
template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()
void	consumesMany (const TypeToGet &id)
template<BranchType B>
void	consumesMany (const TypeToGet &id)
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)
template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

Private Types
typedef EcalRecHit	RecHit
typedef EcalRecHitCollection	RecHitCollection
enum	subdet_t { EB, EE }
	distinguishes barral and endcap of ECAL. More...

Private Member Functions
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)
template<class T >
void	checkSrApplication (const edm::Event &event, T &srfs)
int	cIndex2iEta (int i) const
int	cIndex2iPhi (int i) const
int	cIndex2iTtEta (int i) const
int	cIndex2iTtPhi (int i) const
int	cIndex2iXY (int iX0) const
template<class T >
void	compareSrfColl (const edm::Event &event, T &srfFromData, T &computedSrf)
void	configFirWeights (const std::vector< double > &weightsForZsFIR)
std::pair< int, int >	dccCh (const DetId &xtalId) const
double	frame2Energy (const EcalDataFrame &frame) const
template<class T >
double	frame2EnergyForTp (const T &frame, int offset=0) const
double	getBytesPerCrystal () const
int	getCrystalCount (int iDcc, int iDccCh)
double	getDccEventSize (int iDcc0, double nReadXtals) const
double	getDccOverhead (subdet_t subdet) const
double	getDccSrDependentPayload (int iDcc0, double nReadRus, double nReadXtals) const
double	getEbEventSize (double nReadXtals) const
double	getEeEventSize (double nReadXtals) const
double	getL1aRate () const
int	getRuCount (int iDcc0) const
int	iEta2cIndex (int iEta) const
void	initAsciiFile ()
int	iPhi2cIndex (int iPhi) const
int	iTtEta2cIndex (int iEta) const
int	iTtPhi2cIndex (int iPhi) const
int	iXY2cIndex (int iX) const
void	myAna ()
void	normalizeHists (double eventCount)
void	printAvailableHists ()
void	readAllCollections (const edm::Event &e)
bool	registerHist (const std::string &name, const std::string &title)
void	selectFedsForLog ()
void	setTtEtSums (const edm::EventSetup &es, const EBDigiCollection &ebDigis, const EEDigiCollection &eeDigis)
void	SRFlagValidation (const edm::Event &event, const edm::EventSetup &es)
EcalScDetId	superCrystalOf (const EEDetId &xtalId) const
void	updateL1aRate (const edm::Event &event)
EcalTrigTowerDetId	readOutUnitOf (const EBDetId &xtalId) const
EcalScDetId	readOutUnitOf (const EEDetId &xtalId) const
MonitorElement *	bookFloat (const std::string &name)
MonitorElement *	book1D (const std::string &name, const std::string &title, int nbins, double xmin, double xmax)
MonitorElement *	book2D (const std::string &name, const std::string &title, int nxbins, double xmin, double xmax, int nybins, double ymin, double ymax)
MonitorElement *	bookProfile (const std::string &name, const std::string &title, int nbins, double xmin, double xmax)
MonitorElement *	bookProfile2D (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)
void	fill (MonitorElement *me, float x, float yw)
void	fill (MonitorElement *me, float x, float y, float zw)
void	fill (MonitorElement *me, float x, float y, float z, float w)
int	ruGraphX (const EcalScDetId &id) const
int	ruGraphY (const EcalScDetId &id) const
int	ruGraphX (const EcalTrigTowerDetId &id) const
int	ruGraphY (const EcalTrigTowerDetId &id) const
int	xtalGraphX (const EEDetId &id) const
int	xtalGraphY (const EEDetId &id) const
int	xtalGraphX (const EBDetId &id) const
int	xtalGraphY (const EBDetId &id) const
int	dccId (const EcalScDetId &detId) const
int	dccId (const EcalTrigTowerDetId &detId) const

Static Private Member Functions
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)

Private Attributes
bool	allHists_
std::map< std::string, std::string >	availableHistList_
bool	collNotFoundWarn_
	Switch for collection-not-found warning. More...
DQMStore *	dbe_
	Histogramming interface. More...
energiesEb_t	ebEnergies [nEbEta][nEbPhi]
int	ebZsThr_
energiesEe_t	eeEnergies [nEndcaps][nEeX][nEeY]
int	eeZsThr_
const EcalElectronicsMapping *	elecMap_
int	firstFIRSample_
std::vector< int >	firWeights_
std::string	histDir_
std::set< std::string >	histList_
int	ievt_
bool	isRuComplete_ [nDccs_][nDccChs_]
bool	localReco_
std::vector< bool >	logErrForDccs_
bool	logSrApplicationErrors_
bool	logSrpAlgoErrors_
MonitorElement *	meL1aRate_
int	nCompleteZS_
	Counter of ZS-flagged RU fully read out. More...
int	nDroppedFRO_
	Counter of FRO-flagged RU dropped from data. More...
int	nEb_
int	nEbFROCnt_
	Counter of EB FRO-flagged RUs. More...
int	nEbHI_
int	nEbLI_
int	nEbZsErrors_
	Counter of EB ZS errors (LI channel below ZS threshold) More...
int	nEbZsErrorsType1_
int	nEe_
int	nEeFROCnt_
	Counter of EE FRO-flagged RUs. More...
int	nEeHI_
int	nEeLI_
int	nEeZsErrors_
	Counter of EE ZS errors (LI channel below ZS threshold) More...
int	nEeZsErrorsType1_
int	nHiPerDcc_ [nDccs_]
int	nHiRuPerDcc_ [nDccs_]
int	nIncompleteFRO_
	Counter of FRO-flagged RU only partial data. More...
int	nLiPerDcc_ [nDccs_]
int	nLiRuPerDcc_ [nDccs_]
int	nPerDcc_ [nDccs_]
int	nPerRu_ [nDccs_][nDccChs_]
int	nRuPerDcc_ [nDccs_]
std::string	outputFile_
	Output file for histograms. More...
bool	SkipInnerSC_
std::ofstream	srApplicationErrorLog_
	Output ascii file for unconsistency between Xtals and RU Flags. More...
std::string	srApplicationErrorLogFileName_
std::ofstream	srpAlgoErrorLog_
	Output ascii file for unconsistency on SR flags. More...
std::string	srpAlgoErrorLogFileName_
bool	tpInGeV_
const EcalTPParameters *	tpParam_
const EcalTrigTowerConstituentsMap *	triggerTowerMap_
double	ttEtSums [nTtEta][nTtPhi]
bool	useEventRate_
bool	verbose_
	Verbosity switch. More...
std::vector< double >	weights_
bool	withEbSimHit_
bool	withEeSimHit_
std::ofstream	zsErrorLog_
	File to log ZS and other errors. More...
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_
bool	ebRuActive_ [nEbEta/ebTtEdge][nEbPhi/ebTtEdge]
bool	eeRuActive_ [nEndcaps][nEeX/scEdge][nEeY/scEdge]

Static Private Attributes
static const int	ebTtEdge = 5
	Number of crystals along an EB TT. More...
static const int	kByte_ = 1024
	number of bytes in 1 kByte: More...
static const int	maxDccId_ = minDccId_ + nDccs_ -1
static const int	minDccId_ = 1
static const unsigned	nDccChs_ = 68
	Number of input channels of a DCC. More...
static const int	nDccRus_ [nDccs_]
	number of RUs for each DCC More...
static const unsigned	nDccs_ = 54
	Total number of DCCs. More...
static const int	nEbDccs = 36
	number of DCCs for EB More...
static const int	nEbEta = 170
	number of crystals along Eta in EB More...
static const int	nEbPhi = 360
	number of crystals along Phi in EB More...
static const int	nEbRus = 36*68
	number of RUs for EB More...
static const int	nEbTtEta = 34
	Number of Trigger Towers in barrel along Eta. More...
static const int	nEeDccs = 18
	number of DCCs for EE More...
static const int	nEeRus = 2*(34+32+33+33+32+34+33+34+33)
	number of RUs for EE More...
static const int	nEeX = 100
	EE crystal grid size along X. More...
static const int	nEeY = 100
	EE crystal grid size along Y. More...
static const int	nEndcaps = 2
	number of endcaps More...
static const int	nMaxXtalPerRu = 25
	Number of crystals per Readout Unit excepted partial SCs. More...
static const int	nOneEeTtEta = 11
	Number of Trigger Towers in an endcap along Eta. More...
static const int	nTtEta = 2*nOneEeTtEta + nEbTtEta
	Number of Trigger Towers along Eta. More...
static const int	nTtPhi = 72
	Number of Trigger Towers along Phi. More...
static const double	rad2deg = 45./atan(1.)
	Conversion factor from radian to degree. More...
static const int	scEdge = 5
	Number of crystals along a supercrystal edge. More...

Additional Inherited Members
Public Types inherited from edm::EDAnalyzer
typedef EDAnalyzer	ModuleType
Static Public Member Functions inherited from edm::EDAnalyzer
static const std::string &	baseType ()
static void	fillDescriptions (ConfigurationDescriptions &descriptions)
static void	prevalidate (ConfigurationDescriptions &)

Detailed Description

Definition at line 47 of file EcalSelectiveReadoutValidation.h.

Member Typedef Documentation

typedef EcalRecHit EcalSelectiveReadoutValidation::RecHit

private

Definition at line 52 of file EcalSelectiveReadoutValidation.h.

typedef EcalRecHitCollection EcalSelectiveReadoutValidation::RecHitCollection

private

Definition at line 51 of file EcalSelectiveReadoutValidation.h.

Member Enumeration Documentation

enum EcalSelectiveReadoutValidation::subdet_t

private

distinguishes barral and endcap of ECAL.

Enumerator
EB
EE

Definition at line 75 of file EcalSelectiveReadoutValidation.h.

{EB, EE};

Constructor & Destructor Documentation

EcalSelectiveReadoutValidation::EcalSelectiveReadoutValidation

(

const edm::ParameterSet &

ps

)

Constructor.

Definition at line 95 of file EcalSelectiveReadoutValidation.cc.

References allHists_, availableHistList_, book1D(), book2D(), bookFloat(), bookProfile(), bookProfile2D(), configFirWeights(), edm::EDConsumerBase::consumesCollector(), dbe_, EB, ebComputedSrFlags_, ebDigis_, ebNoZsDigis_, ebRecHits_, ebSimHits_, ebSrFlags_, ebZsThr_, EE, eeComputedSrFlags_, eeDigis_, eeNoZsDigis_, eeRecHits_, eeSimHits_, eeSrFlags_, eeZsThr_, fedRaw_, MonitorElement::Fill(), getDccOverhead(), edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), histDir_, histList_, logSrApplicationErrors_, logSrpAlgoErrors_, meChOcc_, meCompleteZSCnt_, meCompleteZSMap_, meCompleteZSRateMap_, meDccHiVol_, meDccLiVol_, meDccVol_, meDccVolFromData_, meDroppedFROCnt_, meDroppedFROMap_, meDroppedFRORateMap_, meEbEMean_, meEbFixedPayload_, meEbFullRoCnt_, meEbHiZsFir_, meEbLiZsFir_, meEbNoise_, meEbNoZsRecVsSimE_, meEbRecE_, meEbRecEHitXtal_, meEbRecVsSimE_, meEbSimE_, meEbZsErrCnt_, meEbZsErrType1Cnt_, meEeEMean_, meEeFixedPayload_, meEeFullRoCnt_, meEeHiZsFir_, meEeLiZsFir_, meEeNoise_, meEeNoZsRecVsSimE_, meEeRecE_, meEeRecEHitXtal_, meEeRecVsSimE_, meEeSimE_, meEeZsErrCnt_, meEeZsErrType1Cnt_, meFixedPayload_, meForcedRu_, meForcedTtf_, meFullRoCnt_, meFullRoRu_, meHiTtf_, meIncompleteFROCnt_, meIncompleteFROMap_, meIncompleteFRORateMap_, meL1aRate_, meLiTtf_, meMiTtf_, meSRFlagsConsistency_, meTp_, meTpMap_, meTpVsEtSum_, meTtf_, meTtfVsEtSum_, meTtfVsTp_, meVol_, meVolB_, meVolBHI_, meVolBLI_, meVolE_, meVolEHI_, meVolELI_, meVolHI_, meVolLI_, meZs1Ru_, meZsErrCnt_, meZsErrType1Cnt_, nDccs_, nEbDccs, nEeDccs, cppFunctionSkipper::operator, outputFile_, printAvailableHists(), alignCSCRings::s, CollHandle< T >::setToken(), srApplicationErrorLogFileName_, srpAlgoErrorLogFileName_, AlCaHLTBitMon_QueryRunRegistry::string, edmStreamStallGrapher::t, indexGen::title, tpInGeV_, tps_, and verbose_.

                                                                                    :
  collNotFoundWarn_(ps.getUntrackedParameter<bool>("warnIfCollectionNotFound", true)),
  ebDigis_(ps.getParameter<edm::InputTag>("EbDigiCollection"), false,
       collNotFoundWarn_),
  eeDigis_(ps.getParameter<edm::InputTag>("EeDigiCollection"), false,
       collNotFoundWarn_),
  ebNoZsDigis_(ps.getParameter<edm::InputTag>("EbUnsuppressedDigiCollection"),
           false, false/*collNotFoundWarn_*/),
  eeNoZsDigis_(ps.getParameter<edm::InputTag>("EeUnsuppressedDigiCollection"),
           false, false/*collNotFoundWarn_*/),
  ebSrFlags_(ps.getParameter<edm::InputTag>("EbSrFlagCollection"), false,
         collNotFoundWarn_),
  eeSrFlags_(ps.getParameter<edm::InputTag>("EeSrFlagCollection"), false,
         collNotFoundWarn_),
  ebComputedSrFlags_(ps.getParameter<edm::InputTag>("EbSrFlagFromTTCollection"), false,
             false/*collNotFoundWarn_*/),
  eeComputedSrFlags_(ps.getParameter<edm::InputTag>("EeSrFlagFromTTCollection"), false,
             false/*collNotFoundWarn_*/),
  ebSimHits_(ps.getParameter<edm::InputTag>("EbSimHitCollection"), false,
         false/*collNotFoundWarn_*/),
  eeSimHits_(ps.getParameter<edm::InputTag>("EeSimHitCollection"), false,
         false/*collNotFoundWarn_*/),
  tps_(ps.getParameter<edm::InputTag>("TrigPrimCollection"), false,
       collNotFoundWarn_),
  ebRecHits_(ps.getParameter<edm::InputTag>("EbRecHitCollection"), false,
         false/*collNotFoundWarn_*/),
  eeRecHits_(ps.getParameter<edm::InputTag>("EeRecHitCollection"), false,
         false/*collNotFoundWarn_*/),
  fedRaw_(ps.getParameter<edm::InputTag>("FEDRawCollection"), false,
      false/*collNotFoundWarn_*/),
  tmax(0),
  tmin(numeric_limits<int64_t>::max()),
  l1aOfTmin(0),
  l1aOfTmax(0),
  triggerTowerMap_(0),
  localReco_(ps.getParameter<bool>("LocalReco")),
  weights_(ps.getParameter<vector<double> >("weights")),
  tpInGeV_(ps.getParameter<bool>("tpInGeV")),
  firstFIRSample_(ps.getParameter<int>("ecalDccZs1stSample")),
  useEventRate_(ps.getParameter<bool>("useEventRate")),
  logErrForDccs_(nDccs_, false),
  ievt_(0),
  allHists_(false),
  histDir_(ps.getParameter<string>("histDir")),
  withEeSimHit_(false),
  withEbSimHit_(false){

  edm::ConsumesCollector collector(consumesCollector());
  ebDigis_.setToken(collector);
  eeDigis_.setToken(collector);
  ebNoZsDigis_.setToken(collector);
  eeNoZsDigis_.setToken(collector);
  ebSrFlags_.setToken(collector);
  eeSrFlags_.setToken(collector);
  ebComputedSrFlags_.setToken(collector);
  eeComputedSrFlags_.setToken(collector);
  ebSimHits_.setToken(collector);
  eeSimHits_.setToken(collector);
  tps_.setToken(collector);
  ebRecHits_.setToken(collector);
  eeRecHits_.setToken(collector);
  fedRaw_.setToken(collector);

  PgTiming t("EcalSelectiveReadoutValidation ctor");

//   std::vector<int> excludedFeds =
//     ps.getParameter<vector<int> >("excludedFeds");

//   for(size_t i = 0; i < excludedFeds.size(); ++i){
//     int iDcc = excludedFeds[i] % 600;
//     if(iDcc < minDccId_ || iDcc > maxDccId_){
//       throw cms::Exception("config") << "Error in parameter excludedFeds of "
//  "EcalSelectiveReadoutValidation module. Values must be between "
//                   << 600 + minDccId_
//                   << " and " << 600 + maxDccId_ << "\n";
//     } else{
//       logErrForDccs_.at(iDcc-minDccId_) = false;
//     }
//   }

  double ebZsThr = ps.getParameter<double>("ebZsThrADCCount");
  double eeZsThr = ps.getParameter<double>("eeZsThrADCCount");

  ebZsThr_ = lround(ebZsThr*4);
  eeZsThr_ = lround(eeZsThr*4);

  //File to log SRP algorithem inconsistency
  srpAlgoErrorLogFileName_
    = ps.getUntrackedParameter<string>("srpAlgoErrorLogFile","");
  logSrpAlgoErrors_ = (srpAlgoErrorLogFileName_.size()!=0);

  //File to log SRP decision application inconsistency
  srApplicationErrorLogFileName_
    = ps.getUntrackedParameter<string>("srApplicationErrorLogFile","");
  logSrApplicationErrors_ = (srApplicationErrorLogFileName_.size()!=0);

  //FIR ZS weights
  configFirWeights(ps.getParameter<vector<double> >("dccWeights"));

  // DQM ROOT output
  outputFile_ = ps.getUntrackedParameter<string>("outputFile", "");

  if(outputFile_.size() != 0){
    LogInfo("OutputInfo") << " Ecal Digi Task histograms will be saved to '"
              << outputFile_.c_str() << "'";
  } else{
    LogInfo("OutputInfo") << " Ecal Digi Task histograms will NOT be saved";
  }

  // verbosity switch
  verbose_ = ps.getUntrackedParameter<bool>("verbose", false);

  // get hold of back-end interface
  dbe_ = Service<DQMStore>().operator->();

  if(verbose_){
    dbe_->setVerbose(1);
  } else{
    dbe_->setVerbose(0);
  }

  if(verbose_) dbe_->showDirStructure();

  dbe_->setCurrentFolder(histDir_);

  vector<string>
    hists(ps.getUntrackedParameter<vector<string> >("histograms",
                            vector<string>(1, "all")));

  for(vector<string>::iterator it = hists.begin();
      it!=hists.end(); ++it) histList_.insert(*it);
  if(histList_.find("all") != histList_.end()) allHists_ = true;

  //Data volume
  meEbFixedPayload_ = bookFloat("ebFixedVol");
  double ebFixed = getDccOverhead(EB)*nEbDccs;
  double eeFixed =  getDccOverhead(EE)*nEeDccs;
  meEbFixedPayload_->Fill(ebFixed);
  meEeFixedPayload_ = bookFloat("eeFixedVol");
  meEbFixedPayload_->Fill(eeFixed);
  meFixedPayload_ = bookFloat("fixedVol");
  meFixedPayload_->Fill(ebFixed+eeFixed);

  meL1aRate_ = bookFloat("l1aRate_"); 

  meDccVol_ = bookProfile("hDccVol", //"EcalDccEventSizeComputed",
              "ECAL DCC event fragment size;Dcc id; "
              "<Event size> (kB)", nDccs_, .5, .5+nDccs_);

  meDccLiVol_ = bookProfile("hDccLiVol",
                            "LI channel payload per DCC;Dcc id; "
                            "<Event size> (kB)", nDccs_, .5, .5+nDccs_);

  meDccHiVol_ = bookProfile("hDccHiVol",
                            "HI channel payload per DCC;Dcc id; "
                            "<Event size> (kB)", nDccs_, .5, .5+nDccs_);

  meDccVolFromData_ = bookProfile("hDccVolFromData", //"EcalDccEventSize",
                  "ECAL DCC event fragment size;Dcc id; "
                  "<Event size> (kB)", nDccs_, .5, .5+nDccs_);

  meVolBLI_ = book1D("hVolBLI",// "EBLowInterestPayload",
             "ECAL Barrel low interest crystal data payload;"
             "Event size (kB);Nevts",
             100, 0., 200.);

  meVolELI_ = book1D("hVolELI", //"EELowInterestPayload",
             "Endcap low interest crystal data payload;"
             "Event size (kB);Nevts",
             100, 0., 200.);

  meVolLI_ = book1D("hVolLI", //"EcalLowInterestPayload",
            "ECAL low interest crystal data payload;"
            "Event size (kB);Nevts",
            100, 0., 200.);

  meVolBHI_ = book1D("hVolBHI", //"EBHighInterestPayload",
             "Barrel high interest crystal data payload;"
             "Event size (kB);Nevts",
             100, 0., 200.);

  meVolEHI_ = book1D("hVolEHI", //"EEHighInterestPayload",
             "Endcap high interest crystal data payload;"
             "Event size (kB);Nevts",
             100, 0., 200.);

  meVolHI_ = book1D("hVolHI", //"EcalHighInterestPayload",
            "ECAL high interest crystal data payload;"
            "Event size (kB);Nevts",
            100, 0., 200.);

  meVolB_ = book1D("hVolB", //"EBEventSize",
           "Barrel data volume;Event size (kB);Nevts",
           100, 0., 200.);

  meVolE_ = book1D("hVolE", //"EEEventSize",
           "Endcap data volume;Event size (kB);Nevts",
           100, 0., 200.);

  meVol_ = book1D("hVol", //"EcalEventSize",
          "ECAL data volume;Event size (kB);Nevts",
          100, 0., 200.);

  meChOcc_ = book2D("h2ChOcc", //"EcalChannelOccupancy",
            "ECAL crystal channel occupancy after zero suppression;"
            "iX -200 / iEta / iX + 100;"
            "iY / iPhi (starting from -10^{o}!);"
            "Event count",
            401, -200.5, 200.5,
            360, .5, 360.5);

  //TP
  string tpUnit;
  if(tpInGeV_) tpUnit = string("GeV"); else tpUnit = string("TP hw unit");
  string title;
  title = string("Trigger primitive TT E_{T};E_{T} ")
    + tpUnit + string(";Event Count");
  meTp_ = book1D("hTp", //"EcalTriggerPrimitiveEt",
         title.c_str(),
         (tpInGeV_?100:40), 0., (tpInGeV_?10.:40.));

  meTtf_ = book1D("hTtf", //"EcalTriggerTowerFlag",
          "Trigger primitive TT flag;Flag number;Event count",
          8, -.5, 7.5);

  title = string("Trigger tower flag vs TP;E_{T}(TT) (")
    + tpUnit + string(");Flag number");
  meTtfVsTp_ = book2D("h2TtfVsTp",
              title.c_str(),
              100, 0., (tpInGeV_?10.:40.),
              8, -.5, 7.5);

  meTtfVsEtSum_ = book2D("h2TtfVsEtSum",
             "Trigger tower flag vs #sumE_{T};"
             "E_{T}(TT) (GeV);"
             "TTF",
             100, 0., 10.,
             8, -.5, 7.5);
  title = string("Trigger primitive Et (TP) vs #sumE_{T};"
         "E_{T} (sum) (GeV);"
         "E_{T} (TP) (") + tpUnit + string (")");

  meTpVsEtSum_ = book2D("h2TpVsEtSum",
            title.c_str(),
            100, 0., 10.,
            100, 0., (tpInGeV_?10.:40.));

  title = string("Trigger primitive E_{T};"
                 "iEta;"
                 "iPhi;"
                 "E_{T} (TP) (") + tpUnit + string (")");
  meTpMap_ = bookProfile2D("h2Tp",
                           title.c_str(),
                           57, -28.5, 28.5,
               72, .5, 72.5);

  //SRF
  meFullRoRu_ = book2D("h2FRORu", //"EcalFullReadoutSRFlagMap",
               "Full Read-out readout unit;"
               "iX - 40 / iEta / iX + 20;"
               "iY / iPhi (iPhi = 1 at phi = 0 rad);"
               "Event count",
                       80, -39.5, 40.5,
               72, .5, 72.5);

  meFullRoCnt_ = book1D("hFROCnt",
                        "Number of Full-readout-flagged readout units;"
                        "FRO RU count;Event count",
                        300, -.5, 299.5);

  meEbFullRoCnt_ = book1D("hEbFROCnt",
                          "Number of EB Full-readout-flagged readout units;"
                          "FRO RU count;Event count",
                          200, -.5, 199.5);

  meEeFullRoCnt_ = book1D("hEeFROCnt",
                          "Number of EE Full-readout-flagged readout units;"
                          "FRO RU count;Event count",
                          200, -.5, 199.5);

  meZs1Ru_ = book2D("h2Zs1Ru", //"EbZeroSupp1SRFlagMap",
            "Readout unit with ZS-thr-1 flag;"
            "iX - 40 / iEta / iX + 20;"
            "iY0 / iPhi0 (iPhi = 1 at phi = 0 rad);"
            "Event count",
                    80, -39.5, 40.5,
            72, .5, 72.5);

  meForcedRu_ = book2D("h2ForcedRu", //"EcalReadoutUnitForcedBitMap",
               "ECAL readout unit with forced bit of SR flag on;"
               "iX - 40 / iEta / iX + 20;"
               "iY / iPhi (iPhi = 1 at phi = 0 rad);"
               "Event count",
                       80, -39.5, 40.5,
               72, .5, 72.5);

  meLiTtf_ = book2D("h2LiTtf", //"EcalLowInterestTriggerTowerFlagMap",
            "Low interest trigger tower flags;"
            "iEta;"
            "iPhi;"
            "Event count",
                    57, -28.5, 28.5,
            72, .5, 72.5);

  meMiTtf_ = book2D("h2MiTtf", //"EcalMidInterestTriggerTowerFlagMap",
            "Mid interest trigger tower flags;"
            "iEta;"
            "iPhi;"
            "Event count",
            57, -28.5, 28.5,
                    72, .5, 72.5);

  meHiTtf_ = book2D("h2HiTtf", //"EcalHighInterestTriggerTowerFlagMap",
            "High interest trigger tower flags;"
            "iEta;"
            "iPhi;"
            "Event count",
                    57, -28.5, 28.5,
            72, .5, 72.5);

  meForcedTtf_ = book2D("h2ForcedTtf", //"EcalTtfForcedBitMap",
                        "Trigger tower flags with forced bit set;"
                        "iEta;"
                        "iPhi;"
                        "Event count",
                        57, -28.5, 28.5,
                        72, .5, 72.5);


  const float ebMinNoise = -1.;
  const float ebMaxNoise = 1.;

  const float eeMinNoise = -1.;
  const float eeMaxNoise = 1.;

#if 0
  const float ebMinE = 0.;
  const float ebMaxE = 120.;

  const float eeMinE = 0.;
  const float eeMaxE = 120.;
#else
  const float ebMinE = ebMinNoise;
  const float ebMaxE = ebMaxNoise;

  const float eeMinE = eeMinNoise;
  const float eeMaxE = eeMaxNoise;
#endif


  const int evtMax = 500;

  meEbRecE_ = book1D("hEbRecE",
             "Crystal reconstructed energy;E (GeV);Event count",
             100, ebMinE, ebMaxE);

  meEbEMean_ = bookProfile("hEbEMean",
               "EE <E_hit>;event #;<E_hit> (GeV)",
               evtMax, .5, evtMax + .5);

  meEbNoise_ = book1D("hEbNoise",
              "Crystal noise "
              "(rec E of crystal without deposited energy)"
                      ";Rec E (GeV);Event count",
              100, ebMinNoise, ebMaxNoise);

  meEbLiZsFir_   = book1D("zsEbLiFIRemu",
              "Emulated ouput of ZS FIR filter for EB "
              "low interest crystals;"
              "ADC count*4;"
              "Event count",
              60, -30, 30);

  meEbHiZsFir_ = book1D("zsEbHiFIRemu",
                        "Emulated ouput of ZS FIR filter for EB "
                        "high interest crystals;"
                        "ADC count*4;"
                        "Event count",
                        60, -30, 30);

  //TODO: Fill this histogram...
//   meEbIncompleteRUZsFir_ = book1D("zsEbIncompleteRUFIRemu",
//                                   "Emulated ouput of ZS FIR filter for EB "
//                                   "incomplete FRO-flagged RU;"
//                                   "ADC count*4;"
//                                   "Event count",
//                                   60, -30, 30);

  meEbSimE_ = book1D("hEbSimE", "EB hit crystal simulated energy",
             100, ebMinE, ebMaxE);

  meEbRecEHitXtal_ = book1D("hEbRecEHitXtal",
                "EB rec energy of hit crystals",
                100, ebMinE, ebMaxE);

  meEbRecVsSimE_ = book2D("hEbRecVsSimE",
              "Crystal simulated vs reconstructed energy;"
              "Esim (GeV);Erec GeV);Event count",
              100, ebMinE, ebMaxE,
              100, ebMinE, ebMaxE);

  meEbNoZsRecVsSimE_ = book2D("hEbNoZsRecVsSimE",
                  "Crystal no-zs simulated vs reconstructed "
                  "energy;"
                  "Esim (GeV);Erec GeV);Event count",
                  100, ebMinE, ebMaxE,
                  100, ebMinE, ebMaxE);

  meEeRecE_ = book1D("hEeRecE",
             "EE crystal reconstructed energy;E (GeV);"
             "Event count",
             100, eeMinE, eeMaxE);

  meEeEMean_ = bookProfile("hEeEMean",
               "<E_{EE hit}>;event;<E_{hit}> (GeV)",
               evtMax, .5, evtMax + .5);


  meEeNoise_ = book1D("hEeNoise",
              "EE crystal noise "
              "(rec E of crystal without deposited energy);"
              "E (GeV);Event count",
              200, eeMinNoise, eeMaxNoise);

  meEeLiZsFir_   = book1D("zsEeLiFIRemu",
              "Emulated ouput of ZS FIR filter for EE "
              "low interest crystals;"
              "ADC count*4;"
              "Event count",
              60, -30, 30);

  meEeHiZsFir_   = book1D("zsEeHiFIRemu",
              "Emulated ouput of ZS FIR filter for EE "
              "high interest crystals;"
              "ADC count*4;"
              "Event count",
              60, -30, 30);

  //TODO: Fill this histogram...
//   meEeIncompleteRUZsFir_ = book1D("zsEeIncompleteRUFIRemu",
//                                     "Emulated ouput of ZS FIR filter for EE "
//                                     "incomplete FRO-flagged RU;"
//                                     "ADC count*4;"
//                                     "Event count",
//                                     60, -30, 30);


  meEeSimE_ = book1D("hEeSimE", "EE hit crystal simulated energy",
             100, eeMinE, eeMaxE);

  meEeRecEHitXtal_ = book1D("hEeRecEHitXtal",
                "EE rec energy of hit crystals",
                100, eeMinE, eeMaxE);

  meEeRecVsSimE_ = book2D("hEeRecVsSimE",
              "EE crystal simulated vs reconstructed energy;"
              "Esim (GeV);Erec GeV);Event count",
              100, eeMinE, eeMaxE,
              100, eeMinE, eeMaxE);

  meEeNoZsRecVsSimE_ = book2D("hEeNoZsRecVsSimE",
                  "EE crystal no-zs simulated vs "
                  "reconstructed "
                  "energy;Esim (GeV);Erec GeV);Event count",
                  100, eeMinE, eeMaxE,
                  100, eeMinE, eeMaxE);

  meSRFlagsConsistency_ = book2D("hSRAlgoErrorMap",
                 "TTFlags and SR Flags mismatch;"
                 "iX - 40 / iEta / iX + 20;"
                 "iY / iPhi (iPhi = 1 at phi = 0 rad);"
                 "Event count",
                 80, -39.5, 40.5,
                 72, .5, 72.5);

  //Readout Units histos (interest/Ncrystals)
  meIncompleteFROMap_ = book2D("hIncompleteFROMap",
                               "Incomplete full-readout-flagged readout units;"
                               "iX - 40 / iEta / iX + 20;"
                               "iY / iPhi (iPhi = 1 at phi = 0 rad);"
                               "Event count",
                               80, -39.5, 40.5,
                               72, .5, 72.5);

  meIncompleteFROCnt_ = book1D("hIncompleteFROCnt",
                               "Number of incomplete full-readout-flagged "
                               "readout units;"
                               "Number of RUs;Event count;",
                               200, -.5, 199.5);

  meIncompleteFRORateMap_
    = bookProfile2D("hIncompleteFRORateMap",
            "Incomplete full-readout-flagged readout units;"
            "iX - 40 / iEta / iX + 20;"
            "iY / iPhi (iPhi = 1 at phi = 0 rad);"
            "Incomplete error rate",
                    80, -39.5, 40.5,
            72, .5, 72.5);


  meDroppedFROMap_ = book2D("hDroppedFROMap",
                            "Dropped full-readout-flagged readout units;"
                            "iX - 40 / iEta / iX + 20;"
                            "iY / iPhi (iPhi = 1 at phi = 0 rad);"
                            "Event count",
                            80, -39.5, 40.5,
                            72, .5, 72.5);

  meDroppedFROCnt_ = book1D("hDroppedFROCnt",
                            "Number of dropped full-readout-flagged "
                            "RU count;RU count;Event count",
                            200, -.5, 199.5);

  meCompleteZSCnt_ = book1D("hCompleteZsCnt",
                            "Number of zero-suppressed-flagged RU fully "
                            "readout;"
                            "RU count;Event count",
                            200, -.5, 199.5);

  stringstream buf;
  buf << "Number of LI EB channels below the " << ebZsThr_/4. << " ADC count ZS threshold;"
    "Channel count;Event count",
  meEbZsErrCnt_ = book1D("hEbZsErrCnt",
                         buf.str().c_str(),
                         200, -.5, 199.5);

  buf.str("");
  buf << "Number of LI EE channels below the " << eeZsThr_/4. << " ADC count ZS theshold;"
    "Channel count;Event count",
  meEeZsErrCnt_ = book1D("hEeZsErrCnt",
                         buf.str().c_str(),
                         200, -.5, 199.5);

  meZsErrCnt_ = book1D("hZsErrCnt",
                       "Number of LI channels below the ZS threshold;"
                       "Channel count;Event count",
                       200, -.5, 199.5);

  meEbZsErrType1Cnt_ = book1D("hEbZsErrType1Cnt",
                              "Number of EB channels below the ZS "
                              "threshold in a LI but fully readout RU;"
                              "Channel count;Event count;",
                              200, -.5, 199.5);

  meEeZsErrType1Cnt_ = book1D("hEeZsErrType1Cnt",
                              "Number EE channels below the ZS threshold"
                              " in a LI but fully readout RU;"
                              "Channel count;Event count",
                              200, -.5, 199.5);

  meZsErrType1Cnt_ = book1D("hZsErrType1Cnt",
                            "Number of LI channels below the ZS threshold "
                            "in a LI but fully readout RU;"
                            "Channel count;Event count",
                            200, -.5, 199.5);


  meDroppedFRORateMap_
    = bookProfile2D("hDroppedFRORateMap",
            "Dropped full-readout-flagged readout units"
                    "iX - 40 / iEta / iX + 20;"
                    "iY / iPhi (iPhi = 1 at phi = 0 rad);"
                    "Dropping rate",
                    80, -39.5, 40.5,
                    72, .5, 72.5);

  meCompleteZSMap_ = book2D("hCompleteZSMap",
             "Complete zero-suppressed-flagged readout units;"
             "iX - 40 / iEta / iX + 20;"
             "iY / iPhi (iPhi = 1 at phi = 0 rad);"
             "Event count",
             80, -39.5, 40.5,
             72, .5, 72.5);

  meCompleteZSRateMap_
    = bookProfile2D("hCompleteZSRate",
            "Complete zero-suppressed-flagged readout units;"
            "iX - 40 / iEta / iX + 20;"
            "iY / iPhi (iPhi = 1 at phi = 0 rad);"
            "Completeness rate",
            80, -39.5, 40.5,
            72, .5, 72.5);

  //print list of available histograms (must be called after
  //the bookXX methods):
  printAvailableHists();

  //check the histList parameter:
  stringstream s;
  for(set<string>::iterator it = histList_.begin();
      it!=histList_.end();
      ++it){
    if(*it!=string("all")
       && availableHistList_.find(*it)==availableHistList_.end()){
      s << (s.str().size()==0?"":", ") << *it;
    }
  }
  if(s.str().size()!=0){
    LogWarning("Configuration")
      << "Parameter 'histList' contains some unknown histogram(s). "
      "Check spelling. Following name were not found: "
      << s.str();
  }
}

EcalSelectiveReadoutValidation::~EcalSelectiveReadoutValidation

(

)

Destructor.

Definition at line 1375 of file EcalSelectiveReadoutValidation.cc.

                                                               {
}

Member Function Documentation

template<class T , class U >

void EcalSelectiveReadoutValidation::anaDigi ( const T &  frame, const U &  srFlagColl  )

private

Accumulates statitics for data volume analysis. To be called for each ECAL digi. See anaDigiInit().

Definition at line 1526 of file EcalSelectiveReadoutValidation.cc.

References Reference_intrackfit_cff::barrel, dccCh(), ebRuActive_, ebTtEdge, EcalBarrel, eeRuActive_, edm::hlt::Exception, archive::flag, iEta2cIndex(), iPhi2cIndex(), iXY2cIndex(), minDccId_, nEb_, nEbHI_, nEbLI_, nEe_, nEeHI_, nEeLI_, nHiPerDcc_, nHiRuPerDcc_, nLiPerDcc_, nLiRuPerDcc_, nPerDcc_, nPerRu_, nRuPerDcc_, DetId::rawId(), readOutUnitOf(), scEdge, EcalSrFlag::SRF_FULL, DetId::subdetId(), and ecaldqm::zside().

Referenced by analyzeDataVolume().

                                             {
  const DetId& xtalId = frame.id();
  typedef typename U::key_type RuDetId;
  const RuDetId& ruId = readOutUnitOf(frame.id());
  typename U::const_iterator srf = srFlagColl.find(ruId);

  bool highInterest = false;
  int flag = 0;
  
  if(srf != srFlagColl.end()){
    //     throw cms::Exception("EcalSelectiveReadoutValidation")
    //       << __FILE__ << ":" << __LINE__ << ": SR flag not found";
    //   }
    
    flag = srf->value() & ~EcalSrFlag::SRF_FORCED_MASK;
    
    highInterest = (flag == EcalSrFlag::SRF_FULL);
    
  }

  bool barrel = (xtalId.subdetId()==EcalBarrel);

  pair<int,int> ch = dccCh(xtalId);
  
  if(barrel){
    ++nEb_;
    if(highInterest){
      ++nEbHI_;
    } else{//low interest
      ++nEbLI_;
    }
    int iEta0 = iEta2cIndex(static_cast<const EBDetId&>(xtalId).ieta());
    int iPhi0 = iPhi2cIndex(static_cast<const EBDetId&>(xtalId).iphi());
    if(!ebRuActive_[iEta0/ebTtEdge][iPhi0/ebTtEdge]){
      ++nRuPerDcc_[ch.first-minDccId_];
      if(highInterest){
    //  fill(meFullRoRu_, ruGraphX(ruId), ruGraphY(ruId));
        ++nHiRuPerDcc_[ch.first-minDccId_];
      } else{
        ++nLiRuPerDcc_[ch.first-minDccId_];
      }
//       if(flag & EcalSrFlag::SRF_FORCED_MASK){
//  fill(meForcedRu_, ruGraphX(ruId), ruGraphY(ruId));
//       }
//       if(flag == EcalSrFlag::SRF_ZS1){
//         fill(meZs1Ru_, ruGraphX(ruId), ruGraphY(ruId));
//       }
      ebRuActive_[iEta0/ebTtEdge][iPhi0/ebTtEdge] = true;
    }
  } else{//endcap
    ++nEe_;
    if(highInterest){
      ++nEeHI_;
    } else{//low interest
      ++nEeLI_;
    }
    int iX0 = iXY2cIndex(static_cast<const EEDetId&>(frame.id()).ix());
    int iY0 = iXY2cIndex(static_cast<const EEDetId&>(frame.id()).iy());
    int iZ0 = static_cast<const EEDetId&>(frame.id()).zside()>0?1:0;

    if(!eeRuActive_[iZ0][iX0/scEdge][iY0/scEdge]){
      ++nRuPerDcc_[ch.first-minDccId_];
      if(highInterest){
    //  fill(meFullRoRu_, ruGraphX(ruId), ruGraphY(ruId));
        ++nHiRuPerDcc_[ch.first-minDccId_];
      } else{
        ++nLiRuPerDcc_[ch.first-minDccId_];
      }
//       if(flag == EcalSrFlag::SRF_ZS1){
//  fill(meZs1Ru_, ruGraphX(ruId), ruGraphY(ruId));
//       }
//       if(srf->value() & EcalSrFlag::SRF_FORCED_MASK){
//  fill(meForcedRu_, ruGraphX(ruId), ruGraphY(ruId));
//       }
      eeRuActive_[iZ0][iX0/scEdge][iY0/scEdge] = true;
    }
  }

  if(ch.second < 1 || ch.second > 68){
    throw cms::Exception("EcalSelectiveReadoutValidation")
      << "Error in DCC channel retrieval for crystal with detId "
      << xtalId.rawId() << "DCC channel out of allowed range [1..68]\n";
  }
  ++nPerDcc_[ch.first-minDccId_];
  ++nPerRu_[ch.first-minDccId_][ch.second-1];
  if(highInterest){
    ++nHiPerDcc_[ch.first-minDccId_];
  } else{//low interest channel
    ++nLiPerDcc_[ch.first-minDccId_];
  }
}

void EcalSelectiveReadoutValidation::anaDigiInit ( )

private

Initializes statistics accumalator for data volume analysis. To be call at start of each event analysis.

Definition at line 1619 of file EcalSelectiveReadoutValidation.cc.

References ebRuActive_, eeRuActive_, nEb_, nEbHI_, nEbLI_, nEe_, nEeHI_, nEeLI_, nHiPerDcc_, nHiRuPerDcc_, nLiPerDcc_, nLiRuPerDcc_, nPerDcc_, nPerRu_, and nRuPerDcc_.

Referenced by analyzeDataVolume().

                                                {
  nEb_ = 0;
  nEe_ = 0;
  nEeLI_ = 0;
  nEeHI_ = 0;
  nEbLI_ = 0;
  nEbHI_ = 0;
  bzero(nPerDcc_, sizeof(nPerDcc_));
  bzero(nLiPerDcc_, sizeof(nLiPerDcc_));
  bzero(nHiPerDcc_, sizeof(nHiPerDcc_));
  bzero(nRuPerDcc_, sizeof(nRuPerDcc_));
  bzero(ebRuActive_, sizeof(ebRuActive_));
  bzero(eeRuActive_, sizeof(eeRuActive_));
  bzero(nPerRu_, sizeof(nPerRu_));
  bzero(nLiRuPerDcc_, sizeof(nLiRuPerDcc_));
  bzero(nHiRuPerDcc_, sizeof(nHiRuPerDcc_));
}

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

protectedvirtual

Analyzes the event.

Implements edm::EDAnalyzer.

Definition at line 727 of file EcalSelectiveReadoutValidation.cc.

References analyzeDataVolume(), analyzeEB(), analyzeEE(), analyzeTP(), checkSrApplication(), compareSrfColl(), ebComputedSrFlags_, ebNoZsDigis_, ebSimHits_, ebSrFlags_, eeComputedSrFlags_, eeNoZsDigis_, eeSimHits_, eeSrFlags_, fill(), ievt_, meCompleteZSCnt_, meDroppedFROCnt_, meEbFullRoCnt_, meEbZsErrCnt_, meEbZsErrType1Cnt_, meEeFullRoCnt_, meEeZsErrCnt_, meEeZsErrType1Cnt_, meFullRoCnt_, meIncompleteFROCnt_, meZsErrCnt_, meZsErrType1Cnt_, nCompleteZS_, nDroppedFRO_, nEbFROCnt_, nEbZsErrors_, nEbZsErrorsType1_, nEeFROCnt_, nEeZsErrors_, nEeZsErrorsType1_, nIncompleteFRO_, readAllCollections(), selectFedsForLog(), setTtEtSums(), edmStreamStallGrapher::t, tps_, updateL1aRate(), withEbSimHit_, and withEeSimHit_.

                                               {

  updateL1aRate(event);
  
  {
   PgTiming t("collection readout");

   //retrieves event products:
   readAllCollections(event);

  }

  withEeSimHit_ = (eeSimHits_->size()!=0);
  withEbSimHit_ = (ebSimHits_->size()!=0);

  if(ievt_<10){
    edm::LogInfo("EcalSrValid") << "Size of TP collection: " << tps_->size() << "\n"
                << "Size of EB SRF collection read from data: "
                << ebSrFlags_->size() << "\n"
                << "Size of EB SRF collection computed from data TTFs: "
                << ebComputedSrFlags_->size() << "\n"
                << "Size of EE SRF collection read from data: "
                << eeSrFlags_->size() << "\n"
                << "Size of EE SRF collection computed from data TTFs: "
                << eeComputedSrFlags_->size() << "\n";
  }
  
  if(ievt_==0){
    selectFedsForLog(); //note: must be called after readAllCollection
  }

  //computes Et sum trigger tower crystals:
  setTtEtSums(es, *ebNoZsDigis_, *eeNoZsDigis_);

  {
    PgTiming t("data volume analysis");

    //Data Volume
    analyzeDataVolume(event, es);
  }

  {
    PgTiming t("EB analysis");
    //EB digis
    //must be called after analyzeDataVolume because it uses
    //isRuComplete_ array that this method fills
    analyzeEB(event, es);
  }

  {
    PgTiming t("EE analysis");
    //EE digis
    //must be called after analyzeDataVolume because it uses
    //isRuComplete_ array that this method fills
    analyzeEE(event, es);
  }

  fill(meFullRoCnt_, nEeFROCnt_+nEbFROCnt_);
  fill(meEbFullRoCnt_, nEbFROCnt_);
  fill(meEeFullRoCnt_, nEeFROCnt_);

  fill(meEbZsErrCnt_, nEbZsErrors_);
  fill(meEeZsErrCnt_, nEeZsErrors_);
  fill(meZsErrCnt_, nEbZsErrors_ + nEeZsErrors_);

  fill(meEbZsErrType1Cnt_, nEbZsErrorsType1_);
  fill(meEeZsErrType1Cnt_, nEeZsErrorsType1_);
  fill(meZsErrType1Cnt_, nEbZsErrorsType1_ + nEeZsErrorsType1_);

  {
    PgTiming t("TP analysis");
    //TP
    analyzeTP(event, es);
  }

  //SR Consistency and validation
  //SRFlagValidation(event,es);
  if(ebComputedSrFlags_->size()){
    compareSrfColl(event, *ebSrFlags_, *ebComputedSrFlags_);
  }
  if(eeComputedSrFlags_->size()){
    compareSrfColl(event, *eeSrFlags_, *eeComputedSrFlags_);
  }
  nDroppedFRO_ = 0;
  nIncompleteFRO_ = 0;
  nCompleteZS_ = 0;
  checkSrApplication(event, *ebSrFlags_);
  checkSrApplication(event, *eeSrFlags_);
  fill(meDroppedFROCnt_, nDroppedFRO_);
  fill(meIncompleteFROCnt_, nIncompleteFRO_);
  fill(meCompleteZSCnt_, nCompleteZS_);
  ++ievt_;
}

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

private

Data volume analysis. To be called for each event.

Parameters

event	EDM event
es	event setup

Definition at line 1460 of file EcalSelectiveReadoutValidation.cc.

References a, anaDigi(), anaDigiInit(), b, ebDigis_, ebSrFlags_, eeDigis_, eeSrFlags_, FEDRawDataCollection::FEDData(), fedRaw_, fill(), getBytesPerCrystal(), getCrystalCount(), getDccEventSize(), getDccSrDependentPayload(), getEbEventSize(), getEeEventSize(), isRuComplete_, kByte_, maxDccId_, meDccHiVol_, meDccLiVol_, meDccVol_, meDccVolFromData_, meVol_, meVolB_, meVolBHI_, meVolBLI_, meVolE_, meVolEHI_, meVolELI_, meVolHI_, meVolLI_, minDccId_, nDccRus_, nDccs_, nEb_, nEbHI_, nEbLI_, nEe_, nEeHI_, nEeLI_, nHiPerDcc_, nHiRuPerDcc_, nLiPerDcc_, nLiRuPerDcc_, nPerDcc_, nPerRu_, FEDRawData::size(), and edm::DataFrameContainer::size().

Referenced by analyze().

                                                    {

  anaDigiInit();


  //Complete RU, i.e. RU actually fully readout
  for(int iDcc = minDccId_; iDcc <= maxDccId_; ++iDcc){
    for(int iCh = 1; iCh < nDccRus_[iDcc-minDccId_]; ++iCh){
      isRuComplete_[iDcc-minDccId_][iCh-1]
        = (nPerRu_[iDcc-minDccId_][iCh-1]==getCrystalCount(iDcc, iCh));
    }
  }


  //Barrel
  for (unsigned int digis=0; digis<ebDigis_->size(); ++digis){
    EBDataFrame ebdf = (*ebDigis_)[digis];
    anaDigi(ebdf, *ebSrFlags_);
  }

  // Endcap
  for (unsigned int digis=0; digis<eeDigis_->size(); ++digis){
    EEDataFrame eedf = (*eeDigis_)[digis];
    anaDigi(eedf, *eeSrFlags_);
  }

  //histos
  for(unsigned iDcc0 = 0; iDcc0 <  nDccs_; ++iDcc0){
    fill(meDccVol_, iDcc0+1, getDccEventSize(iDcc0, nPerDcc_[iDcc0])/kByte_);
    fill(meDccLiVol_, iDcc0+1,
         getDccSrDependentPayload(iDcc0, nLiRuPerDcc_[iDcc0],
                                  nLiPerDcc_[iDcc0])/kByte_);
    fill(meDccHiVol_, iDcc0+1,
         getDccSrDependentPayload(iDcc0, nHiRuPerDcc_[iDcc0],
                                  nHiPerDcc_[iDcc0])/kByte_);
    const FEDRawDataCollection& raw = *fedRaw_;
    fill(meDccVolFromData_, iDcc0+1,
     ((double)raw.FEDData(601+iDcc0).size())/kByte_);
  }


  //low interesest channels:
  double a = nEbLI_*getBytesPerCrystal()/kByte_; //getEbEventSize(nEbLI_)/kByte_;
  fill(meVolBLI_, a);
  double b = nEeLI_*getBytesPerCrystal()/kByte_; //getEeEventSize(nEeLI_)/kByte_;
  fill(meVolELI_, b);
  fill(meVolLI_, a+b);

  //high interest chanels:
  a = nEbHI_*getBytesPerCrystal()/kByte_; //getEbEventSize(nEbHI_)/kByte_;
  fill(meVolBHI_, a);
  b = nEeHI_*getBytesPerCrystal()/kByte_; //getEeEventSize(nEeHI_)/kByte_;
  fill(meVolEHI_, b);
  fill(meVolHI_, a+b);

  //any-interest channels:
  a = getEbEventSize(nEb_)/kByte_;
  fill(meVolB_, a);
  b = getEeEventSize(nEe_)/kByte_;
  fill(meVolE_, b);
  fill(meVol_, a+b);
}

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

private

ECAL barrel data analysis. To be called for each event.

Parameters

event	EDM event
es	event setup

Definition at line 1076 of file EcalSelectiveReadoutValidation.cc.

References edm::DataFrameContainer::begin(), gather_cfg::cout, dccCh(), dccZsFIR(), ebDigis_, ebEnergies, ebNoZsDigis_, ebRecHits_, ebSimHits_, ebSrFlags_, ebZsThr_, DetId::Ecal, EcalBarrel, edm::DataFrameContainer::end(), PCaloHit::energy(), EcalRecHit::energy(), PV3DBase< T, PVType, FrameType >::eta(), EcalSelectiveReadoutValidation::energiesEb_t::eta, edm::hlt::Exception, fill(), firstFIRSample_, firWeights_, archive::flag, frame2Energy(), EcalSelectiveReadoutValidation::energiesEb_t::gain12, ecalMGPA::gainId(), geometry, edm::EventSetup::get(), CaloSubdetectorGeometry::getGeometry(), i, EBDataFrame::id(), EBSrFlag::id(), PCaloHit::id(), EcalRecHit::id(), EBDetId::ieta(), iEta2cIndex(), EcalTrigTowerDetId::ietaAbs(), ievt_, EcalTrigTowerDetId::iphi(), iPhi2cIndex(), isRuComplete_, localReco_, max(), meChOcc_, meEbEMean_, meEbHiZsFir_, meEbLiZsFir_, meEbNoise_, meEbNoZsRecVsSimE_, meEbRecE_, meEbRecEHitXtal_, meEbRecVsSimE_, meEbSimE_, meForcedRu_, meFullRoRu_, meZs1Ru_, nEbEta, nEbFROCnt_, nEbPhi, nEbZsErrors_, nEbZsErrorsType1_, EcalSelectiveReadoutValidation::energiesEb_t::noZsRecE, PV3DBase< T, PVType, FrameType >::phi(), EcalSelectiveReadoutValidation::energiesEb_t::phi, rad2deg, readOutUnitOf(), EcalSelectiveReadoutValidation::energiesEb_t::recE, ruGraphX(), ruGraphY(), alignCSCRings::s, EcalSelectiveReadoutValidation::energiesEb_t::simE, EcalSelectiveReadoutValidation::energiesEb_t::simHit, EcalDataFrame::size(), srApplicationErrorLog_, EcalSrFlag::SRF_FORCED_MASK, EcalSrFlag::SRF_FULL, EcalSrFlag::SRF_ZS1, PgTiming::stop(), edmStreamStallGrapher::t, findQualityFiles::v, EcalSrFlag::value(), withEbSimHit_, xtalGraphX(), xtalGraphY(), and EcalTrigTowerDetId::zside().

Referenced by analyze().

                                              {

    bool eventError = false;
    nEbZsErrors_ = 0;
    vector<pair<int,int> > xtalEtaPhi;

  {
    PgTiming t("analyzeEB: init");

    xtalEtaPhi.reserve(nEbPhi*nEbEta);
    for(int iEta0=0; iEta0<nEbEta; ++iEta0){
      for(int iPhi0=0; iPhi0<nEbPhi; ++iPhi0){
        ebEnergies[iEta0][iPhi0].noZsRecE = -numeric_limits<double>::max();
        ebEnergies[iEta0][iPhi0].recE = -numeric_limits<double>::max();
        ebEnergies[iEta0][iPhi0].simE = 0; //must be zero.
        ebEnergies[iEta0][iPhi0].simHit = 0;
        ebEnergies[iEta0][iPhi0].gain12 = false;
        xtalEtaPhi.push_back(pair<int,int>(iEta0, iPhi0));
      }
    }
  }

    // get the barrel geometry:
  edm::ESHandle<CaloGeometry> geoHandle;

  PgTiming t1("analyzeEB: geomRetrieval");
  es.get<MyCaloGeometryRecord>().get(geoHandle);
  const CaloSubdetectorGeometry *geometry_p
    = (*geoHandle).getSubdetectorGeometry(DetId::Ecal, EcalBarrel);
  CaloSubdetectorGeometry const& geometry = *geometry_p;
  t1.stop();


  {
    PgTiming t("analyzeEB: unsuppressed digi loop");
    //EB unsuppressed digis:
    for(EBDigiCollection::const_iterator it = ebNoZsDigis_->begin();
        it != ebNoZsDigis_->end(); ++it){
      const EBDataFrame& frame = *it;
      int iEta0 = iEta2cIndex(static_cast<const EBDetId&>(frame.id()).ieta());
      int iPhi0 = iPhi2cIndex(static_cast<const EBDetId&>(frame.id()).iphi());
      if(iEta0<0 || iEta0>=nEbEta){
        stringstream s;
        s << "EcalSelectiveReadoutValidation: "
          << "iEta0 (= " << iEta0 << ") is out of range ("
          << "[0," << nEbEta -1 << "]\n";
        throw cms::Exception(s.str());
      }
      if(iPhi0<0 || iPhi0>=nEbPhi){
        stringstream s;
        s << "EcalSelectiveReadoutValidation: "
          << "iPhi0 (= " << iPhi0 << ") is out of range ("
          << "[0," << nEbPhi -1 << "]\n";
        throw cms::Exception(s.str());
      }

      ebEnergies[iEta0][iPhi0].noZsRecE = frame2Energy(frame);
      ebEnergies[iEta0][iPhi0].gain12 = true;
      for(int i = 0; i< frame.size(); ++i){
        const int gain12Code = 0x1;
        if(frame[i].gainId()!=gain12Code) ebEnergies[iEta0][iPhi0].gain12 =  false;
      }

      const GlobalPoint xtalPos
        = geometry.getGeometry(frame.id())->getPosition();

      ebEnergies[iEta0][iPhi0].phi = rad2deg*((double)xtalPos.phi());
      ebEnergies[iEta0][iPhi0].eta = xtalPos.eta();
    } //next non-zs digi
  }


  {
    PgTiming t("analyzeEB: simHit loop");
    //EB sim hits
    for(vector<PCaloHit>::const_iterator it = ebSimHits_->begin();
        it != ebSimHits_->end(); ++it){
      const PCaloHit& simHit = *it;
      EBDetId detId(simHit.id());
      int iEta = detId.ieta();
      int iEta0 =iEta2cIndex(iEta);
      int iPhi = detId.iphi();
      int iPhi0 = iPhi2cIndex(iPhi);
      ebEnergies[iEta0][iPhi0].simE += simHit.energy();
      ++ebEnergies[iEta0][iPhi0].simHit;
    }
  }

    bool crystalShot[nEbEta][nEbPhi];
  {
    PgTiming t("analyzeEB: suppressed digi loop init");

    for(int iEta0=0; iEta0<nEbEta; ++iEta0){
      for(int iPhi0=0; iPhi0<nEbPhi; ++iPhi0){
        crystalShot[iEta0][iPhi0] = false;
      }
    }
  }

  int nEbDigi = 0;

  {
    PgTiming t("analyzeEB: suppressed digi loop");

    for(EBDigiCollection::const_iterator it = ebDigis_->begin();
        it != ebDigis_->end(); ++it){
        ++nEbDigi;
        const EBDataFrame& frame = *it;
        int iEta = static_cast<const EBDetId&>(frame.id()).ieta();
        int iPhi = static_cast<const EBDetId&>(frame.id()).iphi();
        int iEta0 = iEta2cIndex(iEta);
        int iPhi0 = iPhi2cIndex(iPhi);
        if(iEta0<0 || iEta0>=nEbEta){
          throw (cms::Exception("EcalSelectiveReadoutValidation")
                 << "iEta0 (= " << iEta0 << ") is out of range ("
                 << "[0," << nEbEta -1 << "]");
        }
        if(iPhi0<0 || iPhi0>=nEbPhi){
          throw (cms::Exception("EcalSelectiveReadoutValidation")
                 << "iPhi0 (= " << iPhi0 << ") is out of range ("
                 << "[0," << nEbPhi -1 << "]");
        }
        assert(iEta0>=0 && iEta0<nEbEta);
        assert(iPhi0>=0 && iPhi0<nEbPhi);
        if(!crystalShot[iEta0][iPhi0]){
          crystalShot[iEta0][iPhi0] = true;
        } else{
          cout << "Error: several digi for same crystal!";
          abort();
        }
        if(localReco_){
          ebEnergies[iEta0][iPhi0].recE = frame2Energy(frame);
        }

        ebEnergies[iEta0][iPhi0].gain12 = true;
        for(int i = 0; i< frame.size(); ++i){
          const int gain12Code = 0x1;
          if(frame[i].gainId()!=gain12Code){
            ebEnergies[iEta0][iPhi0].gain12 =  false;
          }
        }

        fill(meChOcc_, xtalGraphX(frame.id()), xtalGraphY(frame.id()));
        EBSrFlagCollection::const_iterator srf
          = ebSrFlags_->find(readOutUnitOf(frame.id()));

        bool highInterest = false;

        // if(srf == ebSrFlags_->end()){
        //       throw cms::Exception("EcalSelectiveReadoutValidation")
        //  << __FILE__ << ":" << __LINE__ << ": SR flag not found";
        //}

        if(srf != ebSrFlags_->end()){
          highInterest = ((srf->value() & ~EcalSrFlag::SRF_FORCED_MASK)
                          == EcalSrFlag::SRF_FULL);
        }


        if(highInterest){
          fill(meEbHiZsFir_, dccZsFIR(frame, firWeights_, firstFIRSample_, 0));
        } else{
          int v = dccZsFIR(frame, firWeights_, firstFIRSample_, 0);
          fill(meEbLiZsFir_, v);
          if(v < ebZsThr_){
            eventError = true;
            ++nEbZsErrors_;
            pair<int,int> ru = dccCh(frame.id());
            if(isRuComplete_[ru.first][ru.second-1]) ++nEbZsErrorsType1_;
            if(nEbZsErrors_ < 3){
              srApplicationErrorLog_ << event.id() << ", "
                                     << "RU " << frame.id() << ", "
                                     << "DCC " << ru.first
                                     << " Ch : " << ru.second << ": "
                                     << "LI channel under ZS threshold.\n";
            }
            if(nEbZsErrors_==3){
              srApplicationErrorLog_ << event.id() << ": "
                                     << "more ZS errors for this event...\n";
            }
          }
        }
      } //next EB digi
    }


    {
      PgTiming t("analyzeEB: rec hit loop");

      if(!localReco_){
        for(RecHitCollection::const_iterator it
              = ebRecHits_->begin();
            it != ebRecHits_->end(); ++it){
          ++nEbDigi;
          const RecHit& hit = *it;
          int iEta = static_cast<const EBDetId&>(hit.id()).ieta();
          int iPhi = static_cast<const EBDetId&>(hit.id()).iphi();
          int iEta0 = iEta2cIndex(iEta);
          int iPhi0 = iPhi2cIndex(iPhi);
          if(iEta0<0 || iEta0>=nEbEta){
            LogError("EcalSrValid") << "iEta0 (= " << iEta0 << ") is out of range ("
                    << "[0," << nEbEta -1 << "]\n";
          }
          if(iPhi0<0 || iPhi0>=nEbPhi){
            LogError("EcalSrValid") << "iPhi0 (= " << iPhi0 << ") is out of range ("
                    << "[0," << nEbPhi -1 << "]\n";
          }
          ebEnergies[iEta0][iPhi0].recE = hit.energy();
        }
      }
    }


//     {
//       PgTiming t("analyzeEB: crystal sorting");

//       //sorts crystal in increasing sim hit energy. ebEnergies[][].simE
//       //must be set beforehand:
//       sort(xtalEtaPhi.begin(), xtalEtaPhi.end(), Sorter(this));
//       cout << "\niEta\tiPhi\tsimE\tnoZsE\tzsE\n";
//     }


    {
      PgTiming t("analyzeEB: loop on energies");

        for(unsigned int i=0; i<xtalEtaPhi.size(); ++i){
          int iEta0 = xtalEtaPhi[i].first;
          int iPhi0=  xtalEtaPhi[i].second;
          energiesEb_t& energies = ebEnergies[iEta0][iPhi0];

          double recE = energies.recE;
          if(recE!=-numeric_limits<double>::max()){//not zero suppressed
            fill(meEbRecE_, ebEnergies[iEta0][iPhi0].recE);
            fill(meEbEMean_, ievt_+1, recE);
          } //not zero suppressed

          if(withEbSimHit_){
            if(!energies.simHit){//noise only crystal channel
              fill(meEbNoise_, energies.noZsRecE);
            } else{
              fill(meEbSimE_, energies.simE);
              fill(meEbRecEHitXtal_, energies.recE);
            }
            fill(meEbRecVsSimE_, energies.simE, energies.recE);
            fill(meEbNoZsRecVsSimE_, energies.simE, energies.noZsRecE);
          }
        }
    }

    {
      PgTiming t("analyzeEB: SRF");
      //SRF
      nEbFROCnt_ = 0;
      char ebSrfMark[2][17][72];
      bzero(ebSrfMark, sizeof(ebSrfMark));
      //      int idbg = 0;
      for(EBSrFlagCollection::const_iterator it = ebSrFlags_->begin();
          it != ebSrFlags_->end(); ++it){
        const EBSrFlag& srf = *it;
    int iEtaAbs = srf.id().ietaAbs();
    int iPhi = srf.id().iphi();
    int iZ = srf.id().zside();

//  cout << "--> " << ++idbg << iEtaAbs << " " << iPhi << " "  << iZ
//       << " " << srf.id() << "\n";
    
    if(iEtaAbs < 1 || iEtaAbs > 17
       || iPhi < 1 || iPhi > 72) throw cms::Exception("EcalSelectiveReadoutValidation")
         << "Found a barrel SRF with an invalid det ID: " << srf.id() << ".\n";
    ++ebSrfMark[iZ>0?1:0][iEtaAbs-1][iPhi-1];
    if(ebSrfMark[iZ>0?1:0][iEtaAbs-1][iPhi-1] > 1) throw cms::Exception("EcalSelectiveReadoutValidation")
      << "Duplicate SRF for RU " << srf.id() << ".\n";
        int flag = srf.value() & ~EcalSrFlag::SRF_FORCED_MASK;
    if(flag == EcalSrFlag::SRF_ZS1){
      fill(meZs1Ru_, ruGraphX(srf.id()), ruGraphY(srf.id()));
    }
        if(flag == EcalSrFlag::SRF_FULL){
      fill(meFullRoRu_, ruGraphX(srf.id()), ruGraphY(srf.id()));
          ++nEbFROCnt_;
        }
        if(srf.value() & EcalSrFlag::SRF_FORCED_MASK){
      fill(meForcedRu_, ruGraphX(srf.id()), ruGraphY(srf.id()));
        }
      }
    }

    {
      PgTiming t("analyzeEB: logSRerror");

      if(eventError) srApplicationErrorLog_ << event.id()
                                            << ": " << nEbZsErrors_
                                            << " ZS-flagged EB channels under "
                       "the ZS threshold, whose " << nEbZsErrorsType1_
                                            << " in a complete RU.\n";
    }
}

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

private

ECAL endcap data analysis. To be called for each event.

Parameters

event	EDM event
es	event setup

Definition at line 823 of file EcalSelectiveReadoutValidation.cc.

References edm::DataFrameContainer::begin(), dccCh(), dccZsFIR(), DetId::Ecal, EcalEndcap, eeDigis_, eeEnergies, eeNoZsDigis_, eeRecHits_, eeSimHits_, eeSrFlags_, eeZsThr_, edm::DataFrameContainer::end(), PCaloHit::energy(), EcalRecHit::energy(), PV3DBase< T, PVType, FrameType >::eta(), EcalSelectiveReadoutValidation::energiesEe_t::eta, edm::hlt::Exception, fill(), firstFIRSample_, firWeights_, archive::flag, frame2Energy(), EcalSelectiveReadoutValidation::energiesEe_t::gain12, ecalMGPA::gainId(), geometry, edm::EventSetup::get(), CaloSubdetectorGeometry::getGeometry(), i, EEDataFrame::id(), EESrFlag::id(), PCaloHit::id(), EcalRecHit::id(), ievt_, isRuComplete_, EcalScDetId::ix(), EEDetId::ix(), iXY2cIndex(), EcalScDetId::iy(), EEDetId::iy(), localReco_, max(), meChOcc_, meEeEMean_, meEeHiZsFir_, meEeLiZsFir_, meEeNoise_, meEeNoZsRecVsSimE_, meEeRecE_, meEeRecEHitXtal_, meEeRecVsSimE_, meEeSimE_, meForcedRu_, meFullRoRu_, meZs1Ru_, nEeFROCnt_, nEeX, nEeY, nEeZsErrors_, nEeZsErrorsType1_, nEndcaps, EcalSelectiveReadoutValidation::energiesEe_t::noZsRecE, PV3DBase< T, PVType, FrameType >::phi(), EcalSelectiveReadoutValidation::energiesEe_t::phi, rad2deg, readOutUnitOf(), EcalSelectiveReadoutValidation::energiesEe_t::recE, ruGraphX(), ruGraphY(), EcalSelectiveReadoutValidation::energiesEe_t::simE, EcalSelectiveReadoutValidation::energiesEe_t::simHit, EcalDataFrame::size(), edm::DataFrameContainer::size(), srApplicationErrorLog_, EcalSrFlag::SRF_FORCED_MASK, EcalSrFlag::SRF_FULL, EcalSrFlag::SRF_ZS1, edmStreamStallGrapher::t, findQualityFiles::v, EcalSrFlag::value(), withEeSimHit_, xtalGraphX(), xtalGraphY(), EcalScDetId::zside(), EEDetId::zside(), and ecaldqm::zside().

Referenced by analyze().

                                                   {
  bool eventError = false;
  nEeZsErrors_ = 0;

  {
    PgTiming t("analyzeEE: init");
    for(int iZ0=0; iZ0<nEndcaps; ++iZ0){
      for(int iX0=0; iX0<nEeX; ++iX0){
        for(int iY0=0; iY0<nEeY; ++iY0){
          eeEnergies[iZ0][iX0][iY0].noZsRecE = -numeric_limits<double>::max();
          eeEnergies[iZ0][iX0][iY0].recE = -numeric_limits<double>::max();
          eeEnergies[iZ0][iX0][iY0].simE = 0; //must be set to zero.
          eeEnergies[iZ0][iX0][iY0].simHit = 0;
          eeEnergies[iZ0][iX0][iY0].gain12   = false;
        }
      }
    }
  }

  // gets the endcap geometry:
  edm::ESHandle<CaloGeometry> geoHandle;
  es.get<MyCaloGeometryRecord>().get(geoHandle);
  const CaloSubdetectorGeometry *geometry_p
    = (*geoHandle).getSubdetectorGeometry(DetId::Ecal, EcalEndcap);
  CaloSubdetectorGeometry const& geometry = *geometry_p;

  {
    PgTiming t("analyzeEE: unsupressed digis");
      //EE unsupressed digis:
      for (unsigned int digis=0; digis<eeNoZsDigis_->size(); ++digis){

        EEDataFrame frame = (*eeNoZsDigis_)[digis];
        int iX0 = iXY2cIndex(frame.id().ix());
        int iY0 = iXY2cIndex(frame.id().iy());
        int iZ0 = frame.id().zside()>0?1:0;

        if(iX0<0 || iX0>=nEeX){
          edm::LogError("EcalSrValid") << "iX0 (= " << iX0 << ") is out of range ("
                       << "[0," << nEeX -1 << "]\n";
        }
        if(iY0<0 || iY0>=nEeY){
          edm::LogError("EcalSrValid") << "iY0 (= " << iY0 << ") is out of range ("
                       << "[0," << nEeY -1 << "]\n";
        }
        //    cout << "EE no ZS energy computation..." ;
        eeEnergies[iZ0][iX0][iY0].noZsRecE = frame2Energy(frame);

        eeEnergies[iZ0][iX0][iY0].gain12 = true;
        for(int i = 0; i< frame.size(); ++i){
          const int gain12Code = 0x1;
          if(frame[i].gainId()!=gain12Code) eeEnergies[iZ0][iX0][iY0].gain12 =  false;
        }

        const GlobalPoint xtalPos
          = geometry.getGeometry(frame.id())->getPosition();

        eeEnergies[iZ0][iX0][iY0].phi = rad2deg*((double)xtalPos.phi());
        eeEnergies[iZ0][iX0][iY0].eta = xtalPos.eta();
      }
  }

  {
    PgTiming t("analyzeEE:rec hits");
    //EE rec hits:
    if(!localReco_){
      for(RecHitCollection::const_iterator it
            = eeRecHits_->begin();
          it != eeRecHits_->end(); ++it){
        const RecHit& hit = *it;
        int iX0 = iXY2cIndex(static_cast<const EEDetId&>(hit.id()).ix());
        int iY0 = iXY2cIndex(static_cast<const EEDetId&>(hit.id()).iy());
        int iZ0 = static_cast<const EEDetId&>(hit.id()).zside()>0?1:0;

        if(iX0<0 || iX0>=nEeX){
          LogError("EcalSrValid") << "iX0 (= " << iX0 << ") is out of range ("
                  << "[0," << nEeX -1 << "]\n";
        }
        if(iY0<0 || iY0>=nEeY){
          LogError("EcalSrValid") << "iY0 (= " << iY0 << ") is out of range ("
               << "[0," << nEeY -1 << "]\n";
        }
        //    cout << "EE no ZS energy computation..." ;
        eeEnergies[iZ0][iX0][iY0].recE = hit.energy();
      }
    }
  }

  {
    PgTiming t("analyzeEE:sim hits");
    //EE sim hits:
    for(vector<PCaloHit>::const_iterator it = eeSimHits_->begin();
        it != eeSimHits_->end(); ++it){
      const PCaloHit& simHit = *it;
      EEDetId detId(simHit.id());
      int iX = detId.ix();
      int iX0 =iXY2cIndex(iX);
      int iY = detId.iy();
      int iY0 = iXY2cIndex(iY);
      int iZ0 = detId.zside()>0?1:0;
      eeEnergies[iZ0][iX0][iY0].simE += simHit.energy();
      ++eeEnergies[iZ0][iX0][iY0].simHit;
    }
  }

  {
    PgTiming t("analyzeEE: suppressed digis");

    //EE suppressed digis
    for(EEDigiCollection::const_iterator it = eeDigis_->begin();
        it != eeDigis_->end(); ++it){
      const EEDataFrame& frame = *it;
      int iX0 = iXY2cIndex(static_cast<const EEDetId&>(frame.id()).ix());
      int iY0 = iXY2cIndex(static_cast<const EEDetId&>(frame.id()).iy());
      int iZ0 = static_cast<const EEDetId&>(frame.id()).zside()>0?1:0;
      if(iX0<0 || iX0>=nEeX){
        LogError("EcalSrValid") << "iX0 (= " << iX0 << ") is out of range ("
                << "[0," << nEeX -1 << "]\n";
      }
      if(iY0<0 || iY0>=nEeY){
        LogError("EcalSrValid") << "iY0 (= " << iY0 << ") is out of range ("
                << "[0," << nEeY -1 << "]\n";
      }

      if(localReco_){
        eeEnergies[iZ0][iX0][iY0].recE = frame2Energy(frame);
      }

      eeEnergies[iZ0][iX0][iY0].gain12 = true;
      for(int i = 0; i< frame.size(); ++i){
        const int gain12Code = 0x1;
        if(frame[i].gainId()!=gain12Code){
          eeEnergies[iZ0][iX0][iY0].gain12 =  false;
        }
      }

      fill(meChOcc_, xtalGraphX(frame.id()), xtalGraphY(frame.id()));

      EESrFlagCollection::const_iterator srf
        = eeSrFlags_->find(readOutUnitOf(frame.id()));

      bool highInterest = false;


      if(srf==eeSrFlags_->end()) continue;

      if(srf!=eeSrFlags_->end()){
        highInterest = ((srf->value() & ~EcalSrFlag::SRF_FORCED_MASK)
                        == EcalSrFlag::SRF_FULL);
      }

      if(highInterest){
        fill(meEeHiZsFir_, dccZsFIR(frame, firWeights_, firstFIRSample_, 0));
      } else{
        int v = dccZsFIR(frame, firWeights_, firstFIRSample_, 0);
        fill(meEeLiZsFir_, v);
        if(v < eeZsThr_){
          eventError = true;
          ++nEeZsErrors_;
          pair<int,int> ru = dccCh(frame.id());
          if(isRuComplete_[ru.first][ru.second-1]) ++nEeZsErrorsType1_;
          if(nEeZsErrors_ < 3){
            srApplicationErrorLog_ << event.id() << ", "
                                   << "RU " << frame.id() << ", "
                                   << "DCC " << ru.first
                                   << " Ch : " << ru.second << ": "
                                   << "LI channel under ZS threshold.\n";
          }
          if(nEeZsErrors_==3){
            srApplicationErrorLog_ << event.id() << ": "
                                   << "more ZS errors for this event...\n";
          }
        }
      }
    } //next ZS digi.
  }

  {
    PgTiming t("analyzeEE: energies");

    for(int iZ0=0; iZ0<nEndcaps; ++iZ0){
      for(int iX0=0; iX0<nEeX; ++iX0){
        for(int iY0=0; iY0<nEeY; ++iY0){
          double recE = eeEnergies[iZ0][iX0][iY0].recE;
          if(recE==-numeric_limits<double>::max()) continue; //not a crystal or ZS
          fill(meEeRecE_, eeEnergies[iZ0][iX0][iY0].recE);

          fill(meEeEMean_, ievt_+1,
               eeEnergies[iZ0][iX0][iY0].recE);

          if(withEeSimHit_){
            if(!eeEnergies[iZ0][iX0][iY0].simHit){//noise only crystal channel
              fill(meEeNoise_, eeEnergies[iZ0][iX0][iY0].noZsRecE);
            } else{
              fill(meEeSimE_, eeEnergies[iZ0][iX0][iY0].simE);
              fill(meEeRecEHitXtal_, eeEnergies[iZ0][iX0][iY0].recE);
            }
            fill(meEeRecVsSimE_, eeEnergies[iZ0][iX0][iY0].simE,
                 eeEnergies[iZ0][iX0][iY0].recE);
            fill(meEeNoZsRecVsSimE_, eeEnergies[iZ0][iX0][iY0].simE,
                 eeEnergies[iZ0][iX0][iY0].noZsRecE);
          }
        }
      }
    }
  }

  {
    PgTiming t("analyzeEE: RU");

    nEeFROCnt_ = 0;
    char eeSrfMark[2][100][100];
    bzero(eeSrfMark, sizeof(eeSrfMark));
    //Filling RU histo
    for(EESrFlagCollection::const_iterator it = eeSrFlags_->begin();
        it != eeSrFlags_->end(); ++it){
      const EESrFlag& srf = *it;
      int iX = srf.id().ix();
      int iY = srf.id().iy();
      int iZ = srf.id().zside(); //-1 for EE-, +1 for EE+
      if(iX<1 || iY > 100) throw cms::Exception("EcalSelectiveReadoutValidation")
    << "Found an endcap SRF with an invalid det ID: " << srf.id() << ".\n";
      ++eeSrfMark[iZ>0?1:0][iX-1][iY-1];
      if(eeSrfMark[iZ>0?1:0][iX-1][iY-1] > 1) throw cms::Exception("EcalSelectiveReadoutValidation")
    << "Duplicate SRF for supercrystal " << srf.id() << ".\n";
      int flag = srf.value() & ~EcalSrFlag::SRF_FORCED_MASK;
      if(flag == EcalSrFlag::SRF_ZS1){
        fill(meZs1Ru_, ruGraphX(srf.id()), ruGraphY(srf.id()));
      }

      if(flag == EcalSrFlag::SRF_FULL){
    fill(meFullRoRu_, ruGraphX(srf.id()), ruGraphY(srf.id()));
    ++nEeFROCnt_;
      }
      
      if(srf.value() & EcalSrFlag::SRF_FORCED_MASK){
    fill(meForcedRu_, ruGraphX(srf.id()), ruGraphY(srf.id()));
      }
    }
  }
  
  {
    PgTiming t("analyzeEE: SR appli error log");

    if(eventError) srApplicationErrorLog_ << event.id()
                                          << ": " << nEeZsErrors_
                                          << " ZS-flagged EE channels under "
                     "the ZS threshold, whose " << nEeZsErrorsType1_
                                          << " in a complete RU.\n";
  }
} //end of analyzeEE

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

private

Trigger primitive analysis. To be called for each event.

Parameters

event	EDM event
es	event setup

Definition at line 1399 of file EcalSelectiveReadoutValidation.cc.

References fill(), EcalTPGScale::getTPGInGeV(), iTtEta2cIndex(), meForcedTtf_, meHiTtf_, meLiTtf_, meMiTtf_, meTp_, meTpMap_, meTpVsEtSum_, meTtf_, meTtfVsEtSum_, meTtfVsTp_, EcalTPGScale::setEventSetup(), tpInGeV_, tps_, and ttEtSums.

Referenced by analyze().

                                               {
  EcalTPGScale ecalScale;
#if (CMSSW_COMPAT_VERSION>=210)
  ecalScale.setEventSetup(es) ;
#endif

  //  std::cout << __FILE__ << __LINE__
  //        << "n TP: " << tps_->size() <<std::endl;

  for(EcalTrigPrimDigiCollection::const_iterator it = tps_->begin();
      it != tps_->end(); ++it){
    //    for(int i = 0; i < it->size(); ++i){
    //  double v = (*it)[i].raw() & 0xFF;
    //  if(v>0) std::cout << v << " " << i << std::endl;
    //}
    //    if(it->compressedEt() > 0){
    //  std::cout << "---------> " << it->id().ieta() << ", "
    //      << it->id().iphi() << ", "
    //      << it->compressedEt() << std::endl;
    //}

    //const int iTcc = elecMap_->TCCid(it->id());
    //const int iTt = elecMap_->iTt(it->id());
    double tpEt;
    if(tpInGeV_){
#if (CMSSW_COMPAT_VERSION<210)
      tpEt = ecalScale.getTPGInGeV(es, *it);
#else
      tpEt = ecalScale.getTPGInGeV(it->compressedEt(), it->id()) ;
#endif
    } else{
      tpEt = it->compressedEt();
    }
    int iEta = it->id().ieta();
    int iEta0 = iTtEta2cIndex(iEta);
    int iPhi = it->id().iphi();
    int iPhi0 = iTtEta2cIndex(iPhi);
    double etSum = ttEtSums[iEta0][iPhi0];
    fill(meTp_, tpEt);
    fill(meTpVsEtSum_, etSum, tpEt);
    fill(meTtf_, it->ttFlag());
    if((it->ttFlag() & 0x3) == 0){
      fill(meLiTtf_, iEta, iPhi);
    }
    if((it->ttFlag() & 0x3) == 1){
      fill(meMiTtf_, iEta, iPhi);
    }
    if((it->ttFlag() & 0x3) == 3){
      fill(meHiTtf_, iEta, iPhi);
    }
    if((it->ttFlag() & 0x4)){
      fill(meForcedTtf_, iEta, iPhi);
    }

    fill(meTtfVsTp_, tpEt, it->ttFlag());
    fill(meTtfVsEtSum_, etSum, it->ttFlag());
    fill(meTpMap_, iEta, iPhi, tpEt, 1.);
  }
}

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

protectedvirtual

Calls at begin of run.

Reimplemented from edm::EDAnalyzer.

Definition at line 1378 of file EcalSelectiveReadoutValidation.cc.

References elecMap_, edm::EventSetup::get(), initAsciiFile(), edm::ESHandle< class >::product(), and triggerTowerMap_.

                                                                                     {
  // endcap mapping
  edm::ESHandle<EcalTrigTowerConstituentsMap> hTriggerTowerMap;
  es.get<IdealGeometryRecord>().get(hTriggerTowerMap);
  triggerTowerMap_ = hTriggerTowerMap.product();

  //electronics map
  ESHandle< EcalElectronicsMapping > ecalmapping;
  es.get< EcalMappingRcd >().get(ecalmapping);
  elecMap_ = ecalmapping.product();

  initAsciiFile();
}

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

private

Definition at line 1949 of file EcalSelectiveReadoutValidation.cc.

References DQMStore::book1D(), dbe_, edm::hlt::Exception, mergeVDriftHistosByStation::name, registerHist(), and query::result.

Referenced by EcalSelectiveReadoutValidation().

                                                                                                                                        {
  if(!registerHist(name, title)) return 0; //this histo is disabled
  MonitorElement* result = dbe_->book1D(name, title, nbins, xmin, xmax);
  if(result==0){
    throw cms::Exception("Histo")
      << "Failed to book histogram " << name;
  }
  return result;
}

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

private

Definition at line 1959 of file EcalSelectiveReadoutValidation.cc.

References DQMStore::book2D(), dbe_, edm::hlt::Exception, mergeVDriftHistosByStation::name, registerHist(), and query::result.

Referenced by EcalSelectiveReadoutValidation().

                                                                                                                                                                               {
  if(!registerHist(name, title)) return 0; //this histo is disabled
  MonitorElement* result = dbe_->book2D(name, title, nxbins, xmin, xmax,
                    nybins, ymin, ymax);
  if(result==0){
    throw cms::Exception("Histo")
      << "Failed to book histogram " << name;
  }
  return result;
}

MonitorElement * EcalSelectiveReadoutValidation::bookFloat ( const std::string &  name )

private

Wrappers to the book methods of the DQMStore DQM histogramming interface.

Definition at line 1938 of file EcalSelectiveReadoutValidation.cc.

References DQMStore::bookFloat(), dbe_, edm::hlt::Exception, mergeVDriftHistosByStation::name, registerHist(), and query::result.

Referenced by EcalSelectiveReadoutValidation().

                                                                              {
  if(!registerHist(name, "")) return 0; //this histo is disabled
  MonitorElement* result = dbe_->bookFloat(name);
  if(result==0){
    throw cms::Exception("DQM")
      << "Failed to book integer DQM monitor element" << name;
  }
  return result;
}

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

private

Definition at line 1970 of file EcalSelectiveReadoutValidation.cc.

References DQMStore::bookProfile(), dbe_, edm::hlt::Exception, mergeVDriftHistosByStation::name, registerHist(), and query::result.

Referenced by EcalSelectiveReadoutValidation().

                                                                                                                                             {
  if(!registerHist(name, title)) return 0; //this histo is disabled
  MonitorElement* result = dbe_->bookProfile(name, title, nbins, xmin, xmax,
                         0, 0, 0);
  if(result==0){
    throw cms::Exception("Histo")
      << "Failed to book histogram " << name;
  }
  return result;
}

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

private

Definition at line 1981 of file EcalSelectiveReadoutValidation.cc.

References DQMStore::bookProfile2D(), dbe_, edm::hlt::Exception, mergeVDriftHistosByStation::name, registerHist(), and query::result.

Referenced by EcalSelectiveReadoutValidation().

                                                                                                                                                                                                        {
  if(!registerHist(name, title)) return 0; //this histo is disabled
  MonitorElement* result
    = dbe_->bookProfile2D(name,
              title,
              nbinx, xmin, xmax,
              nbiny, ymin, ymax,
              0, 0, 0,
              option);
  if(result==0){
    throw cms::Exception("Histo")
      << "Failed to book histogram " << name;
  }
  return result;
}

template<class T >

void EcalSelectiveReadoutValidation::checkSrApplication ( const edm::Event &  event, T &  srfs  )

private

Checks application of SR decision by the DCC.

Parameters

event	event currently analyzed.
srfs	Selective readou flags

Definition at line 2351 of file EcalSelectiveReadoutValidation.cc.

References dccCh(), fill(), archive::flag, getCrystalCount(), meCompleteZSMap_, meCompleteZSRateMap_, meDroppedFROMap_, meDroppedFRORateMap_, meIncompleteFROMap_, meIncompleteFRORateMap_, minDccId_, nCompleteZS_, nDroppedFRO_, nIncompleteFRO_, nPerRu_, ruGraphX(), ruGraphY(), srApplicationErrorLog_, EcalSrFlag::SRF_FULL, EcalSrFlag::SRF_ZS1, and EcalSrFlag::SRF_ZS2.

Referenced by analyze().

                                                                {
  typedef typename T::const_iterator SrFlagCollectionConstIt;
  typedef typename T::key_type MyRuDetIdType;

  for(SrFlagCollectionConstIt itSrf = srfs.begin();
      itSrf != srfs.end(); ++itSrf){
    int flag = itSrf->value() & ~EcalSrFlag::SRF_FORCED_MASK;
    pair<int,int> ru = dccCh(itSrf->id());

    if(flag == EcalSrFlag::SRF_FULL){
      if(nPerRu_[ru.first-minDccId_][ru.second-1]==getCrystalCount(ru.first, ru.second)){ //no error
    fill(meIncompleteFRORateMap_, ruGraphX(itSrf->id()),
             ruGraphY(itSrf->id()), 0);
    fill(meDroppedFRORateMap_,
             ruGraphX(itSrf->id()), ruGraphY(itSrf->id()), 0);
      } else if(nPerRu_[ru.first-minDccId_][ru.second-1]==0) {//tower dropped!
    fill(meIncompleteFRORateMap_,
             ruGraphX(itSrf->id()), ruGraphY(itSrf->id()), 0);
    fill(meDroppedFRORateMap_,
             ruGraphX(itSrf->id()), ruGraphY(itSrf->id()), 1);
    fill(meDroppedFROMap_, ruGraphX(itSrf->id()), ruGraphY(itSrf->id()), 1);
        ++nDroppedFRO_;
    srApplicationErrorLog_ << event.id() << ": Flag of RU "
                   << itSrf->id() << " (DCC " << ru.first
                               << " ch " << ru.second << ") is 'Full readout' "
                   << "while none of its channel was read out\n";
      } else{ //tower partially read out
    fill(meIncompleteFRORateMap_,
             ruGraphX(itSrf->id()), ruGraphY(itSrf->id()), 1);
    fill(meDroppedFRORateMap_,
             ruGraphX(itSrf->id()), ruGraphY(itSrf->id()), 0);
    fill(meIncompleteFROMap_,
             ruGraphX(itSrf->id()), ruGraphY(itSrf->id()), 1);
        ++nIncompleteFRO_;
    srApplicationErrorLog_ << event.id() << ": Flag of RU"
                   << itSrf->id() << " (DCC " << ru.first
                               << " ch " << ru.second << ") is 'Full readout' "
                   << "while only "
                               << nPerRu_[ru.first-minDccId_][ru.second-1]
                   << " / " << getCrystalCount(ru.first, ru.second)
                               << " channels were read out.\n";
      }
    }

    if(flag == EcalSrFlag::SRF_ZS1 || flag == EcalSrFlag::SRF_ZS2){
      if(nPerRu_[ru.first-minDccId_][ru.second-1]
         ==getCrystalCount(ru.first, ru.second)){
    //ZS readout unit whose every channel was read

        fill(meCompleteZSMap_, ruGraphX(itSrf->id()), ruGraphY(itSrf->id()));
    fill(meCompleteZSRateMap_,
             ruGraphX(itSrf->id()), ruGraphY(itSrf->id()), 1);
    //srApplicationErrorLog_ << event.id() << ": "
    //                       << "All " << nMaxXtalPerRu << " channels of RU "
    //                       << itSrf->id() << " passed the Zero suppression.";
        ++nCompleteZS_;
      } else{
    fill(meCompleteZSRateMap_,
             ruGraphX(itSrf->id()), ruGraphY(itSrf->id()), 0);
      }
    }
  }
}

int EcalSelectiveReadoutValidation::cIndex2iEta ( int  i ) const

inlineprivate

converse of iEta2cIndex() method.

Definition at line 275 of file EcalSelectiveReadoutValidation.h.

Referenced by dccCh().

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

int EcalSelectiveReadoutValidation::cIndex2iPhi ( int  i ) const

inlineprivate

converse of iPhi2cIndex() method.

Definition at line 282 of file EcalSelectiveReadoutValidation.h.

Referenced by dccCh().

                               {
    return (i+11) % 360;
  }

int EcalSelectiveReadoutValidation::cIndex2iTtEta ( int  i ) const

inlineprivate

converse of iTtEta2cIndex() method.

Definition at line 309 of file EcalSelectiveReadoutValidation.h.

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

int EcalSelectiveReadoutValidation::cIndex2iTtPhi ( int  i ) const

inlineprivate

converse of iTtPhi2cIndex() method.

Definition at line 315 of file EcalSelectiveReadoutValidation.h.

                                {
    return i + 1;
  }

int EcalSelectiveReadoutValidation::cIndex2iXY ( int  iX0 ) const

inlineprivate

converse of iXY2cIndex() method.

Definition at line 269 of file EcalSelectiveReadoutValidation.h.

                               {
    return iX0+1;
  }

template<class T >

void EcalSelectiveReadoutValidation::compareSrfColl ( const edm::Event &  event, T &  srfFromData, T &  computedSrf  )

private

Compares two SR flag collection, flags read from data and computed flags. Descripencies are recorded in relevant histogram and log file.

Template Parameters

T	collection type. Must be either an EESrFlagCollection or an EBSrFlagCollection.

Parameters

event	event currently analyzed. Used in logs.
srfFromData	SR flag collection read from data
compareSrf	SR flag collection computed from TTF by SRP emulation

Definition at line 2219 of file EcalSelectiveReadoutValidation.cc.

References dccCh(), fill(), logErrForDccs_, meSRFlagsConsistency_, minDccId_, ruGraphX(), ruGraphY(), srpAlgoErrorLog_, and edmStreamStallGrapher::t.

Referenced by analyze().

                                                                                                        {
  typedef typename T::const_iterator SrFlagCollectionConstIt;
  typedef typename T::key_type MyRuDetIdType;
  SrFlagCollectionConstIt itSrfFromData = srfFromData.begin();
  SrFlagCollectionConstIt itComputedSr = computedSrf.begin();

  {
    PgTiming t("collection comparison");
    //cout << __FILE__ << ":" << __LINE__ << ": "
    //   <<  srfFromData.size() << " " << computedSrf.size() << "\n";
    //    int i = 0;
    while(itSrfFromData != srfFromData.end()
      || itComputedSr != computedSrf.end()){
      //      cout << ++i << "\n";
      MyRuDetIdType inconsistentRu = 0;
      bool inconsistent = false;
      if(itComputedSr == computedSrf.end() ||
     (itSrfFromData != srfFromData.end()
      && itSrfFromData->id() < itComputedSr->id())){
    //computedSrf is missig a detid found in srfFromData
        pair<int, int> ch = dccCh(itSrfFromData->id());
    srpAlgoErrorLog_ << event.id() << ": " << itSrfFromData->id()
                         << ", DCC " << ch.first << " ch " << ch.second
             << " found in data (SRF:" << itSrfFromData->flagName()
             << ") but not in the set of SRFs computed from the data TTF.\n";
    inconsistentRu = itSrfFromData->id();
        inconsistent = true;
    ++itSrfFromData;
      } else if(itSrfFromData==srfFromData.end() ||
        (itComputedSr != computedSrf.end()
                 && itComputedSr->id() < itSrfFromData->id())){
    //ebSrFlags is missing a detid found in computedSrf
        pair<int, int> ch = dccCh(itComputedSr->id());
    if(logErrForDccs_[ch.first-minDccId_]){
      srpAlgoErrorLog_ << event.id() << ": " << itComputedSr->id()
                           << ", DCC " << ch.first << " ch " << ch.second
               << " not found in data. Computed SRF: "
               << itComputedSr->flagName() << ".\n";
          inconsistentRu = itComputedSr->id();
          inconsistent = true;
    }
        ++itComputedSr;
      } else{
    //*itSrfFromData and *itComputedSr has same detid
    if(itComputedSr->value()!=itSrfFromData->value()){
      //if(!(itSrfFromData->value & EcalSrFlag::SRF_FORCED_MASK)){
      pair<int, int> ch = dccCh(itSrfFromData->id());
      srpAlgoErrorLog_ << event.id() << ", "
               << itSrfFromData->id()
               << ", DCC " << ch.first << " ch " << ch.second
               << ", SRF inconsistency: "
               << "from data: " << itSrfFromData->flagName()
               << ", computed from TTF: "
                           << itComputedSr->flagName()
               << "\n";
      //}
      inconsistentRu = itComputedSr->id();
          inconsistent = true;
    }
    if(itComputedSr != computedSrf.end()) ++itComputedSr;
    if(itSrfFromData != srfFromData.end()) ++itSrfFromData;
      }

      if(inconsistent) fill(meSRFlagsConsistency_, ruGraphX(inconsistentRu),
                            ruGraphY(inconsistentRu));
    }
  }
}

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

private

Configure DCC ZS FIR weights. Heuristic is used to determine if input weights are normalized weights or integer weights in the hardware representation.

Parameters

weightsForZsFIR

weights from configuration file

Definition at line 2148 of file EcalSelectiveReadoutValidation.cc.

References edm::hlt::Exception, firstFIRSample_, firWeights_, getFIRWeights(), i, fff_deleter::log, indexGen::s2, and mathSSE::sqrt().

Referenced by EcalSelectiveReadoutValidation().

                                                                                     {
  bool notNormalized  = false;
  bool notInt = false;
  for(unsigned i=0; i < weightsForZsFIR.size(); ++i){
    if(weightsForZsFIR[i] > 1.) notNormalized = true;
    if((int)weightsForZsFIR[i]!=weightsForZsFIR[i]) notInt = true;
  }
  if(notInt && notNormalized){
    throw cms::Exception("InvalidParameter")
      << "weigtsForZsFIR paramater values are not valid: they "
      << "must either be integer and uses the hardware representation "
      << "of the weights or less or equal than 1 and used the normalized "
      << "representation.";
  }
  LogInfo log("DccFir");
  if(notNormalized){
    firWeights_ = vector<int>(weightsForZsFIR.size());
    for(unsigned i = 0; i< weightsForZsFIR.size(); ++i){
      firWeights_[i] = (int)weightsForZsFIR[i];
    }
  } else{
    firWeights_ = getFIRWeights(weightsForZsFIR);
  }

  log << "Input weights for FIR: ";
  for(unsigned i = 0; i < weightsForZsFIR.size(); ++i){
    log << weightsForZsFIR[i] << "\t";
  }

  double s2 = 0.;
  log << "\nActual FIR weights: ";
  for(unsigned i = 0; i < firWeights_.size(); ++i){
    log << firWeights_[i] << "\t";
    s2 += firWeights_[i]*firWeights_[i];
  }

  s2 = sqrt(s2);
  log << "\nNormalized FIR weights after hw representation rounding: ";
  for(unsigned i = 0; i < firWeights_.size(); ++i){
    log << firWeights_[i] / (double)(1<<10) << "\t";
  }

  log <<"\nFirst FIR sample: " << firstFIRSample_;
}

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

private

Retrieves the logical number of the DCC reading a given crystal channel.

Parameters

xtarId

crystal channel identifier

Returns

the DCC logical number starting from 1. Retrieves the DCC channel reading out a crystal, the crystals of a barrel trigger tower or the crystals, of an endcap supercrystal.

Parameters

xtarId

crystal channel, barrel trigger tower or endcap supercrystal identifier

Returns

pair of (DCC ID, DCC channel)

Definition at line 1683 of file EcalSelectiveReadoutValidation.cc.

References cIndex2iEta(), cIndex2iPhi(), EcalElectronicsId::dccId(), DetId::det(), DetId::Ecal, EcalBarrel, EcalEndcap, EcalTriggerTower, elecMap_, edm::hlt::Exception, EcalElectronicsMapping::getDCCandSC(), EcalElectronicsMapping::getElectronicsId(), EcalTrigTowerDetId::ieta(), EcalTrigTowerDetId::iphi(), iTtEta2cIndex(), iTtPhi2cIndex(), maxDccId_, minDccId_, nOneEeTtEta, DetId::rawId(), query::result, DetId::subdetId(), EcalElectronicsId::towerId(), and groupFilesInBlocks::tt.

Referenced by anaDigi(), analyzeEB(), analyzeEE(), checkSrApplication(), compareSrfColl(), and dccId().

                                                                           {
  if(detId.det()!=DetId::Ecal){
    throw cms::Exception("InvalidParameter")
      << "Wrong type of DetId passed to the "
      "EcalSelectiveReadoutValidation::dccCh(const DetId&). "
      "An ECAL DetId was expected.\n";
  }
  
  DetId xtalId;
  switch(detId.subdetId()){
  case EcalTriggerTower:       //Trigger tower
    {
      const EcalTrigTowerDetId tt = detId;
      //pick up one crystal of the trigger tower: they are however all readout by
      //the same DCC channel in the barrel.
      //Arithmetic is easier on the "c" indices:
      const int iTtPhi0 = iTtPhi2cIndex(tt.iphi());
      const int iTtEta0 = iTtEta2cIndex(tt.ieta());
      const int oneXtalPhi0 = iTtPhi0 * 5;
      const int oneXtalEta0 = (iTtEta0 - nOneEeTtEta) * 5;

      xtalId = EBDetId(cIndex2iEta(oneXtalEta0),
               cIndex2iPhi(oneXtalPhi0));
    }
    break;
  case EcalEndcap:
    if(detId.rawId() & 0x8000){ //Supercrystal
      return elecMap_->getDCCandSC(EcalScDetId(detId));
//       throw cms::Exception("InvalidParameter")
//  << "Wrong type of DetId passed to the method "
//  "EcalSelectiveReadoutValidation::dccCh(const DetId&). "
//  "A valid EcalTriggerTower, EcalBarrel or EcalEndcap DetId was expected. "
//  "detid = " << xtalId.rawId() << ".\n";
    } else {                    //EE crystal
      xtalId = detId;
    }
    break;
  case EcalBarrel:              //EB crystal
    xtalId = detId;
    break;
  default:
    throw cms::Exception("InvalidParameter")
      << "Wrong type of DetId passed to the method "
      "EcalSelectiveReadoutValidation::dccCh(const DetId&). "
      "A valid EcalTriggerTower, EcalBarrel or EcalEndcap DetId was expected. "
      "detid = " << xtalId.rawId() << ".\n";
  }

  const EcalElectronicsId& EcalElecId = elecMap_->getElectronicsId(xtalId);

  pair<int,int> result;
  result.first = EcalElecId.dccId();

  if(result.first < minDccId_ || result.second > maxDccId_){
    throw cms::Exception("OutOfRange")
      << "Got an invalid DCC ID, DCCID = " << result.first
      << " for DetId 0x" << hex << detId.rawId()
      << " and 0x" << xtalId.rawId() << dec << "\n";
  }

  result.second = EcalElecId.towerId();

  if(result.second < 1 || result.second > 68){
    throw cms::Exception("OutOfRange")
      << "Got an invalid DCC channel ID, DCC_CH = " << result.second
      << " for DetId 0x" << hex << detId.rawId()
      << " and 0x"  << xtalId.rawId() << dec << "\n";
  }

  return result;
}

int EcalSelectiveReadoutValidation::dccId ( const EcalScDetId &  detId ) const

private

Retrieves the ID of the DCC reading a readout unit

Parameters

detId

detid of the readout unit

Definition at line 2289 of file EcalSelectiveReadoutValidation.cc.

References elecMap_, and EcalElectronicsMapping::getDCCandSC().

Referenced by selectFedsForLog().

                                                                       {
  return elecMap_->getDCCandSC(detId).first;
}

int EcalSelectiveReadoutValidation::dccId ( const EcalTrigTowerDetId &  detId ) const

private

Definition at line 2293 of file EcalSelectiveReadoutValidation.cc.

References dccCh(), edm::hlt::Exception, and EcalTrigTowerDetId::ietaAbs().

                                                                              {
  if(detId.ietaAbs()>17){
    throw cms::Exception("InvalidArgument")
      << "Argument of EcalSelectiveReadoutValidation::dccId(const EcalTrigTowerDetId&) "
       << "must be a barrel trigger tower Id\n";
  }
  return dccCh(detId).first;

  //   int iDccPhi0 = (detId.iphi()-1)/4; //4 TT along phi covered by a DCC
  //   int iDccEta0 = detId.zside()<0?0:1;
  //   const int nDccsInPhi = 18;
  //   return 1 + iDccEta0 * nDccsInPhi + iDccPhi0;
}

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

staticprivate

Emulates the DCC zero suppression FIR filter. If one of the time sample is not in gain 12, numeric_limits<int>::max() is returned.

Parameters

frame	data frame
firWeights	TAP weights
firstFIRSample	index (starting from 1) of the first time sample to be used in the filter
saturated	if not null, *saturated is set to true if all the time sample are not in gain 12 and set to false otherwise.

Returns

FIR output or numeric_limits<int>::max().

Definition at line 2084 of file EcalSelectiveReadoutValidation.cc.

References EcalMGPASample::adc(), EcalMGPASample::gainId(), LogTrace, max(), compare_using_db::sample, EcalDataFrame::size(), and w().

Referenced by analyzeEB(), and analyzeEE().

                                     {
  const int nFIRTaps = 6;
  //FIR filter weights:
  const vector<int>& w = firWeights;

  //accumulator used to compute weighted sum of samples
  int acc = 0;
  bool gain12saturated = false;
  const int gain12 = 0x01;
  const int lastFIRSample = firstFIRSample + nFIRTaps - 1;
  //LogDebug("DccFir") << "DCC FIR operation: ";
  int iWeight = 0;
  for(int iSample=firstFIRSample-1;
      iSample<lastFIRSample; ++iSample, ++iWeight){
    if(iSample>=0 && iSample < frame.size()){
      EcalMGPASample sample(frame[iSample]);
      if(sample.gainId()!=gain12) gain12saturated = true;
      LogTrace("DccFir") << (iSample>=firstFIRSample?"+":"") << sample.adc()
             << "*(" << w[iWeight] << ")";
      acc+=sample.adc()*w[iWeight];
    } else{
      edm::LogWarning("DccFir") << __FILE__ << ":" << __LINE__ <<
    ": Not enough samples in data frame or 'ecalDccZs1stSample' module "
    "parameter is not valid...";
    }
  }
  LogTrace("DccFir") << "\n";
  //discards the 8 LSBs
  //(shift operator cannot be used on negative numbers because
  // the result depends on compilator implementation)
  acc = (acc>=0)?(acc >> 8):-(-acc >> 8);
  //ZS passed if weighted sum acc above ZS threshold or if
  //one sample has a lower gain than gain 12 (that is gain 12 output
  //is saturated)

  LogTrace("DccFir") << "acc: " << acc << "\n"
             << "saturated: " << (gain12saturated?"yes":"no") << "\n";

  if(saturated){
    *saturated = gain12saturated;
  }

  return gain12saturated?numeric_limits<int>::max():acc;
}

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

protectedvirtual

Calls at end of run.

Reimplemented from edm::EDAnalyzer.

Definition at line 1392 of file EcalSelectiveReadoutValidation.cc.

References dbe_, MonitorElement::Fill(), getL1aRate(), ievt_, meL1aRate_, normalizeHists(), outputFile_, DQMStore::save(), and useEventRate_.

                                                                                   {
  meL1aRate_->Fill(getL1aRate());
  if(useEventRate_) normalizeHists(ievt_);
  if(outputFile_.size()!=0) dbe_->save(outputFile_);
}

void EcalSelectiveReadoutValidation::fill ( MonitorElement *  me, float  x  )

inlineprivate

Wrapper to fill methods of DQM monitor elements.

Definition at line 388 of file EcalSelectiveReadoutValidation.h.

References MonitorElement::Fill().

Referenced by analyze(), analyzeDataVolume(), analyzeEB(), analyzeEE(), analyzeTP(), checkSrApplication(), and compareSrfColl().

                                        {
    if(me) me->Fill(x);
  }

void EcalSelectiveReadoutValidation::fill ( MonitorElement *  me, float  x, float  yw  )

inlineprivate

Definition at line 391 of file EcalSelectiveReadoutValidation.h.

References MonitorElement::Fill().

                                                 {
    if(me) me->Fill(x, yw);
  }

void EcalSelectiveReadoutValidation::fill ( MonitorElement *  me, float  x, float  y, float  zw  )

inlineprivate

Definition at line 394 of file EcalSelectiveReadoutValidation.h.

References MonitorElement::Fill().

                                                          {
    if(me) me->Fill(x, y, zw);
  }

void EcalSelectiveReadoutValidation::fill ( MonitorElement *  me, float  x, float  y, float  z, float  w  )

inlineprivate

Definition at line 397 of file EcalSelectiveReadoutValidation.h.

References MonitorElement::Fill().

                                                                  {
    if(me) me->Fill(x, y, z, w);
  }

double EcalSelectiveReadoutValidation::frame2Energy ( const EcalDataFrame &  frame ) const

private

Energy reconstruction from ADC samples.

Parameters

frame

the ADC sample of an ECA channel

Definition at line 1637 of file EcalSelectiveReadoutValidation.cc.

References i, bookConverter::min, n, EcalDataFrame::size(), and weights_.

Referenced by analyzeEB(), and analyzeEE().

                                                                                   {
  static bool firstCall = true;
  if(firstCall){
    stringstream buf;
    buf << "Weights:";
    for(unsigned i=0; i<weights_.size();++i){
      buf << "\t" << weights_[i];
    }
    edm::LogInfo("EcalSrValid") << buf.str() << "\n";
    firstCall = false;
  }
  double adc2GeV = 0.;

  if(typeid(EBDataFrame)==typeid(frame)){//barrel APD
    adc2GeV = .035;
  } else if(typeid(EEDataFrame)==typeid(frame)){//endcap VPT
    adc2GeV = 0.06;
  } else{
    assert(false);
  }

  double acc = 0;

  const int n = min(frame.size(), (int)weights_.size());

  double gainInv[] = {12., 1., 6., 12.};

  for(int i=0; i < n; ++i){
    acc += weights_[i]*frame[i].adc()*gainInv[frame[i].gainId()]*adc2GeV;
  }
  return acc;
}

template<class T >

double EcalSelectiveReadoutValidation::frame2EnergyForTp ( const T &  frame, int  offset = 0  ) const

private

Energy reconstruction from ADC samples to be used for trigger primitive estimate.

Parameters

frame	the ADC sample of an ECA channel
offset	time offset. To be used to evaluate energy of the event previous (offset=-1) and next (offset=+1) to the triggered one.

Definition at line 1900 of file EcalSelectiveReadoutValidation.cc.

References edm::hlt::Exception, i, n, evf::evtn::offset(), and create_public_pileup_plots::weights.

Referenced by setTtEtSums().

                                              {
  //we have to start by 0 in order to handle offset=-1
  //(however Fenix FIR has AFAK only 5 taps)
  double weights[] = {0., -1/3., -1/3., -1/3., 0., 1.};

  double adc2GeV = 0.;
  if(typeid(frame) == typeid(EBDataFrame)){
    adc2GeV = 0.035;
  } else if(typeid(frame) == typeid(EEDataFrame)){
    adc2GeV = 0.060;
  } else{ //T is an invalid type!
    //TODO: replace message by a cms exception
    throw cms::Exception("Severe Error")
      << __FILE__ << ":" << __LINE__ << ": "
      << "this is a bug. Please report it.\n";
  }

  double acc = 0;

  const int n = min<int>(frame.size(), sizeof(weights)/sizeof(weights[0]));

  double gainInv[] = {12., 1., 6., 12};

  for(int i=offset; i < n; ++i){
    int iframe = i + offset;
    if(iframe>=0 && iframe<frame.size()){
      acc += weights[i]*frame[iframe].adc()
    *gainInv[frame[iframe].gainId()]*adc2GeV;
      //cout << (iframe>offset?"+":"")
      //     << frame[iframe].adc() << "*" << gainInv[frame[iframe].gainId()]
      //     << "*" << adc2GeV << "*(" << weights[i] << ")";
    }
  }
  //cout << "\n";
  return acc;
}

double EcalSelectiveReadoutValidation::getBytesPerCrystal ( ) const

inlineprivate

Gets the number of bytes per crystal channel of the event part depending on the number of read crystal channels.

Returns

the number of bytes.

Definition at line 169 of file EcalSelectiveReadoutValidation.h.

Referenced by analyzeDataVolume(), getDccSrDependentPayload(), getEbEventSize(), and getEeEventSize().

                                   {
    return 3*8;
  }

int EcalSelectiveReadoutValidation::getCrystalCount ( int  iDcc, int  iDccCh  )

private

Retrieves number of crystal channel read out by a DCC channel

Parameters

iDcc	DCC ID starting from 1
iDccCh	DCC channel starting from 1

Returns

crystal count

Definition at line 2416 of file EcalSelectiveReadoutValidation.cc.

References maxDccId_.

Referenced by analyzeDataVolume(), and checkSrApplication().

                                                                       {
  if(iDcc < minDccId_ || iDcc > maxDccId_){ //invalid DCC
    return 0;
  } else if (10 <= iDcc && iDcc <= 45) {//EB
    return 25;
  } else { //EE
    int iDccPhi;
    if(iDcc < 10) iDccPhi = iDcc;
    else iDccPhi = iDcc - 45;
    switch(iDccPhi*100+iDccCh){
    case 110:
    case 232:
    case 312:
    case 412:
    case 532:
    case 610:
    case 830:
    case 806:
      //inner partials at 12, 3, and 9 o'clock
      return 20;
    case 134:
    case 634:
    case 827:
    case 803:
      return 10;
    case 330:
    case 430:
      return 20;
    case 203:
    case 503:
    case 721:
    case 921:
      return 21;
    default:
      return 25;
    }
  }
}

double EcalSelectiveReadoutValidation::getDccEventSize ( int  iDcc0, double  nReadXtals  ) const

inlineprivate

Gets the size of an DCC event fragment.

Parameters

iDcc0	the DCC logical number starting from 0.
nReadXtals	number of read crystal channels.

Returns

the DCC event fragment size in bytes.

Definition at line 178 of file EcalSelectiveReadoutValidation.h.

References EB, EE, getDccOverhead(), getDccSrDependentPayload(), and getRuCount().

Referenced by analyzeDataVolume().

                                                            {
    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 EcalSelectiveReadoutValidation::getDccOverhead ( subdet_t  subdet ) const

inlineprivate

Gets the size in bytes fixed-size part of a DCC event fragment.

Returns

the fixed size in bytes.

Definition at line 160 of file EcalSelectiveReadoutValidation.h.

References EB.

Referenced by EcalSelectiveReadoutValidation(), getDccEventSize(), getEbEventSize(), and getEeEventSize().

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

double EcalSelectiveReadoutValidation::getDccSrDependentPayload ( int  iDcc0, double  nReadRus, double  nReadXtals  ) const

inlineprivate

Gets DCC event fragment payload depending on the channel selection made by the selective readout.

Parameters

iDcc0	the DCC logical number starting from 0.
nReadRus	number of read-out RUs
nReadXtals	number of read-out crystal channels.

Returns

the DCC event fragment payload in bytes.

Definition at line 198 of file EcalSelectiveReadoutValidation.h.

References getBytesPerCrystal().

Referenced by analyzeDataVolume(), and getDccEventSize().

                                                          {
    return nReadXtals*getBytesPerCrystal() + nReadRus*8;
  }

double EcalSelectiveReadoutValidation::getEbEventSize ( double  nReadXtals ) const

private

Computes the size of an ECAL barrel event fragment.

Parameters

nReadXtals

number of read crystal channels

Returns

the event fragment size in bytes

Definition at line 2032 of file EcalSelectiveReadoutValidation.cc.

References EB, getBytesPerCrystal(), getDccOverhead(), getRuCount(), nEbDccs, and nEeDccs.

Referenced by analyzeDataVolume().

                                                                            {
  double ruHeaderPayload = 0.;
  const int firstEbDcc0 = nEeDccs/2;
  for(int iDcc0 = firstEbDcc0; iDcc0 < firstEbDcc0 + nEbDccs; ++iDcc0){
    ruHeaderPayload += getRuCount(iDcc0)*8.;
  }

  return getDccOverhead(EB)*nEbDccs + nReadXtals*getBytesPerCrystal()
    + ruHeaderPayload;
}

double EcalSelectiveReadoutValidation::getEeEventSize ( double  nReadXtals ) const

private

Computes the size of an ECAL endcap event fragment.

Parameters

nReadXtals

number of read crystal channels

Returns

the event fragment size in bytes

Definition at line 2043 of file EcalSelectiveReadoutValidation.cc.

References EE, getBytesPerCrystal(), getDccOverhead(), getRuCount(), nDccs_, nEbDccs, and nEeDccs.

Referenced by analyzeDataVolume().

                                                                            {
  double ruHeaderPayload = 0.;
  const unsigned firstEbDcc0 = nEeDccs/2;
  for(unsigned iDcc0 = 0; iDcc0 < nDccs_; ++iDcc0){
    //skip barrel:
    if(iDcc0== firstEbDcc0) iDcc0 += nEbDccs;
    ruHeaderPayload += getRuCount(iDcc0)*8.;
  }
  return getDccOverhead(EE)*nEeDccs + nReadXtals*getBytesPerCrystal()
    + ruHeaderPayload;
}

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

staticprivate

Computes the ZS FIR filter weights from the normalized weights.

Parameters

normalizedWeights

the normalized weights

Returns

the computed ZS filter weights.

Definition at line 2133 of file EcalSelectiveReadoutValidation.cc.

References funct::abs(), i, and bookConverter::min.

Referenced by configFirWeights().

                                            {
  const int nFIRTaps = 6;
  vector<int> firWeights(nFIRTaps, 0); //default weight: 0;
  const static int maxWeight = 0xEFF; //weights coded on 11+1 signed bits
  for(unsigned i=0; i < min((size_t)nFIRTaps,normalizedWeights.size()); ++i){
    firWeights[i] = lround(normalizedWeights[i] * (1<<10));
    if(abs(firWeights[i])>maxWeight){//overflow
      firWeights[i] = firWeights[i]<0?-maxWeight:maxWeight;
    }
  }
  return firWeights;
}

double EcalSelectiveReadoutValidation::getL1aRate ( ) const

private

Gets L1A rate estimate.

See Also

updateL1aRate(const edm::Event&)

Returns

L1A rate estimate

Definition at line 719 of file EcalSelectiveReadoutValidation.cc.

References alignCSCRings::e, l1aOfTmax, l1aOfTmin, LogDebug, tmax, and tmin.

Referenced by endRun().

                                                       {
  LogDebug("EcalSrValid") << __FILE__ << ":" << __LINE__ << ": "
              <<  "Tmax = " << tmax << " x 25ns; Tmin = " << tmin
              << " x 25ns; L1A(Tmax) = " << l1aOfTmax << "; L1A(Tmin) = "
              << l1aOfTmin << "\n";
  return (double)(l1aOfTmax - l1aOfTmin) / ((tmax-tmin) * 25e-9);
}

int EcalSelectiveReadoutValidation::getRuCount ( int  iDcc0 ) const

private

Gets the number of readout unit read by a DCC. A readout unit correspond to an active DCC input channel.

Parameters

iDcc0

DCC logical number starting from 0.

Definition at line 1670 of file EcalSelectiveReadoutValidation.cc.

References nRuPerDcc_.

Referenced by getDccEventSize(), getEbEventSize(), and getEeEventSize().

                                                             {
  //   static int nEemRu[] = {34, 32, 33, 33, 32, 34, 33, 34, 33};
  //   static int nEepRu[] = {32, 33, 33, 32, 34, 33, 34, 33, 34};
  //   if(iDcc0<9){//EE-
  //     return nEemRu[iDcc0];
  //   } else if(iDcc0>=45){//EE+
  //     return nEepRu[iDcc0-45];
  //   } else{//EB
  //     return 68;
  //   }
  return nRuPerDcc_[iDcc0];
}

int EcalSelectiveReadoutValidation::iEta2cIndex ( int  iEta ) const

inlineprivate

Converts a std CMSSW crystal eta index to a c-array index (starting from zero and without hole).

Definition at line 246 of file EcalSelectiveReadoutValidation.h.

Referenced by anaDigi(), and analyzeEB().

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

void EcalSelectiveReadoutValidation::initAsciiFile ( )

private

Definition at line 2193 of file EcalSelectiveReadoutValidation.cc.

References edm::hlt::Exception, logSrApplicationErrors_, logSrpAlgoErrors_, dbtoconf::out, srApplicationErrorLog_, srApplicationErrorLogFileName_, srpAlgoErrorLog_, srpAlgoErrorLogFileName_, and estimatePileup_makeJSON::trunc.

Referenced by beginRun().

                                                  {
  if(logSrpAlgoErrors_){
    srpAlgoErrorLog_.open(srpAlgoErrorLogFileName_.c_str(), ios::out | ios::trunc);
    if(!srpAlgoErrorLog_.good()){
      throw cms::Exception("Output")
    << "Failed to open the log file '"
    << srpAlgoErrorLogFileName_
    << "' for SRP algorithm result check.\n";
    }
  }

  if(logSrApplicationErrors_){
    srApplicationErrorLog_.open(srApplicationErrorLogFileName_.c_str(), ios::out | ios::trunc);
    if(!srApplicationErrorLog_.good()){
      throw cms::Exception("Output")
    << "Failed to open the log file '"
    << srApplicationErrorLogFileName_
    << "' for Selective Readout decision application check.\n";
    }
  }
}

int EcalSelectiveReadoutValidation::iPhi2cIndex ( int  iPhi ) const

inlineprivate

Converts a std CMSSW crystal phi index to a c-array index (starting from zero and without hole).

Definition at line 253 of file EcalSelectiveReadoutValidation.h.

Referenced by anaDigi(), and analyzeEB().

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

int EcalSelectiveReadoutValidation::iTtEta2cIndex ( int  iEta ) const

inlineprivate

Transforms CMSSW eta ECAL TT indices to indices starting at 0 to use for c-array or vector.

Parameters

iEta	CMSSW eta index (numbering -28...-1,28...56)

Returns

index in numbering from 0 to 55

Definition at line 291 of file EcalSelectiveReadoutValidation.h.

Referenced by analyzeTP(), dccCh(), and setTtEtSums().

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

int EcalSelectiveReadoutValidation::iTtPhi2cIndex ( int  iPhi ) const

inlineprivate

Transforms CMSSW phi ECAL crystal indices to indices starting at 0 to use for c-array or vector.

Parameters

iPhi	CMSSW phi index (numbering 1...72)

Returns

index in numbering 0...71

Definition at line 300 of file EcalSelectiveReadoutValidation.h.

Referenced by dccCh(), and setTtEtSums().

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

int EcalSelectiveReadoutValidation::iXY2cIndex ( int  iX ) const

inlineprivate

Converts a std CMSSW crystal x or y index to a c-array index (starting from zero and without hole).

Definition at line 263 of file EcalSelectiveReadoutValidation.h.

Referenced by anaDigi(), and analyzeEE().

                              {
    return iX-1;
  }

void EcalSelectiveReadoutValidation::myAna ( )

private

void EcalSelectiveReadoutValidation::normalizeHists ( double  eventCount )

private

Scaled histograms expressed in rate by 1/eventCount

Parameters

eventCount

event count to use for normalization factor

Definition at line 2055 of file EcalSelectiveReadoutValidation.cc.

References MonitorElement::getTH1(), h, i, meChOcc_, meForcedRu_, meFullRoRu_, meHiTtf_, meLiTtf_, meMiTtf_, meTp_, meTtf_, meZs1Ru_, and pileupReCalc_HLTpaths::scale.

Referenced by endRun().

                                                                    {
  MonitorElement* mes[] = { meChOcc_, meTtf_, meTp_, meFullRoRu_,
                meZs1Ru_, meForcedRu_, meLiTtf_, meMiTtf_, meHiTtf_,
                //meEbLiZsFir_, meEbHiZsFir_,
                //meEeLiZsFir_, meEeHiZsFir_,
  };

  double scale = 1./eventCount;
  stringstream buf;
  for(unsigned i = 0; i < sizeof(mes)/sizeof(mes[0]); ++i){
    if(mes[i] == 0) continue;
    TH1* h = mes[i]->getTH1();
    if(dynamic_cast<TH2*>(h)){//TH2
      h->GetZaxis()->SetTitle("Frequency");
    } else{ //assuming TH1
      h->GetYaxis()->SetTitle("<Count>");
    }
    buf << "Normalising " << h->GetName() << ". Factor: " << scale << "\n";
    h->Scale(scale);
    //Set average bit so histogram can be added correctly. Beware must be done
    //after call the TH1::Scale (Scale has no effect if average bit is set)
    h->SetBit(TH1::kIsAverage);
  }
  edm::LogInfo("EcalSrValid") << buf.str();
}

void EcalSelectiveReadoutValidation::printAvailableHists ( )

private

Prints the list of available histograms (registered by the registerHist method), including disabled one.

Definition at line 2020 of file EcalSelectiveReadoutValidation.cc.

References availableHistList_, and fff_deleter::log.

Referenced by EcalSelectiveReadoutValidation().

                                                        {
  LogInfo log("HistoList");
  log << "Avalailable histograms (DQM monitor elements): \n";
  for(map<string, string>::iterator it = availableHistList_.begin();
      it != availableHistList_.end();
      ++it){
    log << it->first << ": " << it->second << "\n";
  }
  log << "\nTo include an histogram add its name in the vstring parameter "
    "'histograms' of the EcalSelectiveReadoutValidation module\n";
}

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

private

Reads the data collections from the event. Called at start of each event analysis.

Parameters

event

the EDM event.

Definition at line 2003 of file EcalSelectiveReadoutValidation.cc.

References ebComputedSrFlags_, ebDigis_, ebNoZsDigis_, ebRecHits_, ebSimHits_, ebSrFlags_, eeComputedSrFlags_, eeDigis_, eeNoZsDigis_, eeRecHits_, eeSimHits_, eeSrFlags_, fedRaw_, CollHandle< T >::read(), and tps_.

Referenced by analyze().

                                                                            {
  ebRecHits_.read(event);
  eeRecHits_.read(event);
  ebDigis_.read(event);
  eeDigis_.read(event);
  ebNoZsDigis_.read(event);
  eeNoZsDigis_.read(event);
  ebSrFlags_.read(event);
  eeSrFlags_.read(event);
  ebComputedSrFlags_.read(event);
  eeComputedSrFlags_.read(event);
  ebSimHits_.read(event);
  eeSimHits_.read(event);
  tps_.read(event);
  fedRaw_.read(event);
}

EcalTrigTowerDetId EcalSelectiveReadoutValidation::readOutUnitOf ( const EBDetId &  xtalId ) const

private

Retrives the readout unit, a trigger tower in the barrel case, and a supercrystal in the endcap case, a given crystal belongs to.

Parameters

xtalId

identifier of the crystal

Returns

identifer of the supercrystal or of the trigger tower.

Definition at line 1795 of file EcalSelectiveReadoutValidation.cc.

References EcalTrigTowerConstituentsMap::towerOf(), and triggerTowerMap_.

Referenced by anaDigi(), analyzeEB(), and analyzeEE().

                                                                        {
  return triggerTowerMap_->towerOf(xtalId);
}

EcalScDetId EcalSelectiveReadoutValidation::readOutUnitOf ( const EEDetId &  xtalId ) const

private

Definition at line 1800 of file EcalSelectiveReadoutValidation.cc.

References EcalElectronicsId::dccId(), elecMap_, EcalElectronicsMapping::getEcalScDetId(), EcalElectronicsMapping::getElectronicsId(), and EcalElectronicsId::towerId().

                                                                        {
  //  return superCrystalOf(xtalId);
  const EcalElectronicsId& EcalElecId = elecMap_->getElectronicsId(xtalId);
  int iDCC= EcalElecId.dccId();
  int iDccChan = EcalElecId.towerId();
  const bool ignoreSingle = true;
  const vector<EcalScDetId> id = elecMap_->getEcalScDetId(iDCC, iDccChan, ignoreSingle);
  return id.size()>0?id[0]:EcalScDetId();
}

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

private

Register a histogram in the available histogram list and check if the histogram is enabled. Called by the histogram booking methods.

Returns

true if the histogram is enable, false otherwise

Definition at line 1997 of file EcalSelectiveReadoutValidation.cc.

References allHists_, availableHistList_, and histList_.

Referenced by book1D(), book2D(), bookFloat(), bookProfile(), and bookProfile2D().

                                                 {
  availableHistList_.insert(pair<string, string>(name, title));
  return allHists_ || histList_.find(name)!=histList_.end();
}

int EcalSelectiveReadoutValidation::ruGraphX ( const EcalScDetId &  id ) const

inlineprivate

Functions to compute x and y coordinates of RU maps grouping endcap and barrel.

Definition at line 926 of file EcalSelectiveReadoutValidation.h.

Referenced by analyzeEB(), analyzeEE(), checkSrApplication(), and compareSrfColl().

                                           {
    return id.ix() + (id.zside()>0?20:-40);
  }

int EcalSelectiveReadoutValidation::ruGraphX ( const EcalTrigTowerDetId &  id ) const

inlineprivate

Definition at line 934 of file EcalSelectiveReadoutValidation.h.

                                                  {
    return id.ieta();
  }

int EcalSelectiveReadoutValidation::ruGraphY ( const EcalScDetId &  id ) const

inlineprivate

Definition at line 930 of file EcalSelectiveReadoutValidation.h.

Referenced by analyzeEB(), analyzeEE(), checkSrApplication(), and compareSrfColl().

                                           {
    return id.iy();
  }

int EcalSelectiveReadoutValidation::ruGraphY ( const EcalTrigTowerDetId &  id ) const

inlineprivate

Definition at line 938 of file EcalSelectiveReadoutValidation.h.

                                                  {
    return id.iphi();
  }

void EcalSelectiveReadoutValidation::selectFedsForLog ( )

private

Look in events whose DCC has SR flags and enable error logging for them. To be called with the processed first event. List of monitored DCCs is reported in the log file.

Definition at line 2309 of file EcalSelectiveReadoutValidation.cc.

References dccId(), ebSrFlags_, eeSrFlags_, first, logErrForDccs_, minDccId_, nDccs_, srApplicationErrorLog_, and srpAlgoErrorLog_.

Referenced by analyze().

                                                     {
  logErrForDccs_ = vector<bool>(nDccs_, false);

  for(EBSrFlagCollection::const_iterator it = ebSrFlags_->begin();
      it != ebSrFlags_->end();
      ++it){

    //cout << __FILE__ << ":" << __LINE__ << ": "
    //   <<  EcalTrigTowerDetId(it->id()) << "\n";

    int iDcc = dccId(it->id()) - minDccId_;
    //    cout << __FILE__ << ":" << __LINE__ << ": "
    //   <<  it->id().rawId() << "-> DCC " << (iDcc+1) << "\n";
    logErrForDccs_.at(iDcc) = true;
  }

  for(EESrFlagCollection::const_iterator it = eeSrFlags_->begin();
      it != eeSrFlags_->end();
      ++it){
    int iDcc = dccId(it->id()) - minDccId_;
//     cout << __FILE__ << ":" << __LINE__ << ": "
//   <<  it->id().rawId() << "-> DCC " << (iDcc+1) << "\n";
    logErrForDccs_.at(iDcc) = true;
  }

  stringstream buf;
  buf << "List of DCCs found in the first processed event: ";
  bool first = true;
  for(unsigned iDcc = 0; iDcc < nDccs_; ++iDcc){
    if(logErrForDccs_[iDcc]){
      buf << (first?"":", ") << (iDcc + minDccId_);
      first = false;
    }
  }
  buf <<  "\nOnly DCCs from this list will be considered for error logging\n";
  srpAlgoErrorLog_ << buf.str();
  srApplicationErrorLog_<<  buf.str();
  LogInfo("EcalSrValid") << buf;
}

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

private

Computes trigger primitive estimates. A sum of crystal deposited transverse energy is performed.

Parameters

es	event setup
ebDigis	the ECAL barrel unsuppressed digi to use for the computation
ebDigis	the ECAL endcap unsuppressed digi to use for the computation

Definition at line 1811 of file EcalSelectiveReadoutValidation.cc.

References edm::DataFrameContainer::begin(), alignCSCRings::e, ebDigis_, DetId::Ecal, EcalBarrel, EcalEndcap, edm::DataFrameContainer::end(), frame2EnergyForTp(), edm::EventSetup::get(), CaloSubdetectorGeometry::getGeometry(), EEDataFrame::id(), EBDataFrame::id(), EcalTrigTowerDetId::ieta(), EcalTrigTowerDetId::iphi(), iTtEta2cIndex(), iTtPhi2cIndex(), nTtEta, nTtPhi, funct::sin(), theta(), EcalTrigTowerConstituentsMap::towerOf(), triggerTowerMap_, ttEtSums, and ecaldqm::ttId().

Referenced by analyze().

                                                        {
  //ecal geometry:
  static const CaloSubdetectorGeometry* eeGeometry = 0;
  static const CaloSubdetectorGeometry* ebGeometry = 0;
  if(eeGeometry==0 || ebGeometry==0){
    edm::ESHandle<CaloGeometry> geoHandle;
    es.get<MyCaloGeometryRecord>().get(geoHandle);
    eeGeometry
      = (*geoHandle).getSubdetectorGeometry(DetId::Ecal, EcalEndcap);
    ebGeometry
      = (*geoHandle).getSubdetectorGeometry(DetId::Ecal, EcalBarrel);
  }

  //init etSum array:
  for(int iEta0 = 0; iEta0 < nTtEta; ++iEta0){
    for(int iPhi0 = 0; iPhi0 < nTtPhi; ++iPhi0){
      ttEtSums[iEta0][iPhi0] = 0.;
    }
  }

  for(EBDigiCollection::const_iterator it = ebDigis_->begin();
      it != ebDigis_->end(); ++it){
    const EBDataFrame& frame = *it;
    const EcalTrigTowerDetId& ttId = triggerTowerMap_->towerOf(frame.id());
    //      LogDebug("TT")
    //        <<  ((EBDetId&)frame.id()).ieta()
    //        << "," << ((EBDetId&)frame.id()).iphi()
    //        << " -> " << ttId.ieta() << "," << ttId.iphi();
    const int iTtEta0 = iTtEta2cIndex(ttId.ieta());
    const int iTtPhi0 = iTtPhi2cIndex(ttId.iphi());
    double theta = ebGeometry->getGeometry(frame.id())->getPosition().theta();
    double e = frame2EnergyForTp(frame);
    if((frame2EnergyForTp(frame,-1) < e) && (frame2EnergyForTp(frame, 1) < e)){
      ttEtSums[iTtEta0][iTtPhi0] += e*sin(theta);
    }
  }

  for(EEDigiCollection::const_iterator it = eeDigis.begin();
      it != eeDigis.end(); ++it){
    const EEDataFrame& frame = *it;
    const EcalTrigTowerDetId& ttId = triggerTowerMap_->towerOf(frame.id());
    const int iTtEta0 = iTtEta2cIndex(ttId.ieta());
    const int iTtPhi0 = iTtPhi2cIndex(ttId.iphi());
    //     LogDebug("TT") << ": EE xtal->TT "
    //        <<  ((EEDetId&)frame.id()).ix()
    //        << "," << ((EEDetId&)frame.id()).iy()
    //        << " -> " << ttId.ieta() << "," << ttId.iphi() << "\n";
    double theta = eeGeometry->getGeometry(frame.id())->getPosition().theta();
    double e = frame2EnergyForTp(frame);
    if((frame2EnergyForTp(frame,-1) < e) && (frame2EnergyForTp(frame, 1) < e)){
      ttEtSums[iTtEta0][iTtPhi0] += e*sin(theta);
    }
  }

  //dealing with pseudo-TT in two inner EE eta-ring:
  int innerTTEtas[] = {0, 1, 54, 55};
  for(unsigned iRing = 0; iRing < sizeof(innerTTEtas)/sizeof(innerTTEtas[0]);
      ++iRing){
    int iTtEta0 = innerTTEtas[iRing];
    //this detector eta-section is divided in only 36 phi bins
    //For this eta regions,
    //current tower eta numbering scheme is inconsistent. For geometry
    //version 133:
    //- TT are numbered from 0 to 72 for 36 bins
    //- some TT have an even index, some an odd index
    //For geometry version 125, there are 72 phi bins.
    //The code below should handle both geometry definition.
    //If there are 72 input trigger primitives for each inner eta-ring,
    //then the average of the trigger primitive of the two pseudo-TT of
    //a pair (nEta, nEta+1) is taken as Et of both pseudo TTs.
    //If there are only 36 input TTs for each inner eta ring, then half
    //of the present primitive of a pseudo TT pair is used as Et of both
    //pseudo TTs.

    for(unsigned iTtPhi0 = 0; iTtPhi0 < nTtPhi-1; iTtPhi0 += 2){
      double et = .5*(ttEtSums[iTtEta0][iTtPhi0]
              +ttEtSums[iTtEta0][iTtPhi0+1]);
      //divides the TT into 2 phi bins in order to match with 72 phi-bins SRP
      //scheme or average the Et on the two pseudo TTs if the TT is already
      //divided into two trigger primitives.
      ttEtSums[iTtEta0][iTtPhi0] = et;
      ttEtSums[iTtEta0][iTtPhi0+1] = et;
    }
  }
}

void EcalSelectiveReadoutValidation::SRFlagValidation ( const edm::Event &  event, const edm::EventSetup &  es  )

private

Selective Readout decisions Validation

Parameters

event	EDM event
es	event setupSelective Readout decisions Validation
event	EDM event
es	event setup

EcalScDetId EcalSelectiveReadoutValidation::superCrystalOf ( const EEDetId &  xtalId ) const

private

Retrieves the endcap supercrystal containing a given crysal

Parameters

xtalId

identifier of the crystal

Returns

the identifier of the supercrystal

Definition at line 1756 of file EcalSelectiveReadoutValidation.cc.

References EEDetId::ix(), EEDetId::iy(), scEdge, and EEDetId::zside().

{

  const int scEdge = 5;
  EcalScDetId id = EcalScDetId((xtalId.ix()-1)/scEdge+1,
             (xtalId.iy()-1)/scEdge+1,
             xtalId.zside());
  return id;
  /*
  const EcalElectronicsId& EcalElecId = elecMap_->getElectronicsId(xtalId);
    int iDCC= EcalElecId.dccId();
    int iDccChan = EcalElecId.towerId();
    const vector<EcalScDetId> id = elecMap_->getEcalScDetId(iDCC, iDccChan);

    if(SkipInnerSC_)
    {
    if( (id.ix()>=9 && id.ix()<=12) && (id.iy()>=9 && id.iy()<=12) )
    return EcalScDetId();
    else
    return id;
    }
    else
    {
    if(id.ix()==9 && id.iy()==9)
    return EcalScDetId(2,5,xtalId.zside());
    else if(id.ix()==9 && id.iy()==12)
    return EcalScDetId(1,13,xtalId.zside());
    else if(id.ix()==12 && id.iy()==9)
    return EcalScDetId(19,5,xtalId.zside());
    else if(id.ix()==12 && id.iy()==12)
    return EcalScDetId(20,13,xtalId.zside());
    else
    return id;
    }
  */
}

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

private

Updates estimate of L1A rate

Parameters

event

EDM event

Definition at line 701 of file EcalSelectiveReadoutValidation.cc.

References l1aOfTmax, l1aOfTmin, edmStreamStallGrapher::t, tmax, and tmin.

Referenced by analyze().

                                                                       {
  const int32_t bx = event.bunchCrossing();
  if(bx<1 || bx > 3564) return;//throw cms::Exception("EcalSelectiveReadoutValidation")
                       //  << "bx value, " << bx << " is out of range\n";
  
  int64_t t = event.bunchCrossing() + (event.orbitNumber()-1)*3564;
  
  if(t<tmin){
    tmin = t;
    l1aOfTmin = event.id().event();
  }

  if(t>tmax){
    tmax = t;
    l1aOfTmax = event.id().event();
  }
}

int EcalSelectiveReadoutValidation::xtalGraphX ( const EEDetId &  id ) const

inlineprivate

Definition at line 942 of file EcalSelectiveReadoutValidation.h.

Referenced by analyzeEB(), and analyzeEE().

                                         {
    return id.ix() + (id.zside()>0?100:-200);
  }

int EcalSelectiveReadoutValidation::xtalGraphX ( const EBDetId &  id ) const

inlineprivate

Definition at line 950 of file EcalSelectiveReadoutValidation.h.

                                         {
    return id.ieta();
  }

int EcalSelectiveReadoutValidation::xtalGraphY ( const EEDetId &  id ) const

inlineprivate

Definition at line 946 of file EcalSelectiveReadoutValidation.h.

Referenced by analyzeEB(), and analyzeEE().

                                         {
    return id.iy();
  }

int EcalSelectiveReadoutValidation::xtalGraphY ( const EBDetId &  id ) const

inlineprivate

Definition at line 954 of file EcalSelectiveReadoutValidation.h.

                                         {
    return id.iphi();
  }

Member Data Documentation

bool EcalSelectiveReadoutValidation::allHists_

private

When true, every histogram is enabled.

Definition at line 849 of file EcalSelectiveReadoutValidation.h.

Referenced by EcalSelectiveReadoutValidation(), and registerHist().

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

private

List of available histograms. Filled by the booking methods. key: name, value: title.

Definition at line 858 of file EcalSelectiveReadoutValidation.h.

Referenced by EcalSelectiveReadoutValidation(), printAvailableHists(), and registerHist().

bool EcalSelectiveReadoutValidation::collNotFoundWarn_

private

Switch for collection-not-found warning.

Definition at line 521 of file EcalSelectiveReadoutValidation.h.

DQMStore* EcalSelectiveReadoutValidation::dbe_

private

Histogramming interface.

Definition at line 515 of file EcalSelectiveReadoutValidation.h.

Referenced by book1D(), book2D(), bookFloat(), bookProfile(), bookProfile2D(), EcalSelectiveReadoutValidation(), and endRun().

CollHandle<EBSrFlagCollection> EcalSelectiveReadoutValidation::ebComputedSrFlags_

private

Definition at line 549 of file EcalSelectiveReadoutValidation.h.

Referenced by analyze(), EcalSelectiveReadoutValidation(), and readAllCollections().

CollHandle<EBDigiCollection> EcalSelectiveReadoutValidation::ebDigis_

private

The event product collections.

Definition at line 543 of file EcalSelectiveReadoutValidation.h.

Referenced by analyzeDataVolume(), analyzeEB(), EcalSelectiveReadoutValidation(), readAllCollections(), and setTtEtSums().

energiesEb_t EcalSelectiveReadoutValidation::ebEnergies[nEbEta][nEbPhi]

private

Energy deposited in ECAL barrel crystals. Eta index starts from 0 at eta minimum and phi index starts at phi=0+ in CMS std coordinate system.

Definition at line 830 of file EcalSelectiveReadoutValidation.h.

Referenced by analyzeEB(), and EcalSelectiveReadoutValidation::Sorter::operator()().

CollHandle<EBDigiCollection> EcalSelectiveReadoutValidation::ebNoZsDigis_

private

Definition at line 545 of file EcalSelectiveReadoutValidation.h.

Referenced by analyze(), analyzeEB(), EcalSelectiveReadoutValidation(), and readAllCollections().

CollHandle<RecHitCollection> EcalSelectiveReadoutValidation::ebRecHits_

private

Definition at line 554 of file EcalSelectiveReadoutValidation.h.

Referenced by analyzeEB(), EcalSelectiveReadoutValidation(), and readAllCollections().

bool EcalSelectiveReadoutValidation::ebRuActive_[nEbEta/ebTtEdge][nEbPhi/ebTtEdge]

private

For book keeping of RU actually read out (not fully zero suppressed)

Definition at line 807 of file EcalSelectiveReadoutValidation.h.

Referenced by anaDigi(), and anaDigiInit().

CollHandle<std::vector<PCaloHit> > EcalSelectiveReadoutValidation::ebSimHits_

private

Definition at line 551 of file EcalSelectiveReadoutValidation.h.

Referenced by analyze(), analyzeEB(), EcalSelectiveReadoutValidation(), and readAllCollections().

CollHandle<EBSrFlagCollection> EcalSelectiveReadoutValidation::ebSrFlags_

private

Definition at line 547 of file EcalSelectiveReadoutValidation.h.

Referenced by analyze(), analyzeDataVolume(), analyzeEB(), EcalSelectiveReadoutValidation(), readAllCollections(), and selectFedsForLog().

const int EcalSelectiveReadoutValidation::ebTtEdge = 5

staticprivate

Number of crystals along an EB TT.

Definition at line 489 of file EcalSelectiveReadoutValidation.h.

Referenced by anaDigi().

int EcalSelectiveReadoutValidation::ebZsThr_

private

ZS threshold in 1/4th ADC count for EB

Definition at line 728 of file EcalSelectiveReadoutValidation.h.

Referenced by analyzeEB(), and EcalSelectiveReadoutValidation().

CollHandle<EESrFlagCollection> EcalSelectiveReadoutValidation::eeComputedSrFlags_

private

Definition at line 550 of file EcalSelectiveReadoutValidation.h.

Referenced by analyze(), EcalSelectiveReadoutValidation(), and readAllCollections().

CollHandle<EEDigiCollection> EcalSelectiveReadoutValidation::eeDigis_

private

Definition at line 544 of file EcalSelectiveReadoutValidation.h.

Referenced by analyzeDataVolume(), analyzeEE(), EcalSelectiveReadoutValidation(), and readAllCollections().

energiesEe_t EcalSelectiveReadoutValidation::eeEnergies[nEndcaps][nEeX][nEeY]

private

Energy deposited in ECAL endcap crystals. Endcap index is 0 for EE- and 1 for EE+. X and Y index starts at x and y minimum in std CMS coordinate system.

Definition at line 836 of file EcalSelectiveReadoutValidation.h.

Referenced by analyzeEE().

CollHandle<EEDigiCollection> EcalSelectiveReadoutValidation::eeNoZsDigis_

private

Definition at line 546 of file EcalSelectiveReadoutValidation.h.

Referenced by analyze(), analyzeEE(), EcalSelectiveReadoutValidation(), and readAllCollections().

CollHandle<RecHitCollection> EcalSelectiveReadoutValidation::eeRecHits_

private

Definition at line 555 of file EcalSelectiveReadoutValidation.h.

Referenced by analyzeEE(), EcalSelectiveReadoutValidation(), and readAllCollections().

bool EcalSelectiveReadoutValidation::eeRuActive_[nEndcaps][nEeX/scEdge][nEeY/scEdge]

private

Definition at line 808 of file EcalSelectiveReadoutValidation.h.

Referenced by anaDigi(), and anaDigiInit().

CollHandle<std::vector<PCaloHit> > EcalSelectiveReadoutValidation::eeSimHits_

private

Definition at line 552 of file EcalSelectiveReadoutValidation.h.

Referenced by analyze(), analyzeEE(), EcalSelectiveReadoutValidation(), and readAllCollections().

CollHandle<EESrFlagCollection> EcalSelectiveReadoutValidation::eeSrFlags_

private

Definition at line 548 of file EcalSelectiveReadoutValidation.h.

Referenced by analyze(), analyzeDataVolume(), analyzeEE(), EcalSelectiveReadoutValidation(), readAllCollections(), and selectFedsForLog().

int EcalSelectiveReadoutValidation::eeZsThr_

private

ZS threshold in 1/4th ADC count for EE

Definition at line 732 of file EcalSelectiveReadoutValidation.h.

Referenced by analyzeEE(), and EcalSelectiveReadoutValidation().

const EcalElectronicsMapping* EcalSelectiveReadoutValidation::elecMap_

private

Ecal electronics/geometrical mapping.

Definition at line 711 of file EcalSelectiveReadoutValidation.h.

Referenced by beginRun(), dccCh(), dccId(), and readOutUnitOf().

CollHandle<FEDRawDataCollection> EcalSelectiveReadoutValidation::fedRaw_

private

Definition at line 556 of file EcalSelectiveReadoutValidation.h.

Referenced by analyzeDataVolume(), EcalSelectiveReadoutValidation(), and readAllCollections().

int EcalSelectiveReadoutValidation::firstFIRSample_

private

Time position of the first sample to use in zero suppession FIR filter. Numbering starts at 0.

Definition at line 741 of file EcalSelectiveReadoutValidation.h.

Referenced by analyzeEB(), analyzeEE(), and configFirWeights().

std::vector<int> EcalSelectiveReadoutValidation::firWeights_

private

Weights to be used for the ZS FIR filter

Definition at line 724 of file EcalSelectiveReadoutValidation.h.

Referenced by analyzeEB(), analyzeEE(), and configFirWeights().

std::string EcalSelectiveReadoutValidation::histDir_

private

Histogram directory PATH in DQM or within the output ROOT file

Definition at line 853 of file EcalSelectiveReadoutValidation.h.

Referenced by EcalSelectiveReadoutValidation().

std::set<std::string> EcalSelectiveReadoutValidation::histList_

private

List of enabled histograms. Special name "all" is used to indicate all available histograms.

Definition at line 845 of file EcalSelectiveReadoutValidation.h.

Referenced by EcalSelectiveReadoutValidation(), and registerHist().

int EcalSelectiveReadoutValidation::ievt_

private

Event sequence number

Definition at line 819 of file EcalSelectiveReadoutValidation.h.

Referenced by analyze(), analyzeEB(), analyzeEE(), and endRun().

bool EcalSelectiveReadoutValidation::isRuComplete_[nDccs_][nDccChs_]

private

Definition at line 811 of file EcalSelectiveReadoutValidation.h.

Referenced by analyzeDataVolume(), analyzeEB(), and analyzeEE().

const int EcalSelectiveReadoutValidation::kByte_ = 1024

staticprivate

number of bytes in 1 kByte:

Definition at line 443 of file EcalSelectiveReadoutValidation.h.

Referenced by analyzeDataVolume().

int64_t EcalSelectiveReadoutValidation::l1aOfTmax

private

Definition at line 565 of file EcalSelectiveReadoutValidation.h.

Referenced by getL1aRate(), and updateL1aRate().

int64_t EcalSelectiveReadoutValidation::l1aOfTmin

private

Definition at line 564 of file EcalSelectiveReadoutValidation.h.

Referenced by getL1aRate(), and updateL1aRate().

bool EcalSelectiveReadoutValidation::l1aRateErr

private

Definition at line 566 of file EcalSelectiveReadoutValidation.h.

bool EcalSelectiveReadoutValidation::localReco_

private

Local reconstruction switch: true to reconstruct locally the amplitude insted of using the Rec Hits.

Definition at line 716 of file EcalSelectiveReadoutValidation.h.

Referenced by analyzeEB(), and analyzeEE().

std::vector<bool> EcalSelectiveReadoutValidation::logErrForDccs_

private

List of TCC masks for validation If tccMasks[iTcc-1] is false then TCC is considered to have been out of the run and related validations are skipped.

Definition at line 752 of file EcalSelectiveReadoutValidation.h.

Referenced by compareSrfColl(), and selectFedsForLog().

bool EcalSelectiveReadoutValidation::logSrApplicationErrors_

private

Switch to log SR decision that fails to be applied on data: inconstitencies between SRF and number of read out crystals.

Definition at line 901 of file EcalSelectiveReadoutValidation.h.

Referenced by EcalSelectiveReadoutValidation(), and initAsciiFile().

bool EcalSelectiveReadoutValidation::logSrpAlgoErrors_

private

Switch to log in an ascii file inconsistencies found between SRFs read from data and SRFs obtained by rerunning SRP algorithm on TTFs.

Definition at line 896 of file EcalSelectiveReadoutValidation.h.

Referenced by EcalSelectiveReadoutValidation(), and initAsciiFile().

const int EcalSelectiveReadoutValidation::maxDccId_ = minDccId_ + nDccs_ -1

staticprivate

Definition at line 456 of file EcalSelectiveReadoutValidation.h.

Referenced by analyzeDataVolume(), dccCh(), and getCrystalCount().

MonitorElement* EcalSelectiveReadoutValidation::meChOcc_

private

Definition at line 585 of file EcalSelectiveReadoutValidation.h.

Referenced by analyzeEB(), analyzeEE(), EcalSelectiveReadoutValidation(), and normalizeHists().

MonitorElement* EcalSelectiveReadoutValidation::meCompleteZS_

private

Definition at line 636 of file EcalSelectiveReadoutValidation.h.

MonitorElement* EcalSelectiveReadoutValidation::meCompleteZSCnt_

private

Definition at line 648 of file EcalSelectiveReadoutValidation.h.

Referenced by analyze(), and EcalSelectiveReadoutValidation().

MonitorElement* EcalSelectiveReadoutValidation::meCompleteZSMap_

private

Definition at line 640 of file EcalSelectiveReadoutValidation.h.

Referenced by checkSrApplication(), and EcalSelectiveReadoutValidation().

MonitorElement* EcalSelectiveReadoutValidation::meCompleteZSRateMap_

private

Definition at line 644 of file EcalSelectiveReadoutValidation.h.

Referenced by checkSrApplication(), and EcalSelectiveReadoutValidation().

MonitorElement* EcalSelectiveReadoutValidation::meDccHiVol_

private

Definition at line 574 of file EcalSelectiveReadoutValidation.h.

Referenced by analyzeDataVolume(), and EcalSelectiveReadoutValidation().

MonitorElement* EcalSelectiveReadoutValidation::meDccLiVol_

private

Definition at line 573 of file EcalSelectiveReadoutValidation.h.

Referenced by analyzeDataVolume(), and EcalSelectiveReadoutValidation().

MonitorElement* EcalSelectiveReadoutValidation::meDccVol_

private

The histograms

Definition at line 572 of file EcalSelectiveReadoutValidation.h.

Referenced by analyzeDataVolume(), and EcalSelectiveReadoutValidation().

MonitorElement* EcalSelectiveReadoutValidation::meDccVolFromData_

private

Definition at line 575 of file EcalSelectiveReadoutValidation.h.

Referenced by analyzeDataVolume(), and EcalSelectiveReadoutValidation().

MonitorElement* EcalSelectiveReadoutValidation::meDroppedFRO_

private

Definition at line 635 of file EcalSelectiveReadoutValidation.h.

MonitorElement* EcalSelectiveReadoutValidation::meDroppedFROCnt_

private

Definition at line 647 of file EcalSelectiveReadoutValidation.h.

Referenced by analyze(), and EcalSelectiveReadoutValidation().

MonitorElement* EcalSelectiveReadoutValidation::meDroppedFROMap_

private

Definition at line 639 of file EcalSelectiveReadoutValidation.h.

Referenced by checkSrApplication(), and EcalSelectiveReadoutValidation().

MonitorElement* EcalSelectiveReadoutValidation::meDroppedFRORateMap_

private

Definition at line 643 of file EcalSelectiveReadoutValidation.h.

Referenced by checkSrApplication(), and EcalSelectiveReadoutValidation().

MonitorElement* EcalSelectiveReadoutValidation::meEbEMean_

private

Definition at line 594 of file EcalSelectiveReadoutValidation.h.

Referenced by analyzeEB(), and EcalSelectiveReadoutValidation().

MonitorElement* EcalSelectiveReadoutValidation::meEbFixedPayload_

private

Event payload that do not depend on the number of crystals passing the SR

Definition at line 661 of file EcalSelectiveReadoutValidation.h.

Referenced by EcalSelectiveReadoutValidation().

MonitorElement* EcalSelectiveReadoutValidation::meEbFullRoCnt_

private

Definition at line 621 of file EcalSelectiveReadoutValidation.h.

Referenced by analyze(), and EcalSelectiveReadoutValidation().

MonitorElement* EcalSelectiveReadoutValidation::meEbHiZsFir_

private

Definition at line 625 of file EcalSelectiveReadoutValidation.h.

Referenced by analyzeEB(), and EcalSelectiveReadoutValidation().

MonitorElement* EcalSelectiveReadoutValidation::meEbIncompleteRUZsFir_

private

Definition at line 626 of file EcalSelectiveReadoutValidation.h.

MonitorElement* EcalSelectiveReadoutValidation::meEbLiZsFir_

private

Definition at line 624 of file EcalSelectiveReadoutValidation.h.

Referenced by analyzeEB(), and EcalSelectiveReadoutValidation().

MonitorElement* EcalSelectiveReadoutValidation::meEbNoise_

private

Definition at line 595 of file EcalSelectiveReadoutValidation.h.

Referenced by analyzeEB(), and EcalSelectiveReadoutValidation().

MonitorElement* EcalSelectiveReadoutValidation::meEbNoZsRecVsSimE_

private

Definition at line 599 of file EcalSelectiveReadoutValidation.h.

Referenced by analyzeEB(), and EcalSelectiveReadoutValidation().

MonitorElement* EcalSelectiveReadoutValidation::meEbRecE_

private

Definition at line 593 of file EcalSelectiveReadoutValidation.h.

Referenced by analyzeEB(), and EcalSelectiveReadoutValidation().

MonitorElement* EcalSelectiveReadoutValidation::meEbRecEHitXtal_

private

Definition at line 597 of file EcalSelectiveReadoutValidation.h.

Referenced by analyzeEB(), and EcalSelectiveReadoutValidation().

MonitorElement* EcalSelectiveReadoutValidation::meEbRecVsSimE_

private

Definition at line 598 of file EcalSelectiveReadoutValidation.h.

Referenced by analyzeEB(), and EcalSelectiveReadoutValidation().

MonitorElement* EcalSelectiveReadoutValidation::meEbSimE_

private

Definition at line 596 of file EcalSelectiveReadoutValidation.h.

Referenced by analyzeEB(), and EcalSelectiveReadoutValidation().

MonitorElement* EcalSelectiveReadoutValidation::meEbZsErrCnt_

private

Definition at line 649 of file EcalSelectiveReadoutValidation.h.

Referenced by analyze(), and EcalSelectiveReadoutValidation().

MonitorElement* EcalSelectiveReadoutValidation::meEbZsErrType1Cnt_

private

Definition at line 652 of file EcalSelectiveReadoutValidation.h.

Referenced by analyze(), and EcalSelectiveReadoutValidation().

MonitorElement* EcalSelectiveReadoutValidation::meEeEMean_

private

Definition at line 602 of file EcalSelectiveReadoutValidation.h.

Referenced by analyzeEE(), and EcalSelectiveReadoutValidation().

MonitorElement* EcalSelectiveReadoutValidation::meEeFixedPayload_

private

Definition at line 662 of file EcalSelectiveReadoutValidation.h.

Referenced by EcalSelectiveReadoutValidation().

MonitorElement* EcalSelectiveReadoutValidation::meEeFullRoCnt_

private

Definition at line 622 of file EcalSelectiveReadoutValidation.h.

Referenced by analyze(), and EcalSelectiveReadoutValidation().

MonitorElement* EcalSelectiveReadoutValidation::meEeHiZsFir_

private

Definition at line 629 of file EcalSelectiveReadoutValidation.h.

Referenced by analyzeEE(), and EcalSelectiveReadoutValidation().

MonitorElement* EcalSelectiveReadoutValidation::meEeLiZsFir_

private

Definition at line 628 of file EcalSelectiveReadoutValidation.h.

Referenced by analyzeEE(), and EcalSelectiveReadoutValidation().

MonitorElement* EcalSelectiveReadoutValidation::meEeNoise_

private

Definition at line 603 of file EcalSelectiveReadoutValidation.h.

Referenced by analyzeEE(), and EcalSelectiveReadoutValidation().

MonitorElement* EcalSelectiveReadoutValidation::meEeNoZsRecVsSimE_

private

Definition at line 607 of file EcalSelectiveReadoutValidation.h.

Referenced by analyzeEE(), and EcalSelectiveReadoutValidation().

MonitorElement* EcalSelectiveReadoutValidation::meEeRecE_

private

Definition at line 601 of file EcalSelectiveReadoutValidation.h.

Referenced by analyzeEE(), and EcalSelectiveReadoutValidation().

MonitorElement* EcalSelectiveReadoutValidation::meEeRecEHitXtal_

private

Definition at line 605 of file EcalSelectiveReadoutValidation.h.

Referenced by analyzeEE(), and EcalSelectiveReadoutValidation().

MonitorElement* EcalSelectiveReadoutValidation::meEeRecVsSimE_

private

Definition at line 606 of file EcalSelectiveReadoutValidation.h.

Referenced by analyzeEE(), and EcalSelectiveReadoutValidation().

MonitorElement* EcalSelectiveReadoutValidation::meEeSimE_

private

Definition at line 604 of file EcalSelectiveReadoutValidation.h.

Referenced by analyzeEE(), and EcalSelectiveReadoutValidation().

MonitorElement* EcalSelectiveReadoutValidation::meEeZsErrCnt_

private

Definition at line 650 of file EcalSelectiveReadoutValidation.h.

Referenced by analyze(), and EcalSelectiveReadoutValidation().

MonitorElement* EcalSelectiveReadoutValidation::meEeZsErrType1Cnt_

private

Definition at line 653 of file EcalSelectiveReadoutValidation.h.

Referenced by analyze(), and EcalSelectiveReadoutValidation().

MonitorElement* EcalSelectiveReadoutValidation::meFixedPayload_

private

Definition at line 663 of file EcalSelectiveReadoutValidation.h.

Referenced by EcalSelectiveReadoutValidation().

MonitorElement* EcalSelectiveReadoutValidation::meForcedRu_

private

Definition at line 611 of file EcalSelectiveReadoutValidation.h.

Referenced by analyzeEB(), analyzeEE(), EcalSelectiveReadoutValidation(), and normalizeHists().

MonitorElement* EcalSelectiveReadoutValidation::meForcedTtf_

private

Definition at line 616 of file EcalSelectiveReadoutValidation.h.

Referenced by analyzeTP(), and EcalSelectiveReadoutValidation().

MonitorElement* EcalSelectiveReadoutValidation::meFullRoCnt_

private

Definition at line 620 of file EcalSelectiveReadoutValidation.h.

Referenced by analyze(), and EcalSelectiveReadoutValidation().

MonitorElement* EcalSelectiveReadoutValidation::meFullRoRu_

private

Definition at line 609 of file EcalSelectiveReadoutValidation.h.

Referenced by analyzeEB(), analyzeEE(), EcalSelectiveReadoutValidation(), and normalizeHists().

MonitorElement* EcalSelectiveReadoutValidation::meHiTtf_

private

Definition at line 615 of file EcalSelectiveReadoutValidation.h.

Referenced by analyzeTP(), EcalSelectiveReadoutValidation(), and normalizeHists().

MonitorElement* EcalSelectiveReadoutValidation::meIncompleteFRO_

private

Definition at line 634 of file EcalSelectiveReadoutValidation.h.

MonitorElement* EcalSelectiveReadoutValidation::meIncompleteFROCnt_

private

Definition at line 646 of file EcalSelectiveReadoutValidation.h.

Referenced by analyze(), and EcalSelectiveReadoutValidation().

MonitorElement* EcalSelectiveReadoutValidation::meIncompleteFROMap_

private

Definition at line 638 of file EcalSelectiveReadoutValidation.h.

Referenced by checkSrApplication(), and EcalSelectiveReadoutValidation().

MonitorElement* EcalSelectiveReadoutValidation::meIncompleteFRORateMap_

private

Definition at line 642 of file EcalSelectiveReadoutValidation.h.

Referenced by checkSrApplication(), and EcalSelectiveReadoutValidation().

MonitorElement* EcalSelectiveReadoutValidation::meL1aRate_

private

Estimate of L1A rate

Definition at line 668 of file EcalSelectiveReadoutValidation.h.

Referenced by EcalSelectiveReadoutValidation(), and endRun().

MonitorElement* EcalSelectiveReadoutValidation::meLiTtf_

private

Definition at line 613 of file EcalSelectiveReadoutValidation.h.

Referenced by analyzeTP(), EcalSelectiveReadoutValidation(), and normalizeHists().

MonitorElement* EcalSelectiveReadoutValidation::meMiTtf_

private

Definition at line 614 of file EcalSelectiveReadoutValidation.h.

Referenced by analyzeTP(), EcalSelectiveReadoutValidation(), and normalizeHists().

MonitorElement* EcalSelectiveReadoutValidation::meSRFlagsComputed_

private

Definition at line 631 of file EcalSelectiveReadoutValidation.h.

MonitorElement* EcalSelectiveReadoutValidation::meSRFlagsConsistency_

private

Definition at line 632 of file EcalSelectiveReadoutValidation.h.

Referenced by compareSrfColl(), and EcalSelectiveReadoutValidation().

MonitorElement* EcalSelectiveReadoutValidation::meSRFlagsFromData_

private

Definition at line 630 of file EcalSelectiveReadoutValidation.h.

MonitorElement* EcalSelectiveReadoutValidation::meTp_

private

Definition at line 587 of file EcalSelectiveReadoutValidation.h.

Referenced by analyzeTP(), EcalSelectiveReadoutValidation(), and normalizeHists().

MonitorElement* EcalSelectiveReadoutValidation::meTpMap_

private

Definition at line 618 of file EcalSelectiveReadoutValidation.h.

Referenced by analyzeTP(), and EcalSelectiveReadoutValidation().

MonitorElement* EcalSelectiveReadoutValidation::meTpVsEtSum_

private

Definition at line 591 of file EcalSelectiveReadoutValidation.h.

Referenced by analyzeTP(), and EcalSelectiveReadoutValidation().

MonitorElement* EcalSelectiveReadoutValidation::meTtf_

private

Definition at line 588 of file EcalSelectiveReadoutValidation.h.

Referenced by analyzeTP(), EcalSelectiveReadoutValidation(), and normalizeHists().

MonitorElement* EcalSelectiveReadoutValidation::meTtfVsEtSum_

private

Definition at line 590 of file EcalSelectiveReadoutValidation.h.

Referenced by analyzeTP(), and EcalSelectiveReadoutValidation().

MonitorElement* EcalSelectiveReadoutValidation::meTtfVsTp_

private

Definition at line 589 of file EcalSelectiveReadoutValidation.h.

Referenced by analyzeTP(), and EcalSelectiveReadoutValidation().

MonitorElement* EcalSelectiveReadoutValidation::meVol_

private

Definition at line 576 of file EcalSelectiveReadoutValidation.h.

Referenced by analyzeDataVolume(), and EcalSelectiveReadoutValidation().

MonitorElement* EcalSelectiveReadoutValidation::meVolB_

private

Definition at line 577 of file EcalSelectiveReadoutValidation.h.

Referenced by analyzeDataVolume(), and EcalSelectiveReadoutValidation().

MonitorElement* EcalSelectiveReadoutValidation::meVolBHI_

private

Definition at line 582 of file EcalSelectiveReadoutValidation.h.

Referenced by analyzeDataVolume(), and EcalSelectiveReadoutValidation().

MonitorElement* EcalSelectiveReadoutValidation::meVolBLI_

private

Definition at line 579 of file EcalSelectiveReadoutValidation.h.

Referenced by analyzeDataVolume(), and EcalSelectiveReadoutValidation().

MonitorElement* EcalSelectiveReadoutValidation::meVolE_

private

Definition at line 578 of file EcalSelectiveReadoutValidation.h.

Referenced by analyzeDataVolume(), and EcalSelectiveReadoutValidation().

MonitorElement* EcalSelectiveReadoutValidation::meVolEHI_

private

Definition at line 583 of file EcalSelectiveReadoutValidation.h.

Referenced by analyzeDataVolume(), and EcalSelectiveReadoutValidation().

MonitorElement* EcalSelectiveReadoutValidation::meVolELI_

private

Definition at line 580 of file EcalSelectiveReadoutValidation.h.

Referenced by analyzeDataVolume(), and EcalSelectiveReadoutValidation().

MonitorElement* EcalSelectiveReadoutValidation::meVolHI_

private

Definition at line 584 of file EcalSelectiveReadoutValidation.h.

Referenced by analyzeDataVolume(), and EcalSelectiveReadoutValidation().

MonitorElement* EcalSelectiveReadoutValidation::meVolLI_

private

Definition at line 581 of file EcalSelectiveReadoutValidation.h.

Referenced by analyzeDataVolume(), and EcalSelectiveReadoutValidation().

MonitorElement* EcalSelectiveReadoutValidation::meZs1Ru_

private

Definition at line 610 of file EcalSelectiveReadoutValidation.h.

Referenced by analyzeEB(), analyzeEE(), EcalSelectiveReadoutValidation(), and normalizeHists().

MonitorElement* EcalSelectiveReadoutValidation::meZsErrCnt_

private

Definition at line 651 of file EcalSelectiveReadoutValidation.h.

Referenced by analyze(), and EcalSelectiveReadoutValidation().

MonitorElement* EcalSelectiveReadoutValidation::meZsErrType1Cnt_

private

Definition at line 654 of file EcalSelectiveReadoutValidation.h.

Referenced by analyze(), and EcalSelectiveReadoutValidation().

const int EcalSelectiveReadoutValidation::minDccId_ = 1

staticprivate

Definition at line 453 of file EcalSelectiveReadoutValidation.h.

Referenced by anaDigi(), analyzeDataVolume(), checkSrApplication(), compareSrfColl(), dccCh(), and selectFedsForLog().

int EcalSelectiveReadoutValidation::nCompleteZS_

private

Counter of ZS-flagged RU fully read out.

Definition at line 677 of file EcalSelectiveReadoutValidation.h.

Referenced by analyze(), and checkSrApplication().

const unsigned EcalSelectiveReadoutValidation::nDccChs_ = 68

staticprivate

Number of input channels of a DCC.

Definition at line 450 of file EcalSelectiveReadoutValidation.h.

const int EcalSelectiveReadoutValidation::nDccRus_

staticprivate

Initial value:

={
  
  
  34, 32, 33, 33, 32, 34, 33, 34, 33,
  
  
  68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68,
  
  
  68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68,
  
  
  32, 33, 33, 32, 34, 33, 34, 33, 34
}

number of RUs for each DCC

Definition at line 471 of file EcalSelectiveReadoutValidation.h.

Referenced by analyzeDataVolume().

const unsigned EcalSelectiveReadoutValidation::nDccs_ = 54

staticprivate

Total number of DCCs.

Definition at line 446 of file EcalSelectiveReadoutValidation.h.

Referenced by analyzeDataVolume(), EcalSelectiveReadoutValidation(), getEeEventSize(), and selectFedsForLog().

int EcalSelectiveReadoutValidation::nDroppedFRO_

private

Counter of FRO-flagged RU dropped from data.

Definition at line 671 of file EcalSelectiveReadoutValidation.h.

Referenced by analyze(), and checkSrApplication().

int EcalSelectiveReadoutValidation::nEb_

private

ECAL barrel read channel count

Definition at line 756 of file EcalSelectiveReadoutValidation.h.

Referenced by anaDigi(), anaDigiInit(), and analyzeDataVolume().

const int EcalSelectiveReadoutValidation::nEbDccs = 36

staticprivate

number of DCCs for EB

Definition at line 459 of file EcalSelectiveReadoutValidation.h.

Referenced by EcalSelectiveReadoutValidation(), getEbEventSize(), and getEeEventSize().

const int EcalSelectiveReadoutValidation::nEbEta = 170

staticprivate

number of crystals along Eta in EB

Definition at line 477 of file EcalSelectiveReadoutValidation.h.

Referenced by analyzeEB().

int EcalSelectiveReadoutValidation::nEbFROCnt_

private

Counter of EB FRO-flagged RUs.

Definition at line 680 of file EcalSelectiveReadoutValidation.h.

Referenced by analyze(), and analyzeEB().

int EcalSelectiveReadoutValidation::nEbHI_

private

ECAL barrel high interest read channel count

Definition at line 776 of file EcalSelectiveReadoutValidation.h.

Referenced by anaDigi(), anaDigiInit(), and analyzeDataVolume().

int EcalSelectiveReadoutValidation::nEbLI_

private

ECAL barrel low interest read channel count

Definition at line 772 of file EcalSelectiveReadoutValidation.h.

Referenced by anaDigi(), anaDigiInit(), and analyzeDataVolume().

const int EcalSelectiveReadoutValidation::nEbPhi = 360

staticprivate

number of crystals along Phi in EB

Definition at line 480 of file EcalSelectiveReadoutValidation.h.

Referenced by analyzeEB().

const int EcalSelectiveReadoutValidation::nEbRus = 36*68

staticprivate

number of RUs for EB

Definition at line 465 of file EcalSelectiveReadoutValidation.h.

const int EcalSelectiveReadoutValidation::nEbTtEta = 34

staticprivate

Number of Trigger Towers in barrel along Eta.

Definition at line 498 of file EcalSelectiveReadoutValidation.h.

int EcalSelectiveReadoutValidation::nEbZsErrors_

private

Counter of EB ZS errors (LI channel below ZS threshold)

Definition at line 686 of file EcalSelectiveReadoutValidation.h.

Referenced by analyze(), and analyzeEB().

int EcalSelectiveReadoutValidation::nEbZsErrorsType1_

private

Counter of EB ZS errors of type 1: LI channel below ZS threshold and in a RU which was fully readout

Definition at line 693 of file EcalSelectiveReadoutValidation.h.

Referenced by analyze(), and analyzeEB().

int EcalSelectiveReadoutValidation::nEe_

private

ECAL endcap read channel count

Definition at line 760 of file EcalSelectiveReadoutValidation.h.

Referenced by anaDigi(), anaDigiInit(), and analyzeDataVolume().

const int EcalSelectiveReadoutValidation::nEeDccs = 18

staticprivate

number of DCCs for EE

Definition at line 462 of file EcalSelectiveReadoutValidation.h.

Referenced by EcalSelectiveReadoutValidation(), getEbEventSize(), and getEeEventSize().

int EcalSelectiveReadoutValidation::nEeFROCnt_

private

Counter of EE FRO-flagged RUs.

Definition at line 683 of file EcalSelectiveReadoutValidation.h.

Referenced by analyze(), and analyzeEE().

int EcalSelectiveReadoutValidation::nEeHI_

private

ECAL endcap high interest read channel count

Definition at line 768 of file EcalSelectiveReadoutValidation.h.

Referenced by anaDigi(), anaDigiInit(), and analyzeDataVolume().

int EcalSelectiveReadoutValidation::nEeLI_

private

ECAL endcap low interest read channel count

Definition at line 764 of file EcalSelectiveReadoutValidation.h.

Referenced by anaDigi(), anaDigiInit(), and analyzeDataVolume().

const int EcalSelectiveReadoutValidation::nEeRus = 2*(34+32+33+33+32+34+33+34+33)

staticprivate

number of RUs for EE

Definition at line 468 of file EcalSelectiveReadoutValidation.h.

const int EcalSelectiveReadoutValidation::nEeX = 100

staticprivate

EE crystal grid size along X.

Definition at line 483 of file EcalSelectiveReadoutValidation.h.

Referenced by analyzeEE().

const int EcalSelectiveReadoutValidation::nEeY = 100

staticprivate

EE crystal grid size along Y.

Definition at line 486 of file EcalSelectiveReadoutValidation.h.

Referenced by analyzeEE().

int EcalSelectiveReadoutValidation::nEeZsErrors_

private

Counter of EE ZS errors (LI channel below ZS threshold)

Definition at line 689 of file EcalSelectiveReadoutValidation.h.

Referenced by analyze(), and analyzeEE().

int EcalSelectiveReadoutValidation::nEeZsErrorsType1_

private

Counter of EE ZS errors of tyoe 1: LI channel below ZS threshold and in a RU which was fully readout

Definition at line 697 of file EcalSelectiveReadoutValidation.h.

Referenced by analyze(), and analyzeEE().

const int EcalSelectiveReadoutValidation::nEndcaps = 2

staticprivate

number of endcaps

Definition at line 474 of file EcalSelectiveReadoutValidation.h.

Referenced by analyzeEE().

int EcalSelectiveReadoutValidation::nHiPerDcc_[nDccs_]

private

read-out ECAL Hiugh interest channel count for each DCC:

Definition at line 788 of file EcalSelectiveReadoutValidation.h.

Referenced by anaDigi(), anaDigiInit(), and analyzeDataVolume().

int EcalSelectiveReadoutValidation::nHiRuPerDcc_[nDccs_]

private

Count for each DCC of HI RUs with at leat one channel read out:

Definition at line 801 of file EcalSelectiveReadoutValidation.h.

Referenced by anaDigi(), anaDigiInit(), and analyzeDataVolume().

int EcalSelectiveReadoutValidation::nIncompleteFRO_

private

Counter of FRO-flagged RU only partial data.

Definition at line 674 of file EcalSelectiveReadoutValidation.h.

Referenced by analyze(), and checkSrApplication().

int EcalSelectiveReadoutValidation::nLiPerDcc_[nDccs_]

private

read-out ECAL Low interest channel count for each DCC:

Definition at line 784 of file EcalSelectiveReadoutValidation.h.

Referenced by anaDigi(), anaDigiInit(), and analyzeDataVolume().

int EcalSelectiveReadoutValidation::nLiRuPerDcc_[nDccs_]

private

Count for each DCC of LI RUs with at leat one channel read out:

Definition at line 797 of file EcalSelectiveReadoutValidation.h.

Referenced by anaDigi(), anaDigiInit(), and analyzeDataVolume().

const int EcalSelectiveReadoutValidation::nMaxXtalPerRu = 25

staticprivate

Number of crystals per Readout Unit excepted partial SCs.

Definition at line 507 of file EcalSelectiveReadoutValidation.h.

const int EcalSelectiveReadoutValidation::nOneEeTtEta = 11

staticprivate

Number of Trigger Towers in an endcap along Eta.

Definition at line 495 of file EcalSelectiveReadoutValidation.h.

Referenced by dccCh().

int EcalSelectiveReadoutValidation::nPerDcc_[nDccs_]

private

read-out ECAL channel count for each DCC:

Definition at line 780 of file EcalSelectiveReadoutValidation.h.

Referenced by anaDigi(), anaDigiInit(), and analyzeDataVolume().

int EcalSelectiveReadoutValidation::nPerRu_[nDccs_][nDccChs_]

private

Number of crystal read for each DCC channel (aka readout unit).

Definition at line 815 of file EcalSelectiveReadoutValidation.h.

Referenced by anaDigi(), anaDigiInit(), analyzeDataVolume(), and checkSrApplication().

int EcalSelectiveReadoutValidation::nRuPerDcc_[nDccs_]

private

Count for each DCC of RUs with at leat one channel read out:

Definition at line 793 of file EcalSelectiveReadoutValidation.h.

Referenced by anaDigi(), anaDigiInit(), and getRuCount().

const int EcalSelectiveReadoutValidation::nTtEta = 2*nOneEeTtEta + nEbTtEta

staticprivate

Number of Trigger Towers along Eta.

Definition at line 501 of file EcalSelectiveReadoutValidation.h.

Referenced by setTtEtSums().

const int EcalSelectiveReadoutValidation::nTtPhi = 72

staticprivate

Number of Trigger Towers along Phi.

Definition at line 504 of file EcalSelectiveReadoutValidation.h.

Referenced by setTtEtSums().

std::string EcalSelectiveReadoutValidation::outputFile_

private

Output file for histograms.

Definition at line 518 of file EcalSelectiveReadoutValidation.h.

Referenced by EcalSelectiveReadoutValidation(), and endRun().

const double EcalSelectiveReadoutValidation::rad2deg = 45./atan(1.)

staticprivate

Conversion factor from radian to degree.

Definition at line 509 of file EcalSelectiveReadoutValidation.h.

Referenced by analyzeEB(), and analyzeEE().

const int EcalSelectiveReadoutValidation::scEdge = 5

staticprivate

Number of crystals along a supercrystal edge.

Definition at line 492 of file EcalSelectiveReadoutValidation.h.

Referenced by anaDigi(), and superCrystalOf().

bool EcalSelectiveReadoutValidation::SkipInnerSC_

private

Permits to skip inner SC

Definition at line 840 of file EcalSelectiveReadoutValidation.h.

std::ofstream EcalSelectiveReadoutValidation::srApplicationErrorLog_

private

Output ascii file for unconsistency between Xtals and RU Flags.

Definition at line 535 of file EcalSelectiveReadoutValidation.h.

Referenced by analyzeEB(), analyzeEE(), checkSrApplication(), initAsciiFile(), and selectFedsForLog().

std::string EcalSelectiveReadoutValidation::srApplicationErrorLogFileName_

private

Output ascii file name for unconsistency between SRFs and actual number of read-out crystals.

Definition at line 529 of file EcalSelectiveReadoutValidation.h.

Referenced by EcalSelectiveReadoutValidation(), and initAsciiFile().

std::ofstream EcalSelectiveReadoutValidation::srpAlgoErrorLog_

private

Output ascii file for unconsistency on SR flags.

Definition at line 532 of file EcalSelectiveReadoutValidation.h.

Referenced by compareSrfColl(), initAsciiFile(), and selectFedsForLog().

std::string EcalSelectiveReadoutValidation::srpAlgoErrorLogFileName_

private

Output ascii file name for unconsistency between SRFs read from data and SRF obtained by rerunning SRP algorithm on TTFs.

Definition at line 525 of file EcalSelectiveReadoutValidation.h.

Referenced by EcalSelectiveReadoutValidation(), and initAsciiFile().

int64_t EcalSelectiveReadoutValidation::tmax

private

For L1A rate estimate

Definition at line 562 of file EcalSelectiveReadoutValidation.h.

Referenced by getL1aRate(), and updateL1aRate().

int64_t EcalSelectiveReadoutValidation::tmin

private

Definition at line 563 of file EcalSelectiveReadoutValidation.h.

Referenced by getL1aRate(), and updateL1aRate().

bool EcalSelectiveReadoutValidation::tpInGeV_

private

Switch for uncompressing TP value

Definition at line 736 of file EcalSelectiveReadoutValidation.h.

Referenced by analyzeTP(), and EcalSelectiveReadoutValidation().

const EcalTPParameters* EcalSelectiveReadoutValidation::tpParam_

private

Interface to access trigger primitive parameters, especially to convert Et in compressed formart into natural unit.

Definition at line 707 of file EcalSelectiveReadoutValidation.h.

CollHandle<EcalTrigPrimDigiCollection> EcalSelectiveReadoutValidation::tps_

private

Definition at line 553 of file EcalSelectiveReadoutValidation.h.

Referenced by analyze(), analyzeTP(), EcalSelectiveReadoutValidation(), and readAllCollections().

const EcalTrigTowerConstituentsMap* EcalSelectiveReadoutValidation::triggerTowerMap_

private

ECAL trigger tower mapping

Definition at line 702 of file EcalSelectiveReadoutValidation.h.

Referenced by beginRun(), readOutUnitOf(), and setTtEtSums().

double EcalSelectiveReadoutValidation::ttEtSums[nTtEta][nTtPhi]

private

Trigger tower Et computed as sum the crystal Et. Indices stands for the eta and phi TT index starting from 0 at eta minimum and at phi=0+ in std CMS coordinate system.

Definition at line 825 of file EcalSelectiveReadoutValidation.h.

Referenced by analyzeTP(), and setTtEtSums().

bool EcalSelectiveReadoutValidation::useEventRate_

private

Switch to fill histograms with event rate instead of event count. Applies only to some histograms.

Definition at line 746 of file EcalSelectiveReadoutValidation.h.

Referenced by endRun().

bool EcalSelectiveReadoutValidation::verbose_

private

Verbosity switch.

Definition at line 512 of file EcalSelectiveReadoutValidation.h.

Referenced by EcalSelectiveReadoutValidation().

std::vector<double> EcalSelectiveReadoutValidation::weights_

private

Weights for amplitude local reconstruction

Definition at line 720 of file EcalSelectiveReadoutValidation.h.

Referenced by frame2Energy().

bool EcalSelectiveReadoutValidation::withEbSimHit_

private

Indicates if EB sim hits are available

Definition at line 867 of file EcalSelectiveReadoutValidation.h.

Referenced by analyze(), and analyzeEB().

bool EcalSelectiveReadoutValidation::withEeSimHit_

private

Indicates if EE sim hits are available

Definition at line 863 of file EcalSelectiveReadoutValidation.h.

Referenced by analyze(), and analyzeEE().

std::ofstream EcalSelectiveReadoutValidation::zsErrorLog_

private

File to log ZS and other errors.

Definition at line 538 of file EcalSelectiveReadoutValidation.h.