db/d83/ClusterTask_8cc_source.html

 #include "../interface/ClusterTask.h"


 #include <cmath>


 #include "FWCore/Framework/interface/ESHandle.h"

 #include "RecoEcal/EgammaCoreTools/interface/EcalClusterTools.h"

 #include "Geometry/CaloTopology/interface/CaloTopology.h"

 #include "Geometry/CaloGeometry/interface/CaloGeometry.h"

 #include "Geometry/CaloGeometry/interface/CaloSubdetectorGeometry.h"

 #include "Geometry/Records/interface/CaloTopologyRecord.h"

 #include "Geometry/Records/interface/CaloGeometryRecord.h"

 #include "DataFormats/EcalRawData/interface/EcalDCCHeaderBlock.h"

 #include "DataFormats/EcalDetId/interface/EcalDetIdCollections.h"

 #include "DataFormats/EcalDetId/interface/EcalSubdetector.h"

 #include "DataFormats/GeometryVector/interface/GlobalPoint.h"


 namespace ecaldqm {


   ClusterTask::ClusterTask(const edm::ParameterSet &_params, const::edm::ParameterSet& _paths) :

     DQWorkerTask(_params, _paths, "ClusterTask"),

     topology_(0),

     ebGeometry_(0),

     eeGeometry_(0),

     ebHits_(0),

     eeHits_(0),

     ievt_(0),

     lowEMax_(0.),

     massCalcPrescale_(0)

   {

     collectionMask_ =

       (0x1 << kRun) |

       (0x1 << kEBRecHit) |

       (0x1 << kEERecHit) |

       (0x1 << kEBBasicCluster) |

       (0x1 << kEEBasicCluster) |

       (0x1 << kEBSuperCluster) |

       (0x1 << kEESuperCluster);


     dependencies_.push_back(std::pair<Collections, Collections>(kEBSuperCluster, kEBRecHit));

     dependencies_.push_back(std::pair<Collections, Collections>(kEESuperCluster, kEERecHit));


     edm::ParameterSet const& taskParams(_params.getUntrackedParameterSet(name_));


     lowEMax_ = taskParams.getUntrackedParameter<double>("lowEMax");

     massCalcPrescale_ = taskParams.getUntrackedParameter<int>("massCalcPrescale");

   }


   ClusterTask::~ClusterTask()

   {

   }


   void

   ClusterTask::beginRun(const edm::Run &, const edm::EventSetup &_es)

   {

     edm::ESHandle<CaloTopology> topoHndl;

     _es.get<CaloTopologyRecord>().get(topoHndl);

     topology_ = topoHndl.product();

     if(!topology_)

       throw cms::Exception("EventSetup") << "CaloTopology missing" << std::endl;


     edm::ESHandle<CaloGeometry> geomHndl;

     _es.get<CaloGeometryRecord>().get(geomHndl);

     ebGeometry_ = geomHndl->getSubdetectorGeometry(DetId::Ecal, EcalBarrel);

     eeGeometry_ = geomHndl->getSubdetectorGeometry(DetId::Ecal, EcalEndcap);

     if(!ebGeometry_ || !eeGeometry_)

       throw cms::Exception("EventSetup") << "CaloSubdetectorGeometry missing" << std::endl;


     ievt_ = 0;

   }


   void

   ClusterTask::beginEvent(const edm::Event &, const edm::EventSetup &)

   {

     ebHits_ = 0;

     eeHits_ = 0;


     ievt_++;

   }


   void

   ClusterTask::bookMEs()

   {

     DQWorker::bookMEs();


     MEs_[kBCE]->setAxisTitle("energy (GeV)", 1);

     MEs_[kBCNum]->setAxisTitle("number of clusters", 1);

     MEs_[kBCSize]->setAxisTitle("number of clusters", 1);

     MEs_[kSCE]->setAxisTitle("energy (GeV)", 1);

     MEs_[kSCELow]->setAxisTitle("energy (GeV)", 1);

     MEs_[kSCSeedEnergy]->setAxisTitle("energy (GeV)", 1);

     MEs_[kSCClusterVsSeed]->setAxisTitle("seed crystal energy (GeV)", 1);

     MEs_[kSCClusterVsSeed]->setAxisTitle("cluster energy (GeV)", 2);

     MEs_[kSCNum]->setAxisTitle("number of clusters", 1);

     MEs_[kSCNBCs]->setAxisTitle("cluster size", 1);

     MEs_[kSCNcrystals]->setAxisTitle("cluster size", 1);

     MEs_[kSCR9]->setAxisTitle("R9", 1);

     MEs_[kPi0]->setAxisTitle("mass (GeV)", 1);

     MEs_[kJPsi]->setAxisTitle("mass (GeV)", 1);

     MEs_[kZ]->setAxisTitle("mass (GeV)", 1);

     MEs_[kHighMass]->setAxisTitle("mass (GeV)", 1);


     for(int i(0); i < 2; i++)

       MEs_[kSCELow]->getME(i)->getTH1()->GetXaxis()->SetLimits(0., lowEMax_);

   }


   bool

   ClusterTask::filterRunType(const std::vector<short>& _runType)

   {

     for(int iFED(0); iFED < 54; iFED++){

       if ( _runType[iFED] == EcalDCCHeaderBlock::COSMIC ||

            _runType[iFED] == EcalDCCHeaderBlock::MTCC ||

            _runType[iFED] == EcalDCCHeaderBlock::COSMICS_GLOBAL ||

            _runType[iFED] == EcalDCCHeaderBlock::PHYSICS_GLOBAL ||

            _runType[iFED] == EcalDCCHeaderBlock::COSMICS_LOCAL ||

            _runType[iFED] == EcalDCCHeaderBlock::PHYSICS_LOCAL ) return true;

     }


     return false;

   }


   void

   ClusterTask::runOnRecHits(const EcalRecHitCollection &_hits, Collections _collection)

   {

     switch(_collection){

     case kEBRecHit:

       ebHits_ = &_hits;

       break;

     case kEERecHit:

       eeHits_ = &_hits;

       break;

     default:

       break;

     }

   }


   void

   ClusterTask::runOnBasicClusters(const reco::BasicClusterCollection &_bcs, Collections _collection)

   {

     using namespace std;


     int nBC[] = {0, 0};

     bool isBarrel(_collection == kEBBasicCluster);


     vector<reco::BasicCluster const*> lowMassCands;


     for(reco::BasicClusterCollection::const_iterator bcItr(_bcs.begin()); bcItr != _bcs.end(); ++bcItr){

       const math::XYZPoint &position(bcItr->position());


       DetId id(bcItr->seed());

       if(id.null()){

     GlobalPoint gp(position.x(), position.y(), position.z());

     const CaloSubdetectorGeometry* subgeom(isBarrel ? ebGeometry_ : eeGeometry_);


     id = subgeom->getClosestCell(gp);

       }


       if(id.null() || (id.subdetId() == EcalBarrel && !isBarrel) || (id.subdetId() == EcalEndcap && isBarrel)) continue;


       float energy(bcItr->energy());


       MEs_[kBCE]->fill(id, energy);


       MEs_[kBCEMap]->fill(id, energy);

       MEs_[kBCEMapProjEta]->fill(id, energy);

       MEs_[kBCEMapProjPhi]->fill(id, energy);


       MEs_[kBCOccupancy]->fill(id);

       MEs_[kBCOccupancyProjEta]->fill(id);

       MEs_[kBCOccupancyProjPhi]->fill(id);


       float size(bcItr->size());


       MEs_[kBCSize]->fill(id, size);


       MEs_[kBCSizeMap]->fill(id, size);

       MEs_[kBCSizeMapProjEta]->fill(id, size);

       MEs_[kBCSizeMapProjPhi]->fill(id, size);


       int zside(position.z() > 0 ? 1 : 0);

       nBC[zside]++;


       if(ievt_ % massCalcPrescale_ != 0) continue;


       if(energy > 10.) continue;


       EcalRecHitCollection::const_iterator hitItr(isBarrel ? ebHits_->find(id) : eeHits_->find(id));

       if(hitItr == (isBarrel ? ebHits_->end() : eeHits_->end())) continue;


       // cuts here must be parametrized

       if(hitItr->energy() < 0.5) continue;


       if(hitItr->energy() / energy > 0.95) continue;


       lowMassCands.push_back(&(*bcItr));

     }


     if(isBarrel){

       MEs_[kBCNum]->fill((unsigned)BinService::kEB + 1, nBC[0] + nBC[1]);

     }else{

       MEs_[kBCNum]->fill((unsigned)BinService::kEEm + 1, nBC[0]);

       MEs_[kBCNum]->fill((unsigned)BinService::kEEp + 1, nBC[1]);

     }


     if(ievt_ % massCalcPrescale_ != 0) return;


     for(vector<reco::BasicCluster const*>::iterator bcItr1(lowMassCands.begin()); bcItr1 != lowMassCands.end(); ++bcItr1){

       reco::BasicCluster const& bc1(**bcItr1);

       float energy1(bc1.energy());

       float px1(energy1 * sin(bc1.position().theta()) * cos(bc1.phi()));

       float py1(energy1 * sin(bc1.position().theta()) * sin(bc1.phi()));

       float pz1(energy1 * cos(bc1.position().theta()));


       for(vector<reco::BasicCluster const*>::iterator bcItr2(lowMassCands.begin()); bcItr2 != lowMassCands.end(); ++bcItr2){

     if(*bcItr1 == *bcItr2) continue;

     reco::BasicCluster const& bc2(**bcItr2);

     float energy2(bc2.energy());

     float px2(energy2 * sin(bc2.position().theta()) * cos(bc2.phi()));

     float py2(energy2 * sin(bc2.position().theta()) * sin(bc2.phi()));

     float pz2(energy2 * cos(bc2.position().theta()));


     float ptpair(sqrt((px1 + px2) * (px1 + px2) + (py1 + py2) * (py1 + py2)));

     if(ptpair < 2.5) continue;


     float epair(energy1 + energy2);

     float pzpair(abs(pz1 + pz2));


     if(epair < pzpair + 1.e-10) continue;

     float eta(0.5 * log((epair + pzpair)/(epair - pzpair)));

     float phi(atan2(px1 + px2, py1 + py2));


     float iso(0.);

     for(reco::BasicClusterCollection::const_iterator bcItr(_bcs.begin()); bcItr != _bcs.end(); ++bcItr){

       float dEta(bcItr->eta() - eta);

       float dPhi(bcItr->phi() - phi);

       if(sqrt(dEta * dEta + dPhi * dPhi) < 0.2) iso += bcItr->energy() * sin(bcItr->position().theta());

     }

     if(iso > 0.5) continue;


     float mass(sqrt(epair * epair - pzpair * pzpair - ptpair * ptpair));

     MEs_[kPi0]->fill(mass);

     MEs_[kJPsi]->fill(mass);

       }

     }

   }


   void

   ClusterTask::runOnSuperClusters(const reco::SuperClusterCollection &_scs, Collections _collection)

   {

     using namespace std;


     const EcalRecHitCollection *hits(0);

     bool isBarrel;

     if(_collection == kEBSuperCluster){

       hits = ebHits_;

       isBarrel = true;

     }else{

       hits = eeHits_;

       isBarrel = false;

     }


     reco::SuperCluster const* leading(0);

     reco::SuperCluster const* subLeading(0);


     int nSC[] = {0, 0};


     for(reco::SuperClusterCollection::const_iterator scItr(_scs.begin()); scItr != _scs.end(); ++scItr){

       const math::XYZPoint &position(scItr->position());


       DetId id(scItr->seed()->seed());

       if(id.null()){

     GlobalPoint gp(position.x(), position.y(), position.z());

     const CaloSubdetectorGeometry* subgeom(isBarrel ? ebGeometry_ : eeGeometry_);


     id = subgeom->getClosestCell(gp);

       }


       if(id.null() || (id.subdetId() == EcalBarrel && !isBarrel) || (id.subdetId() == EcalEndcap && isBarrel)) continue;


       float energy(scItr->energy());


       MEs_[kSCE]->fill(id, energy);

       if(energy < lowEMax_) MEs_[kSCELow]->fill(id, energy);


       MEs_[kSCNBCs]->fill(id, scItr->clustersSize());

       MEs_[kSCNcrystals]->fill(id, scItr->size());


       if(!hits) continue;

       EcalRecHitCollection::const_iterator seedItr(hits->find(id));

       if(seedItr == hits->end()) continue;


       MEs_[kSCSeedEnergy]->fill(id, seedItr->energy());

       MEs_[kSCClusterVsSeed]->fill(id, seedItr->energy(), energy);


       MEs_[kSCSeedOccupancy]->fill(id);


       if(_scs.size() == 1)

     MEs_[kSingleCrystalCluster]->fill(id);


       float e3x3(EcalClusterTools::e3x3(*scItr->seed(), hits, topology_));

       MEs_[kSCR9]->fill(id, e3x3 / energy);


       int zside(position.z() > 0 ? 1 : 0);

       nSC[zside]++;


       if(ievt_ % massCalcPrescale_ != 0) continue;


       float et(energy * sin(scItr->position().theta()));

       if(!leading || et > leading->energy() * sin(leading->position().theta())){

     subLeading = leading;

     leading = &(*scItr);

       }

       else if(!subLeading || et > subLeading->energy() * sin(subLeading->position().theta())){

     subLeading = &(*scItr);

       }

     }


     if(_collection == kEBSuperCluster){

       MEs_[kSCNum]->fill((unsigned)BinService::kEB + 1, nSC[0] + nSC[1]);

     }else{

       MEs_[kSCNum]->fill((unsigned)BinService::kEEm + 1, nSC[0]);

       MEs_[kSCNum]->fill((unsigned)BinService::kEEp + 1, nSC[1]);

     }


     if(ievt_ % massCalcPrescale_ != 0) return;


     // implement isolation & cuts

     if(!leading || !subLeading) return;

     float e(leading->energy() + subLeading->energy());

     float px(leading->energy() * sin(leading->position().theta()) * cos(leading->phi()) + subLeading->energy() * sin(subLeading->position().theta()) * cos(subLeading->phi()));

     float py(leading->energy() * sin(leading->position().theta()) * sin(leading->phi()) + subLeading->energy() * sin(subLeading->position().theta()) * sin(subLeading->phi()));

     float pz(leading->energy() * cos(leading->position().theta()) + subLeading->energy() * cos(subLeading->position().theta()));

     float mass(sqrt(e * e - px * px - py * py - pz * pz));

     MEs_[kZ]->fill(mass);

     MEs_[kHighMass]->fill(mass);


   }


   /*static*/

   void

   ClusterTask::setMEData(std::vector<MEData>& _data)

   {

     BinService::AxisSpecs xaxis, yaxis, zaxis;


     zaxis.low = 0.;

     zaxis.high = 50.;

     _data[kBCEMap] = MEData("BCEMap", BinService::kEcal3P, BinService::kSuperCrystal, MonitorElement::DQM_KIND_TPROFILE2D, 0, 0, &zaxis);

     _data[kBCEMapProjEta] = MEData("BCEMap", BinService::kEcal3P, BinService::kProjEta, MonitorElement::DQM_KIND_TPROFILE);

     _data[kBCEMapProjPhi] = MEData("BCEMap", BinService::kEcal3P, BinService::kProjPhi, MonitorElement::DQM_KIND_TPROFILE);


     _data[kBCOccupancy] = MEData("BCOccupancy", BinService::kEcal3P, BinService::kSuperCrystal, MonitorElement::DQM_KIND_TH2F);

     _data[kBCOccupancyProjEta] = MEData("BCOccupancy", BinService::kEcal3P, BinService::kProjEta, MonitorElement::DQM_KIND_TH1F);

     _data[kBCOccupancyProjPhi] = MEData("BCOccupancy", BinService::kEcal3P, BinService::kProjPhi, MonitorElement::DQM_KIND_TH1F);


     zaxis.high = 30.;

     _data[kBCSizeMap] = MEData("BCSizeMap", BinService::kEcal3P, BinService::kSuperCrystal, MonitorElement::DQM_KIND_TPROFILE2D, 0, 0, &zaxis);

     _data[kBCSizeMapProjEta] = MEData("BCSizeMap", BinService::kEcal3P, BinService::kProjEta, MonitorElement::DQM_KIND_TPROFILE);

     _data[kBCSizeMapProjPhi] = MEData("BCSizeMap", BinService::kEcal3P, BinService::kProjPhi, MonitorElement::DQM_KIND_TPROFILE);


     xaxis.nbins = 50;

     xaxis.low = 0.;

     xaxis.high = 150.;

     _data[kBCE] = MEData("BCE", BinService::kEcal3P, BinService::kUser, MonitorElement::DQM_KIND_TH1F, &xaxis);


     xaxis.nbins = 20;

     xaxis.low = 0.;

     xaxis.high = 100.;

     _data[kBCNum] = MEData("BCNum", BinService::kEcal2P, BinService::kUser, MonitorElement::DQM_KIND_TH1F, &xaxis);


     xaxis.nbins = 50;

     xaxis.low = 0.;

     xaxis.high = 100.;

     _data[kBCSize] = MEData("BCSize", BinService::kEcal2P, BinService::kUser, MonitorElement::DQM_KIND_TH1F, &xaxis);


     xaxis.nbins = 50;

     xaxis.low = 0.;

     xaxis.high = 150.;

     _data[kSCE] = MEData("SCE", BinService::kEcal2P, BinService::kUser, MonitorElement::DQM_KIND_TH1F, &xaxis);


     xaxis.nbins = 50;

     xaxis.low = 0.;

     xaxis.high = 10.;

     _data[kSCELow] = MEData("SCELow", BinService::kEcal2P, BinService::kUser, MonitorElement::DQM_KIND_TH1F, &xaxis);


     xaxis.nbins = 50;

     xaxis.low = 0.;

     xaxis.high = 150.;

     _data[kSCSeedEnergy] = MEData("SCSeedEnergy", BinService::kEcal2P, BinService::kUser, MonitorElement::DQM_KIND_TH1F, &xaxis);


     yaxis.nbins = 50;

     yaxis.low = 0.;

     yaxis.high = 150.;

     _data[kSCClusterVsSeed] = MEData("SCClusterVsSeed", BinService::kEcal2P, BinService::kUser, MonitorElement::DQM_KIND_TH2F, &xaxis, &yaxis);


     _data[kSCSeedOccupancy] = MEData("SCSeedOccupancy", BinService::kEcal3P, BinService::kSuperCrystal, MonitorElement::DQM_KIND_TH2F);

     _data[kSingleCrystalCluster] = MEData("SCSingleCrystalCluster", BinService::kEcal3P, BinService::kSuperCrystal, MonitorElement::DQM_KIND_TH2F);


     xaxis.nbins = 20;

     xaxis.low = 0.;

     xaxis.high = 20.;

     _data[kSCNum] = MEData("SCNum", BinService::kEcal2P, BinService::kUser, MonitorElement::DQM_KIND_TH1F, &xaxis);


     xaxis.nbins = 15;

     xaxis.low = 0.;

     xaxis.high = 15.;

     _data[kSCNBCs] = MEData("SCNBCs", BinService::kEcal2P, BinService::kUser, MonitorElement::DQM_KIND_TH1F, &xaxis);

     xaxis.nbins = 50;

     xaxis.low = 0.;

     xaxis.high = 150.;

     _data[kSCNcrystals] = MEData("SCNcrystals", BinService::kEcal2P, BinService::kUser, MonitorElement::DQM_KIND_TH1F, &xaxis);


     xaxis.nbins = 50;

     xaxis.low = 0.;

     xaxis.high = 1.2;

     _data[kSCR9] = MEData("SCR9", BinService::kEcal2P, BinService::kUser, MonitorElement::DQM_KIND_TH1F, &xaxis);


     xaxis.nbins = 50;

     xaxis.low = 0.;

     xaxis.high = 0.5;

     _data[kPi0] = MEData("Pi0", BinService::nObjType, BinService::kUser, MonitorElement::DQM_KIND_TH1F, &xaxis);

     xaxis.low = 2.9;

     xaxis.high = 3.3;

     _data[kJPsi] = MEData("JPsi", BinService::nObjType, BinService::kUser, MonitorElement::DQM_KIND_TH1F, &xaxis);

     xaxis.low = 40.;

     xaxis.high = 110.;

     _data[kZ] = MEData("Z", BinService::nObjType, BinService::kUser, MonitorElement::DQM_KIND_TH1F, &xaxis);

     xaxis.low = 110.;

     xaxis.high = 3000.;

     _data[kHighMass] = MEData("HighMass", BinService::nObjType, BinService::kUser, MonitorElement::DQM_KIND_TH1F, &xaxis);

   }


   DEFINE_ECALDQM_WORKER(ClusterTask);

 }


EcalSubdetector.h

MonitorElement::DQM_KIND_TPROFILE
Definition: MonitorElement.h:59

EcalClusterTools.h

reco::CaloCluster::position
const math::XYZPoint & position() const
cluster centroid position
Definition: CaloCluster.h:123

i
int i
Definition: DBlmapReader.cc:9

ecaldqm::kEESuperCluster
Definition: Collections.h:32

ecaldqm::ClusterTask::kSCNcrystals
Definition: ClusterTask.h:54

ecaldqm::ClusterTask::kBCEMap
Definition: ClusterTask.h:34

ecaldqm::DQWorkerTask::dependencies_
std::vector< std::pair< Collections, Collections > > dependencies_
Definition: DQWorkerTask.h:31

ecaldqm::ClusterTask::kSingleCrystalCluster
Definition: ClusterTask.h:51

lumiContext.fill
string fill
Definition: lumiContext.py:319

EcalDQMBinningService::kProjPhi
Definition: EcalDQMBinningService.h:52

EcalDCCHeaderBlock::PHYSICS_LOCAL
Definition: EcalDCCHeaderBlock.h:56

edm::SortedCollection< EcalRecHit >

EcalDQMBinningService::kProjEta
Definition: EcalDQMBinningService.h:51

EcalDCCHeaderBlock::COSMICS_LOCAL
Definition: EcalDCCHeaderBlock.h:57

ecaldqm::kEEBasicCluster
Definition: Collections.h:30

ecaldqm::ClusterTask::eeHits_
const EcalRecHitCollection * eeHits_
Definition: ClusterTask.h:70

CaloSubdetectorGeometry
Definition: CaloSubdetectorGeometry.h:21

MonitorElement::DQM_KIND_TH1F
Definition: MonitorElement.h:52

ecaldqm::ClusterTask::kSCELow
Definition: ClusterTask.h:47

ecaldqm::ClusterTask::filterRunType
bool filterRunType(const std::vector< short > &)
Definition: ClusterTask.cc:107

EcalDCCHeaderBlock.h

funct::sin
Sin< T >::type sin(const T &t)
Definition: Sin.h:22

create_public_lumi_plots.log
log
Definition: create_public_lumi_plots.py:1108

edm::SortedCollection< EcalRecHit >::const_iterator
std::vector< EcalRecHit >::const_iterator const_iterator
Definition: SortedCollection.h:80

ecaldqm::ClusterTask::ievt_
int ievt_
Definition: ClusterTask.h:71

abs
#define abs(x)
Definition: mlp_lapack.h:159

EcalDQMBinningService::kEEm
Definition: EcalDQMBinningService.h:32

ecaldqm::kEBBasicCluster
Definition: Collections.h:29

EcalDCCHeaderBlock::PHYSICS_GLOBAL
Definition: EcalDCCHeaderBlock.h:45

eta
T eta() const
Definition: Basic3DVectorLD.h:172

EcalDQMBinningService::kEcal2P
Definition: EcalDQMBinningService.h:38

reco::BasicCluster

CaloGeometryRecord
Definition: CaloGeometryRecord.h:26

position
static int position[TOTALCHAMBERS][3]
Definition: ReadPGInfo.cc:509

ecaldqm::ClusterTask::eeGeometry_
const CaloSubdetectorGeometry * eeGeometry_
Definition: ClusterTask.h:69

ecaldqm::ClusterTask::setMEData
static void setMEData(std::vector< MEData > &)
Definition: ClusterTask.cc:340

ecaldqm::ClusterTask::kBCSizeMapProjEta
Definition: ClusterTask.h:41

ecaldqm::DQWorkerTask::collectionMask_
uint32_t collectionMask_
Definition: DQWorkerTask.h:28

EcalDQMBinningService::AxisSpecs::low
double low
Definition: EcalDQMBinningService.h:88

EcalDQMBinningService::AxisSpecs::high
double high
Definition: EcalDQMBinningService.h:88

EcalDQMBinningService::AxisSpecs
Definition: EcalDQMBinningService.h:86

ecaldqm::ClusterTask::kBCE
Definition: ClusterTask.h:43

errorMatrix2Lands_multiChannel.id
tuple id
Definition: errorMatrix2Lands_multiChannel.py:151

ecaldqm::ClusterTask::kJPsi
Definition: ClusterTask.h:57

ecaldqm::ClusterTask::kBCSize
Definition: ClusterTask.h:45

EcalDQMBinningService::AxisSpecs::nbins
int nbins
Definition: EcalDQMBinningService.h:87

DetId::Ecal
Definition: DetId.h:26

CaloGeometryRecord.h

ecaldqm::ClusterTask::beginEvent
void beginEvent(const edm::Event &, const edm::EventSetup &)
Definition: ClusterTask.cc:72

dPhi
double dPhi(double phi1, double phi2)
Definition: JetUtil.h:30

ecaldqm::ClusterTask::ebHits_
const EcalRecHitCollection * ebHits_
Definition: ClusterTask.h:70

reco::SuperClusterCollection
std::vector< SuperCluster > SuperClusterCollection
collection of SuperCluser objectr
Definition: SuperClusterFwd.h:9

edm::ParameterSet::getUntrackedParameterSet
ParameterSet const & getUntrackedParameterSet(std::string const &name, ParameterSet const &defaultValue) const
Definition: ParameterSet.cc:2347

ecaldqm::ClusterTask::beginRun
void beginRun(const edm::Run &, const edm::EventSetup &)
Definition: ClusterTask.cc:53

mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:46

edm::ESHandle< CaloTopology >

ecaldqm::ClusterTask::massCalcPrescale_
int massCalcPrescale_
Definition: ClusterTask.h:73

CaloSubdetectorGeometry.h

ecaldqm::ClusterTask::kSCNBCs
Definition: ClusterTask.h:53

ecaldqm::ClusterTask::kSCNum
Definition: ClusterTask.h:52

ecaldqm::kEBRecHit
Definition: Collections.h:27

EcalDQMBinningService::kEEp
Definition: EcalDQMBinningService.h:33

ecaldqm::ClusterTask::runOnRecHits
void runOnRecHits(const EcalRecHitCollection &, Collections)
Definition: ClusterTask.cc:122

funct::cos
Cos< T >::type cos(const T &t)
Definition: Cos.h:22

ecaldqm::ClusterTask::kBCEMapProjPhi
Definition: ClusterTask.h:36

EcalClusterTools::e3x3
static float e3x3(const reco::BasicCluster &cluster, const EcalRecHitCollection *recHits, const CaloTopology *topology)
Definition: EcalClusterTools.cc:240

MonitorElement::DQM_KIND_TPROFILE2D
Definition: MonitorElement.h:60

ecaldqm::ClusterTask::kBCEMapProjEta
Definition: ClusterTask.h:35

ESHandle.h

ecaldqm::ClusterTask::lowEMax_
float lowEMax_
Definition: ClusterTask.h:72

ecaldqm::DQWorkerTask
Definition: DQWorkerTask.h:12

reco::CaloCluster::energy
double energy() const
cluster energy
Definition: CaloCluster.h:120

edm::EventSetup
Definition: EventSetup.h:44

ecaldqm::ClusterTask::kHighMass
Definition: ClusterTask.h:59

EcalDQMBinningService::nObjType
Definition: EcalDQMBinningService.h:42

EcalDQMBinningService::kSuperCrystal
Definition: EcalDQMBinningService.h:48

reco::SuperCluster
Definition: SuperCluster.h:20

ecaldqm::ClusterTask::kSCClusterVsSeed
Definition: ClusterTask.h:49

ecaldqm::ClusterTask::runOnSuperClusters
void runOnSuperClusters(const reco::SuperClusterCollection &, Collections)
Definition: ClusterTask.cc:247

CaloTopologyRecord
Definition: CaloTopologyRecord.h:11

ecaldqm::ClusterTask::kPi0
Definition: ClusterTask.h:56

ecaldqm::ClusterTask::kBCSizeMap
Definition: ClusterTask.h:40

ecaldqm::ClusterTask
Definition: ClusterTask.h:15

ecaldqm::ClusterTask::~ClusterTask
~ClusterTask()
Definition: ClusterTask.cc:48

ecaldqm::ClusterTask::kSCR9
Definition: ClusterTask.h:55

edm::SortedCollection::end
const_iterator end() const
Definition: SortedCollection.h:301

ecaldqm::kRun
Definition: Collections.h:33

DetId
Definition: DetId.h:20

ecaldqm::DQWorker::bookMEs
virtual void bookMEs()
Definition: DQWorker.cc:48

edm::hlt::Exception
error
Definition: HLTenums.h:24

CaloTopologyRecord.h

ecaldqm::DQWorker::MEs_
std::vector< MESet * > MEs_
Definition: DQWorker.h:56

ecaldqm::Collections
Collections
Definition: Collections.h:6

CaloGeometry.h

math::XYZPoint
XYZPointD XYZPoint
point in space with cartesian internal representation
Definition: Point3D.h:13

edm::EventSetup::get
const T & get() const
Definition: EventSetup.h:55

edm::ESHandle::product
T const * product() const
Definition: ESHandle.h:62

EcalDQMBinningService::kUser
Definition: EcalDQMBinningService.h:53

reco::BasicClusterCollection
std::vector< BasicCluster > BasicClusterCollection
collection of BasicCluster objects
Definition: BasicClusterFwd.h:27

EcalDCCHeaderBlock::MTCC
Definition: EcalDCCHeaderBlock.h:33

ecaldqm::ClusterTask::topology_
const CaloTopology * topology_
Definition: ClusterTask.h:67

alignCSCRings.e
list e
Definition: alignCSCRings.py:90

ecaldqm::ClusterTask::kBCNum
Definition: ClusterTask.h:44

ecaldqm::MEData
Definition: MESet.h:20

Point3DBase< float, GlobalTag >

edm::SortedCollection::find
iterator find(key_type k)
Definition: SortedCollection.h:262

ecaldqm::ClusterTask::kBCOccupancyProjPhi
Definition: ClusterTask.h:39

ecaldqm::kEERecHit
Definition: Collections.h:28

ecaldqm::ClusterTask::ClusterTask
ClusterTask(const edm::ParameterSet &, const edm::ParameterSet &)
Definition: ClusterTask.cc:19

ecaldqm::ClusterTask::kSCSeedOccupancy
Definition: ClusterTask.h:50

scaleCards.mass
tuple mass
Definition: scaleCards.py:27

EcalBarrel
Definition: EcalSubdetector.h:12

ecaldqm::ClusterTask::runOnBasicClusters
void runOnBasicClusters(const reco::BasicClusterCollection &, Collections)
Definition: ClusterTask.cc:137

ecaldqm::ClusterTask::kSCE
Definition: ClusterTask.h:46

EcalDQMBinningService::kEcal3P
Definition: EcalDQMBinningService.h:39

edm::ParameterSet
Definition: ParameterSet.h:35

EcalDCCHeaderBlock::COSMICS_GLOBAL
Definition: EcalDCCHeaderBlock.h:46

relval_parameters_module.energy
string energy
Definition: relval_parameters_module.py:29

EcalEndcap
Definition: EcalSubdetector.h:12

ecaldqm::ClusterTask::kZ
Definition: ClusterTask.h:58

ecaldqm::DEFINE_ECALDQM_WORKER
DEFINE_ECALDQM_WORKER(CertificationClient)

ecaldqm::ClusterTask::bookMEs
void bookMEs()
Definition: ClusterTask.cc:81

ecaldqm::ClusterTask::kBCSizeMapProjPhi
Definition: ClusterTask.h:42

ecaldqm::ClusterTask::kBCOccupancyProjEta
Definition: ClusterTask.h:38

ecaldqm::ClusterTask::kSCSeedEnergy
Definition: ClusterTask.h:48

reco::CaloCluster::phi
double phi() const
azimuthal angle of cluster centroid
Definition: CaloCluster.h:163

EcalDetIdCollections.h

edm::Event
Definition: Event.h:50

MonitorElement::DQM_KIND_TH2F
Definition: MonitorElement.h:55

findQualityFiles.size
tuple size
Write out results.
Definition: findQualityFiles.py:442

ecaldqm::DQWorker::name_
std::string name_
Definition: DQWorker.h:55

ecaldqm::ClusterTask::kBCOccupancy
Definition: ClusterTask.h:37

EcalDCCHeaderBlock::COSMIC
Definition: EcalDCCHeaderBlock.h:30

CaloTopology.h

edm::Run
Definition: Run.h:33

ecaldqm::kEBSuperCluster
Definition: Collections.h:31

GlobalPoint.h

EcalDQMBinningService::kEB
Definition: EcalDQMBinningService.h:29

phi
Definition: DDAxes.h:10

ecaldqm::ClusterTask::ebGeometry_
const CaloSubdetectorGeometry * ebGeometry_
Definition: ClusterTask.h:68