#include <ClusterTask.h>

Inheritance diagram for ecaldqm::ClusterTask:

Public Types
enum	MESets { kBCEMap, kBCEMapProjEta, kBCEMapProjPhi, kBCOccupancy, kBCOccupancyProjEta, kBCOccupancyProjPhi, kBCSizeMap, kBCSizeMapProjEta, kBCSizeMapProjPhi, kBCE, kBCNum, kBCSize, kSCE, kSCELow, kSCSeedEnergy, kSCClusterVsSeed, kSCSeedOccupancy, kSingleCrystalCluster, kSCNum, kSCNBCs, kSCNcrystals, kSCR9, kPi0, kJPsi, kZ, kHighMass, nMESets }

Public Types inherited from ecaldqm::DQWorker
enum	MESets { nMESets }

Public Member Functions
void	analyze (const void *, Collections) override

void	beginEvent (const edm::Event &, const edm::EventSetup &) override

void	beginRun (const edm::Run &, const edm::EventSetup &) override

void	bookMEs () override

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

bool	filterRunType (const std::vector< short > &) override

void	runOnBasicClusters (const reco::BasicClusterCollection &, Collections)

void	runOnRecHits (const EcalRecHitCollection &, Collections)

void	runOnSuperClusters (const reco::SuperClusterCollection &, Collections)

	~ClusterTask ()

Public Member Functions inherited from ecaldqm::DQWorkerTask
	DQWorkerTask (const edm::ParameterSet &, const edm::ParameterSet &, std::string const &)

virtual void	endEvent (const edm::Event &, const edm::EventSetup &)

virtual bool	filterTrigger (const edm::TriggerResultsByName &)

virtual const std::vector < std::pair< Collections, Collections > > &	getDependencies ()

virtual bool	runsOn (unsigned)

virtual	~DQWorkerTask ()

Public Member Functions inherited from ecaldqm::DQWorker
virtual void	beginLuminosityBlock (const edm::LuminosityBlock &, const edm::EventSetup &)

	DQWorker (const edm::ParameterSet &, const edm::ParameterSet &, std::string const &)

virtual void	endLuminosityBlock (const edm::LuminosityBlock &, const edm::EventSetup &)

virtual void	endRun (const edm::Run &, const edm::EventSetup &)

const std::vector< MESet * > &	getMEs ()

virtual std::string const &	getName ()

virtual bool	isInitialized ()

virtual void	reset ()

virtual void	setInitialized (bool _init)

virtual void	setVerbosity (int _verbosity)

virtual	~DQWorker ()

Static Public Member Functions
static void	setMEData (std::vector< MEData > &)

Static Public Member Functions inherited from ecaldqm::DQWorker
static void	setMEData (std::vector< MEData > &)

Private Attributes
const CaloSubdetectorGeometry *	ebGeometry_

const EcalRecHitCollection *	ebHits_

const CaloSubdetectorGeometry *	eeGeometry_

const EcalRecHitCollection *	eeHits_

int	ievt_

float	lowEMax_

int	massCalcPrescale_

const CaloTopology *	topology_

Additional Inherited Members
Static Public Attributes inherited from ecaldqm::DQWorker
static std::map< std::string, std::vector< MEData > >	meData

Protected Member Functions inherited from ecaldqm::DQWorker
MESet *	createMESet_ (std::string const &, MEData const &, bool _readOnly=false) const

void	meSet_ (unsigned, edm::ParameterSet const &)

Protected Attributes inherited from ecaldqm::DQWorkerTask
uint32_t	collectionMask_

std::vector< std::pair < Collections, Collections > >	dependencies_

Protected Attributes inherited from ecaldqm::DQWorker
bool	initialized_

std::vector< MESet * >	MEs_

std::string	name_

int	verbosity_

Detailed Description

Definition at line 15 of file ClusterTask.h.

Member Enumeration Documentation

enum ecaldqm::ClusterTask::MESets

Enumerator
kBCEMap
kBCEMapProjEta
kBCEMapProjPhi
kBCOccupancy
kBCOccupancyProjEta
kBCOccupancyProjPhi
kBCSizeMap
kBCSizeMapProjEta
kBCSizeMapProjPhi
kBCE
kBCNum
kBCSize
kSCE
kSCELow
kSCSeedEnergy
kSCClusterVsSeed
kSCSeedOccupancy
kSingleCrystalCluster
kSCNum
kSCNBCs
kSCNcrystals
kSCR9
kPi0
kJPsi
kZ
kHighMass
nMESets

Definition at line 33 of file ClusterTask.h.

                 {
       kBCEMap, // profile2d
       kBCEMapProjEta, // profile
       kBCEMapProjPhi, // profile
       kBCOccupancy, // h2f
       kBCOccupancyProjEta, // h1f
       kBCOccupancyProjPhi, // h1f
       kBCSizeMap, // profile2d
       kBCSizeMapProjEta, // profile
       kBCSizeMapProjPhi, // profile
       kBCE, // h1f
       kBCNum, // h1f for EB & EE
       kBCSize, // h1f for EB & EE
       kSCE, // h1f
       kSCELow, // h1f
       kSCSeedEnergy, // h1f
       kSCClusterVsSeed, // h2f
       kSCSeedOccupancy, // h2f
       kSingleCrystalCluster, // h2f
       kSCNum, // h1f
       kSCNBCs, // h1f
       kSCNcrystals, // h1f
       kSCR9, // h1f
       kPi0, // h1f
       kJPsi, // h1f
       kZ, // h1f
       kHighMass, // h1f
       nMESets
     };

Constructor & Destructor Documentation

ecaldqm::ClusterTask::ClusterTask	(	const edm::ParameterSet &	,
		const edm::ParameterSet &
	)

Definition at line 19 of file ClusterTask.cc.

References ecaldqm::DQWorkerTask::collectionMask_, ecaldqm::DQWorkerTask::dependencies_, edm::ParameterSet::getUntrackedParameterSet(), ecaldqm::kEBBasicCluster, ecaldqm::kEBRecHit, ecaldqm::kEBSuperCluster, ecaldqm::kEEBasicCluster, ecaldqm::kEERecHit, ecaldqm::kEESuperCluster, ecaldqm::kRun, lowEMax_, massCalcPrescale_, and ecaldqm::DQWorker::name_.

                                                                                        :
     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");
   }

ecaldqm::ClusterTask::~ClusterTask ( )

Definition at line 48 of file ClusterTask.cc.

49 {

50 }

Member Function Documentation

void ecaldqm::ClusterTask::analyze	(	const void *	_p,
		Collections	_collection
	)

inlineoverridevirtual

Reimplemented from ecaldqm::DQWorkerTask.

Definition at line 76 of file ClusterTask.h.

References ecaldqm::kEBBasicCluster, ecaldqm::kEBRecHit, ecaldqm::kEBSuperCluster, ecaldqm::kEEBasicCluster, ecaldqm::kEERecHit, ecaldqm::kEESuperCluster, runOnBasicClusters(), runOnRecHits(), and runOnSuperClusters().

                                                                          {
     switch(_collection){
     case kEBRecHit:
     case kEERecHit:
       runOnRecHits(*static_cast<const EcalRecHitCollection*>(_p), _collection);
       break;
     case kEBBasicCluster:
     case kEEBasicCluster:
       runOnBasicClusters(*static_cast<const reco::BasicClusterCollection*>(_p), _collection);
       break;
     case kEBSuperCluster:
     case kEESuperCluster:
       runOnSuperClusters(*static_cast<const reco::SuperClusterCollection*>(_p), _collection);
       break;
     default:
       break;
     }
   }

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

overridevirtual

Reimplemented from ecaldqm::DQWorkerTask.

Definition at line 72 of file ClusterTask.cc.

References ebHits_, eeHits_, and ievt_.

   {
     ebHits_ = 0;
     eeHits_ = 0;
 
     ievt_++;
   }

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

overridevirtual

Reimplemented from ecaldqm::DQWorker.

Definition at line 53 of file ClusterTask.cc.

References ebGeometry_, DetId::Ecal, EcalBarrel, EcalEndcap, eeGeometry_, edm::hlt::Exception, edm::EventSetup::get(), ievt_, edm::ESHandle< class >::product(), and topology_.

   {
     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 ecaldqm::ClusterTask::bookMEs ( )

overridevirtual

Reimplemented from ecaldqm::DQWorker.

Definition at line 81 of file ClusterTask.cc.

References ecaldqm::DQWorker::bookMEs(), i, kBCE, kBCNum, kBCSize, kHighMass, kJPsi, kPi0, kSCClusterVsSeed, kSCE, kSCELow, kSCNBCs, kSCNcrystals, kSCNum, kSCR9, kSCSeedEnergy, kZ, lowEMax_, and ecaldqm::DQWorker::MEs_.

   {
     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 ecaldqm::ClusterTask::filterRunType ( const std::vector< short > & _runType )

overridevirtual

Reimplemented from ecaldqm::DQWorkerTask.

Definition at line 107 of file ClusterTask.cc.

References EcalDCCHeaderBlock::COSMIC, EcalDCCHeaderBlock::COSMICS_GLOBAL, EcalDCCHeaderBlock::COSMICS_LOCAL, EcalDCCHeaderBlock::MTCC, EcalDCCHeaderBlock::PHYSICS_GLOBAL, and EcalDCCHeaderBlock::PHYSICS_LOCAL.

   {
     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 ecaldqm::ClusterTask::runOnBasicClusters	(	const reco::BasicClusterCollection &	_bcs,
		Collections	_collection
	)

Definition at line 137 of file ClusterTask.cc.

References funct::abs(), funct::cos(), dPhi(), alignCSCRings::e, ebGeometry_, ebHits_, EcalBarrel, EcalEndcap, eeGeometry_, eeHits_, edm::SortedCollection< T, SORT >::end(), relval_parameters_module::energy, eta(), edm::SortedCollection< T, SORT >::find(), ievt_, kBCE, kBCEMap, kBCEMapProjEta, kBCEMapProjPhi, kBCNum, kBCOccupancy, kBCOccupancyProjEta, kBCOccupancyProjPhi, kBCSize, kBCSizeMap, kBCSizeMapProjEta, kBCSizeMapProjPhi, EcalDQMBinningService::kEB, ecaldqm::kEBBasicCluster, EcalDQMBinningService::kEEm, EcalDQMBinningService::kEEp, kJPsi, kPi0, create_public_lumi_plots::log, massCalcPrescale_, ecaldqm::DQWorker::MEs_, phi, position, funct::sin(), findQualityFiles::size, and mathSSE::sqrt().

Referenced by analyze().

   {
     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 ecaldqm::ClusterTask::runOnRecHits	(	const EcalRecHitCollection &	_hits,
		Collections	_collection
	)

Definition at line 122 of file ClusterTask.cc.

References ebHits_, eeHits_, ecaldqm::kEBRecHit, and ecaldqm::kEERecHit.

Referenced by analyze().

   {
     switch(_collection){
     case kEBRecHit:
       ebHits_ = &_hits;
       break;
     case kEERecHit:
       eeHits_ = &_hits;
       break;
     default:
       break;
     }
   }

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

Definition at line 247 of file ClusterTask.cc.

References funct::cos(), alignCSCRings::e, EcalClusterTools::e3x3(), ebGeometry_, ebHits_, EcalBarrel, EcalEndcap, eeGeometry_, eeHits_, edm::SortedCollection< T, SORT >::end(), relval_parameters_module::energy, reco::CaloCluster::energy(), lumiContext::fill, edm::SortedCollection< T, SORT >::find(), ievt_, EcalDQMBinningService::kEB, ecaldqm::kEBSuperCluster, EcalDQMBinningService::kEEm, EcalDQMBinningService::kEEp, kHighMass, kSCClusterVsSeed, kSCE, kSCELow, kSCNBCs, kSCNcrystals, kSCNum, kSCR9, kSCSeedEnergy, kSCSeedOccupancy, kSingleCrystalCluster, kZ, lowEMax_, massCalcPrescale_, ecaldqm::DQWorker::MEs_, reco::CaloCluster::phi(), reco::CaloCluster::position(), position, funct::sin(), mathSSE::sqrt(), and topology_.

Referenced by analyze().

   {
     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);
 
   }

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

static

Definition at line 340 of file ClusterTask.cc.

   {
     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);
   }