#include <PiZeroTask.h>

Inheritance diagram for ecaldqm::PiZeroTask:

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

bool	filterRunType (short const *) override

	PiZeroTask ()

void	runOnEBRecHits (EcalRecHitCollection const &)

	~PiZeroTask () override=default

Public Member Functions inherited from ecaldqm::DQWorkerTask
virtual void	addDependencies (DependencySet &)

virtual void	beginEvent (edm::Event const &, edm::EventSetup const &, bool const &, bool &)

	DQWorkerTask ()

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

virtual bool	filterTrigger (edm::TriggerResultsByName const &)

virtual void	setTokens (edm::ConsumesCollector &)

	~DQWorkerTask () override

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

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

virtual void	bookMEs (DQMStore::IBooker &)

bool	checkElectronicsMap (bool=true)

bool	checkGeometry (bool=true)

bool	checkTopology (bool=true)

bool	checkTrigTowerMap (bool=true)

	DQWorker ()

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

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

EcalDQMSetupObjects const	getEcalDQMSetupObjects ()

EcalElectronicsMapping const *	GetElectronicsMap ()

CaloGeometry const *	GetGeometry ()

std::string const &	getName () const

CaloTopology const *	GetTopology ()

EcalTrigTowerConstituentsMap const *	GetTrigTowerMap ()

bool	onlineMode () const

virtual void	releaseMEs ()

void	setEventNumber (edm::EventNumber_t _e)

void	setLumiNumber (edm::LuminosityBlockNumber_t _l)

void	setRunNumber (edm::RunNumber_t _r)

void	setSetupObjects (edm::EventSetup const &)

void	setSetupObjectsEndLumi (edm::EventSetup const &)

void	setTime (time_t _t)

void	setTokens (edm::ConsumesCollector &)

virtual	~DQWorker () noexcept(false)

Private Member Functions
void	setParams (edm::ParameterSet const &) override

Private Attributes
int	clusEtaSize_

int	clusPhiSize_

double	clusSeedThr_

edm::ParameterSet	posCalcParameters_

double	seleMinvMaxPi0_

double	seleMinvMinPi0_

double	selePi0BeltDeta_

double	selePi0BeltDR_

double	selePi0Iso_

double	selePtGammaOne_

double	selePtGammaTwo_

double	selePtPi0_

double	seleS4S9GammaOne_

double	seleS4S9GammaTwo_

double	seleXtalMinEnergy_

Static Private Attributes
static const int	MAXCLUS = 2000

static const int	MAXPI0S = 200

Additional Inherited Members
Public Types inherited from ecaldqm::DQWorkerTask
typedef EcalDCCHeaderBlock::EcalDCCEventSettings	EventSettings

Static Public Member Functions inherited from ecaldqm::DQWorkerTask
static void	fillDescriptions (edm::ParameterSetDescription &)

Static Public Member Functions inherited from ecaldqm::DQWorker
static void	fillDescriptions (edm::ParameterSetDescription &_desc)

Public Attributes inherited from ecaldqm::DQWorker
edm::ESGetToken< EcalElectronicsMapping, EcalMappingRcd >	elecMapHandle

edm::ESGetToken< EcalElectronicsMapping, EcalMappingRcd >	elecMapHandleEndLumi

edm::ESGetToken< CaloGeometry, CaloGeometryRecord >	geomHandle

edm::ESGetToken< CaloGeometry, CaloGeometryRecord >	geomHandleEndLumi

edm::ESGetToken< CaloTopology, CaloTopologyRecord >	topoHandle

edm::ESGetToken< CaloTopology, CaloTopologyRecord >	topoHandleEndLumi

edm::ESGetToken< EcalTrigTowerConstituentsMap, IdealGeometryRecord >	ttMapHandle

edm::ESGetToken< EcalTrigTowerConstituentsMap, IdealGeometryRecord >	ttMapHandleEndLumi

Protected Types inherited from ecaldqm::DQWorker
typedef dqm::legacy::DQMStore	DQMStore

typedef dqm::legacy::MonitorElement	MonitorElement

Protected Member Functions inherited from ecaldqm::DQWorkerTask
void	setME (edm::ParameterSet const &) final

Protected Member Functions inherited from ecaldqm::DQWorker
void	initialize (std::string const &_name, edm::ParameterSet const &)

void	print_ (std::string const &, int=0) const

virtual void	setSource (edm::ParameterSet const &)

void	setVerbosity (int _verbosity)

Protected Attributes inherited from ecaldqm::DQWorker
bool	booked_

MESetCollection	MEs_

std::string	name_

bool	onlineMode_

Timestamp	timestamp_

int	verbosity_

bool	willConvertToEDM_

Detailed Description

Definition at line 17 of file PiZeroTask.h.

Constructor & Destructor Documentation

◆ PiZeroTask()

ecaldqm::PiZeroTask::PiZeroTask ( )

Definition at line 4 of file PiZeroTask.cc.

       : DQWorkerTask(),
         seleXtalMinEnergy_(0.f),
         clusSeedThr_(0.f),
         clusEtaSize_(0),
         clusPhiSize_(0),
         selePtGammaOne_(0.f),
         selePtGammaTwo_(0.f),
         seleS4S9GammaOne_(0.f),
         seleS4S9GammaTwo_(0.f),
         selePtPi0_(0.f),
         selePi0Iso_(0.f),
         selePi0BeltDR_(0.f),
         selePi0BeltDeta_(0.f),
         seleMinvMaxPi0_(0.f),
         seleMinvMinPi0_(0.f),
         posCalcParameters_(edm::ParameterSet()) {}

◆ ~PiZeroTask()

ecaldqm::PiZeroTask::~PiZeroTask ( )

overridedefault

Member Function Documentation

◆ analyze()

bool ecaldqm::PiZeroTask::analyze	(	void const *	collection_data,
		Collections	collection
	)

inlineoverridevirtual

Reimplemented from ecaldqm::DQWorkerTask.

Definition at line 53 of file PiZeroTask.h.

References universalConfigTemplate::collection, ecaldqm::kEBRecHit, ecaldqm::kEERecHit, and runOnEBRecHits().

                                                                                      {
     switch (collection) {
       case kEBRecHit:
         if (collection_data)
           runOnEBRecHits(*static_cast<EcalRecHitCollection const*>(collection_data));
         return true;
       case kEERecHit:  // This module does not run on EERecHits
         break;
       default:
         break;
     }
 
     return false;
   }

◆ filterRunType()

bool ecaldqm::PiZeroTask::filterRunType ( short const * runType )

overridevirtual

Reimplemented from ecaldqm::DQWorkerTask.

Definition at line 44 of file PiZeroTask.cc.

References EcalDCCHeaderBlock::COSMIC, EcalDCCHeaderBlock::COSMICS_GLOBAL, EcalDCCHeaderBlock::COSMICS_LOCAL, EcalDCCHeaderBlock::MTCC, ecaldqm::nDCC, EcalDCCHeaderBlock::PHYSICS_GLOBAL, EcalDCCHeaderBlock::PHYSICS_LOCAL, and EcalCondDBWriter_cfi::runType.

                                                      {
     for (unsigned iFED(0); iFED != ecaldqm::nDCC; 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;
   }

◆ runOnEBRecHits()

void ecaldqm::PiZeroTask::runOnEBRecHits ( EcalRecHitCollection const & hits )

Definition at line 55 of file PiZeroTask.cc.

References ecaldqm::MESetCollection::at(), PositionCalc::Calculate_Location(), clusEtaSize_, clusPhiSize_, clusSeedThr_, funct::cos(), DetId::Ecal, EcalBarrel, EcalPreshower, hcalRecHitTable_cff::energy, JetChargeProducer_cfi::exp, ecaldqm::DQWorker::getEcalDQMSetupObjects(), ecaldqm::DQWorker::GetGeometry(), CaloGeometry::getSubdetectorGeometry(), CaloTopology::getSubdetectorTopology(), ecaldqm::DQWorker::GetTopology(), CaloSubdetectorTopology::getWindow(), hfClusterShapes_cfi::hits, mps_fire::i, l1ctLayer2EG_cff::id, hit::id, hcalRecHitTable_cff::ieta, EBDetId::ieta(), hcalRecHitTable_cff::iphi, EBDetId::iphi(), dqmiolumiharvest::j, dqmdumpme::k, MAXCLUS, MAXPI0S, ecaldqm::DQWorker::MEs_, posCalcParameters_, fileCollector::seed, HLT_2024v14_cff::seeds, seleMinvMaxPi0_, seleMinvMinPi0_, selePi0BeltDeta_, selePi0BeltDR_, selePi0Iso_, selePtGammaOne_, selePtGammaTwo_, selePtPi0_, seleS4S9GammaOne_, seleS4S9GammaTwo_, seleXtalMinEnergy_, funct::sin(), jetUpdater_cfi::sort, mathSSE::sqrt(), and x.

Referenced by analyze().

                                                                   {
     MESet& mePi0MinvEB(MEs_.at("Pi0MinvEB"));
     MESet& mePi0Pt1EB(MEs_.at("Pi0Pt1EB"));
     MESet& mePi0Pt2EB(MEs_.at("Pi0Pt2EB"));
     MESet& mePi0PtEB(MEs_.at("Pi0PtEB"));
     MESet& mePi0IsoEB(MEs_.at("Pi0IsoEB"));
 
     const CaloSubdetectorTopology* topology_p;
     const CaloSubdetectorGeometry* geometry_p = GetGeometry()->getSubdetectorGeometry(DetId::Ecal, EcalBarrel);
     const CaloSubdetectorGeometry* geometryES_p = GetGeometry()->getSubdetectorGeometry(DetId::Ecal, EcalPreshower);
 
     // Parameters for the position calculation:
     PositionCalc posCalculator_ = PositionCalc(posCalcParameters_);
 
     std::map<DetId, EcalRecHit> recHitsEB_map;
 
     std::vector<EcalRecHit> seeds;
     std::vector<EBDetId> usedXtals;
     seeds.clear();
     usedXtals.clear();
 
     int nClus = 0;
     std::vector<float> eClus;
     std::vector<float> etClus;
     std::vector<float> etaClus;
     std::vector<float> phiClus;
     std::vector<EBDetId> max_hit;
     std::vector<std::vector<EcalRecHit> > RecHitsCluster;
     std::vector<float> s4s9Clus;
 
     // Find cluster seeds in EB
     for (auto const& hit : hits) {
       EBDetId id(hit.id());
       double energy = hit.energy();
       if (energy > seleXtalMinEnergy_) {
         std::pair<DetId, EcalRecHit> map_entry(hit.id(), hit);
         recHitsEB_map.insert(map_entry);
       }
       if (energy > clusSeedThr_)
         seeds.push_back(hit);
     }  // EB rechits
 
     sort(seeds.begin(), seeds.end(), [](auto& x, auto& y) { return (x.energy() > y.energy()); });
     for (auto const& seed : seeds) {
       EBDetId seed_id = seed.id();
 
       bool seedAlreadyUsed = false;
       for (auto const& usedIds : usedXtals) {
         if (usedIds == seed_id) {
           seedAlreadyUsed = true;
           break;
         }
       }
       if (seedAlreadyUsed)
         continue;
       topology_p = GetTopology()->getSubdetectorTopology(DetId::Ecal, EcalBarrel);
       std::vector<DetId> clus_v = topology_p->getWindow(seed_id, clusEtaSize_, clusPhiSize_);
       std::vector<std::pair<DetId, float> > clus_used;
 
       std::vector<EcalRecHit> RecHitsInWindow;
 
       double simple_energy = 0;
 
       for (auto const& det : clus_v) {
         bool HitAlreadyUsed = false;
         for (auto const& usedIds : usedXtals) {
           if (usedIds == det) {
             HitAlreadyUsed = true;
             break;
           }
         }
         if (HitAlreadyUsed)
           continue;
         if (recHitsEB_map.find(det) != recHitsEB_map.end()) {
           std::map<DetId, EcalRecHit>::iterator aHit;
           aHit = recHitsEB_map.find(det);
           usedXtals.push_back(det);
           RecHitsInWindow.push_back(aHit->second);
           clus_used.push_back(std::pair<DetId, float>(det, 1.));
           simple_energy = simple_energy + aHit->second.energy();
         }
       }
 
       math::XYZPoint clus_pos = posCalculator_.Calculate_Location(clus_used, &hits, geometry_p, geometryES_p);
       float theta_s = 2. * atan(exp(-clus_pos.eta()));
       float p0x_s = simple_energy * sin(theta_s) * cos(clus_pos.phi());
       float p0y_s = simple_energy * sin(theta_s) * sin(clus_pos.phi());
       float et_s = sqrt(p0x_s * p0x_s + p0y_s * p0y_s);
 
       eClus.push_back(simple_energy);
       etClus.push_back(et_s);
       etaClus.push_back(clus_pos.eta());
       phiClus.push_back(clus_pos.phi());
       max_hit.push_back(seed_id);
       RecHitsCluster.push_back(RecHitsInWindow);
 
       // Compute S4/S9 variable
       // We are not sure to have 9 RecHits so need to check eta and phi:
       float s4s9_[4];
       for (int i = 0; i < 4; i++)
         s4s9_[i] = seed.energy();
       for (unsigned int j = 0; j < RecHitsInWindow.size(); j++) {
         if ((((EBDetId)RecHitsInWindow[j].id()).ieta() == seed_id.ieta() - 1 && seed_id.ieta() != 1) ||
             (seed_id.ieta() == 1 && (((EBDetId)RecHitsInWindow[j].id()).ieta() == seed_id.ieta() - 2))) {
           if (((EBDetId)RecHitsInWindow[j].id()).iphi() == seed_id.iphi() - 1 ||
               ((EBDetId)RecHitsInWindow[j].id()).iphi() - 360 == seed_id.iphi() - 1) {
             s4s9_[0] += RecHitsInWindow[j].energy();
           } else {
             if (((EBDetId)RecHitsInWindow[j].id()).iphi() == seed_id.iphi()) {
               s4s9_[0] += RecHitsInWindow[j].energy();
               s4s9_[1] += RecHitsInWindow[j].energy();
             } else {
               if (((EBDetId)RecHitsInWindow[j].id()).iphi() == seed_id.iphi() + 1 ||
                   ((EBDetId)RecHitsInWindow[j].id()).iphi() - 360 == seed_id.iphi() + 1) {
                 s4s9_[1] += RecHitsInWindow[j].energy();
               }
             }
           }
         } else {
           if (((EBDetId)RecHitsInWindow[j].id()).ieta() == seed_id.ieta()) {
             if (((EBDetId)RecHitsInWindow[j].id()).iphi() == seed_id.iphi() - 1 ||
                 ((EBDetId)RecHitsInWindow[j].id()).iphi() - 360 == seed_id.iphi() - 1) {
               s4s9_[0] += RecHitsInWindow[j].energy();
               s4s9_[3] += RecHitsInWindow[j].energy();
             } else {
               if (((EBDetId)RecHitsInWindow[j].id()).iphi() == seed_id.iphi() + 1 ||
                   ((EBDetId)RecHitsInWindow[j].id()).iphi() - 360 == seed_id.iphi() + 1) {
                 s4s9_[1] += RecHitsInWindow[j].energy();
                 s4s9_[2] += RecHitsInWindow[j].energy();
               }
             }
           } else {
             if ((((EBDetId)RecHitsInWindow[j].id()).ieta() == seed_id.ieta() + 1 && seed_id.ieta() != -1) ||
                 (seed_id.ieta() == -1 && (((EBDetId)RecHitsInWindow[j].id()).ieta() == seed_id.ieta() + 2))) {
               if (((EBDetId)RecHitsInWindow[j].id()).iphi() == seed_id.iphi() - 1 ||
                   ((EBDetId)RecHitsInWindow[j].id()).iphi() - 360 == seed_id.iphi() - 1) {
                 s4s9_[3] += RecHitsInWindow[j].energy();
               } else {
                 if (((EBDetId)RecHitsInWindow[j].id()).iphi() == seed_id.iphi()) {
                   s4s9_[2] += RecHitsInWindow[j].energy();
                   s4s9_[3] += RecHitsInWindow[j].energy();
                 } else {
                   if (((EBDetId)RecHitsInWindow[j].id()).iphi() == seed_id.iphi() + 1 ||
                       ((EBDetId)RecHitsInWindow[j].id()).iphi() - 360 == seed_id.iphi() + 1) {
                     s4s9_[2] += RecHitsInWindow[j].energy();
                   }
                 }
               }
             } else {
               edm::LogWarning("EcalDQM") << " (EBDetId)RecHitsInWindow[j].id()).ieta() "
                                          << ((EBDetId)RecHitsInWindow[j].id()).ieta() << " seed_id.ieta() "
                                          << seed_id.ieta() << "\n"
                                          << " Problem with S4 calculation\n";
               return;
             }
           }
         }
       }
       s4s9Clus.push_back(*std::max_element(s4s9_, s4s9_ + 4) / simple_energy);
       nClus++;
       if (nClus == MAXCLUS)
         return;
     }  //  End loop over seed clusters
 
     // Selection, based on simple clustering
     // pi0 candidates
     int npi0_s = 0;
 
     std::vector<EBDetId> scXtals;
     scXtals.clear();
 
     if (nClus <= 1)
       return;
     for (Int_t i = 0; i < nClus; i++) {
       for (Int_t j = i + 1; j < nClus; j++) {
         if (etClus[i] > selePtGammaOne_ && etClus[j] > selePtGammaTwo_ && s4s9Clus[i] > seleS4S9GammaOne_ &&
             s4s9Clus[j] > seleS4S9GammaTwo_) {
           float theta_0 = 2. * atan(exp(-etaClus[i]));
           float theta_1 = 2. * atan(exp(-etaClus[j]));
 
           float p0x = eClus[i] * sin(theta_0) * cos(phiClus[i]);
           float p1x = eClus[j] * sin(theta_1) * cos(phiClus[j]);
           float p0y = eClus[i] * sin(theta_0) * sin(phiClus[i]);
           float p1y = eClus[j] * sin(theta_1) * sin(phiClus[j]);
           float p0z = eClus[i] * cos(theta_0);
           float p1z = eClus[j] * cos(theta_1);
 
           float pt_pi0 = sqrt((p0x + p1x) * (p0x + p1x) + (p0y + p1y) * (p0y + p1y));
           if (pt_pi0 < selePtPi0_)
             continue;
           float m_inv = sqrt((eClus[i] + eClus[j]) * (eClus[i] + eClus[j]) - (p0x + p1x) * (p0x + p1x) -
                              (p0y + p1y) * (p0y + p1y) - (p0z + p1z) * (p0z + p1z));
           if ((m_inv < seleMinvMaxPi0_) && (m_inv > seleMinvMinPi0_)) {
             // New Loop on cluster to measure isolation:
             std::vector<int> IsoClus;
             IsoClus.clear();
             float Iso = 0;
             TVector3 pi0vect = TVector3((p0x + p1x), (p0y + p1y), (p0z + p1z));
             for (Int_t k = 0; k < nClus; k++) {
               if (k == i || k == j)
                 continue;
               TVector3 Clusvect = TVector3(eClus[k] * sin(2. * atan(exp(-etaClus[k]))) * cos(phiClus[k]),
                                            eClus[k] * sin(2. * atan(exp(-etaClus[k]))) * sin(phiClus[k]),
                                            eClus[k] * cos(2. * atan(exp(-etaClus[k]))));
               float dretaclpi0 = fabs(etaClus[k] - pi0vect.Eta());
               float drclpi0 = Clusvect.DeltaR(pi0vect);
 
               if ((drclpi0 < selePi0BeltDR_) && (dretaclpi0 < selePi0BeltDeta_)) {
                 Iso = Iso + etClus[k];
                 IsoClus.push_back(k);
               }
             }
 
             if (Iso / pt_pi0 < selePi0Iso_) {
               mePi0MinvEB.fill(getEcalDQMSetupObjects(), m_inv);
               mePi0Pt1EB.fill(getEcalDQMSetupObjects(), etClus[i]);
               mePi0Pt2EB.fill(getEcalDQMSetupObjects(), etClus[j]);
               mePi0PtEB.fill(getEcalDQMSetupObjects(), pt_pi0);
               mePi0IsoEB.fill(getEcalDQMSetupObjects(), Iso / pt_pi0);
 
               npi0_s++;
             }
 
             if (npi0_s == MAXPI0S)
               return;
           }  // pi0 inv mass window
         }    // pt and S4S9 cut
       }      // cluster "j" index loop
     }        // cluster "i" index loop
   }          // runonEBRecHits()

◆ setParams()

void ecaldqm::PiZeroTask::setParams ( edm::ParameterSet const & params )

overrideprivatevirtual

Reimplemented from ecaldqm::DQWorker.

Definition at line 22 of file PiZeroTask.cc.

References clusEtaSize_, clusPhiSize_, clusSeedThr_, submitPVValidationJobs::params, posCalcParameters_, seleMinvMaxPi0_, seleMinvMinPi0_, selePi0BeltDeta_, selePi0BeltDR_, selePi0Iso_, selePtGammaOne_, selePtGammaTwo_, selePtPi0_, seleS4S9GammaOne_, seleS4S9GammaTwo_, and seleXtalMinEnergy_.

                                                           {
     // Parameters needed for pi0 finding
     seleXtalMinEnergy_ = params.getParameter<double>("seleXtalMinEnergy");
 
     clusSeedThr_ = params.getParameter<double>("clusSeedThr");
     clusEtaSize_ = params.getParameter<int>("clusEtaSize");
     clusPhiSize_ = params.getParameter<int>("clusPhiSize");
 
     selePtGammaOne_ = params.getParameter<double>("selePtGammaOne");
     selePtGammaTwo_ = params.getParameter<double>("selePtGammaTwo");
     seleS4S9GammaOne_ = params.getParameter<double>("seleS4S9GammaOne");
     seleS4S9GammaTwo_ = params.getParameter<double>("seleS4S9GammaTwo");
     selePtPi0_ = params.getParameter<double>("selePtPi0");
     selePi0Iso_ = params.getParameter<double>("selePi0Iso");
     selePi0BeltDR_ = params.getParameter<double>("selePi0BeltDR");
     selePi0BeltDeta_ = params.getParameter<double>("selePi0BeltDeta");
     seleMinvMaxPi0_ = params.getParameter<double>("seleMinvMaxPi0");
     seleMinvMinPi0_ = params.getParameter<double>("seleMinvMinPi0");
 
     posCalcParameters_ = params.getParameter<edm::ParameterSet>("posCalcParameters");
   }