#include <RecoLocalCalo/CaloTowersMerger/src/CaloTowersMerger.cc>

Inheritance diagram for CaloTowersMerger:

Public Member Functions
	CaloTowersMerger (const edm::ParameterSet &)

CaloTower	mergedTower (const CaloTower &t1, const CaloTower &t2)

	~CaloTowersMerger () override

Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default

	EDProducer (const EDProducer &)=delete

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

const EDProducer &	operator= (const EDProducer &)=delete

Private Member Functions
void	produce (edm::Event &, const edm::EventSetup &) override

Private Attributes
edm::InputTag	extraTowerTag

edm::InputTag	regularTowerTag

edm::EDGetTokenT< CaloTowerCollection >	tok_ext_

edm::EDGetTokenT< CaloTowerCollection >	tok_reg_

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer<>
using	CacheTypes = CacheContexts< T... >

using	GlobalCache = typename CacheTypes::GlobalCache

using	HasAbility = AbilityChecker< T... >

using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache

using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache

using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >

using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache

using	RunCache = typename CacheTypes::RunCache

using	RunContext = RunContextT< RunCache, GlobalCache >

using	RunSummaryCache = typename CacheTypes::RunSummaryCache

Detailed Description

Description: [one line class summary]

Implementation: [Notes on implementation]

Definition at line 44 of file CaloTowersMerger.cc.

Constructor & Destructor Documentation

◆ CaloTowersMerger()

CaloTowersMerger::CaloTowersMerger ( const edm::ParameterSet & iConfig )

explicit

Definition at line 72 of file CaloTowersMerger.cc.

                                                                  {
   regularTowerTag = iConfig.getParameter<edm::InputTag>("regularTowerTag");
   extraTowerTag = iConfig.getParameter<edm::InputTag>("extraTowerTag");
  
   // register for data access
   tok_reg_ = consumes<CaloTowerCollection>(regularTowerTag);
   tok_ext_ = consumes<CaloTowerCollection>(extraTowerTag);
  
   //register your products
   produces<CaloTowerCollection>();
 }

References extraTowerTag, edm::ParameterSet::getParameter(), regularTowerTag, tok_ext_, and tok_reg_.

◆ ~CaloTowersMerger()

CaloTowersMerger::~CaloTowersMerger ( )

override

Definition at line 84 of file CaloTowersMerger.cc.

                                     {
   // do anything here that needs to be done at desctruction time
   // (e.g. close files, deallocate resources etc.)
 }

Member Function Documentation

◆ mergedTower()

CaloTower CaloTowersMerger::mergedTower	(	const CaloTower &	t1,
		const CaloTower &	t2
	)

Definition at line 161 of file CaloTowersMerger.cc.

                                                                                 {
   double newOuterE = 0;
  
   // HO energies are always saved (even if useHO=false)
   // make sure there is no double counting
   // crude test if one has HO energy and the other not (possibly due to bad hit cleanup)
   // However: for |iEta|>15 E_outer has different meening:
   // it holds either the energy in the outer depths in HCAL, etc
  
   if (rt.ietaAbs() < 16 && (fabs(rt.outerEnergy() - et.outerEnergy()) < 0.00001)) {
     // there is no differnce in the store HO energies
     newOuterE = rt.outerEnergy();
   } else {
     newOuterE = rt.outerEnergy() + et.outerEnergy();
   }
  
   bool rt_hasEcalConstit = false;
   bool et_hasEcalConstit = false;
  
   bool rt_hasHcalConstit = false;
   bool et_hasHcalConstit = false;
  
   // check if there are HCAL/ECAL constituents in the towers
  
   std::vector<DetId>::const_iterator rc_begin = rt.constituents().begin();
   std::vector<DetId>::const_iterator rc_end = rt.constituents().end();
   std::vector<DetId>::const_iterator rc_it;
  
   for (rc_it = rc_begin; rc_it != rc_end; ++rc_it) {
     if (rc_it->det() == DetId::Hcal)
       rt_hasHcalConstit = true;
     break;
   }
   for (rc_it = rc_begin; rc_it != rc_end; ++rc_it) {
     if (rc_it->det() == DetId::Ecal)
       rt_hasEcalConstit = true;
     break;
   }
  
   std::vector<DetId>::const_iterator ec_begin = et.constituents().begin();
   std::vector<DetId>::const_iterator ec_end = et.constituents().end();
   std::vector<DetId>::const_iterator ec_it;
  
   for (ec_it = ec_begin; ec_it != ec_end; ++ec_it) {
     if (ec_it->det() == DetId::Hcal)
       et_hasHcalConstit = true;
     break;
   }
   for (ec_it = ec_begin; ec_it != ec_end; ++ec_it) {
     if (ec_it->det() == DetId::Ecal)
       et_hasEcalConstit = true;
     break;
   }
  
   std::vector<DetId> combinedConstituents = rt.constituents();
   for (ec_it = ec_begin; ec_it != ec_end; ++ec_it) {
     // if properly resconstructed, the only possible overlap should be for HO hits that
     // are always listed as constituents if above thereshold (old JetMET request)
     if (std::find(combinedConstituents.begin(), combinedConstituents.end(), *ec_it) == combinedConstituents.end())
       combinedConstituents.push_back(*ec_it);
   }
  
   GlobalPoint newEmPosition(0.0, 0.0, 0.0);
  
   // The following assumes the current default
   // momentum reconstruction method (1) and
   // accepted rechits with some threshod >0
  
   if (rt_hasEcalConstit && et_hasEcalConstit) {
     if (rt.emEnergy() > 0 && et.emEnergy() > 0) {
       double sumEmE = rt.emEnergy() + et.emEnergy();
  
       double x = rt.emEnergy() * rt.emPosition().x() + et.emEnergy() * et.emPosition().x();
       double y = rt.emEnergy() * rt.emPosition().y() + et.emEnergy() * et.emPosition().y();
       double z = rt.emEnergy() * rt.emPosition().z() + et.emEnergy() * et.emPosition().z();
  
       GlobalPoint weightedEmdPosition(x / sumEmE, y / sumEmE, z / sumEmE);
       newEmPosition = weightedEmdPosition;
     }
  
   } else if (rt_hasEcalConstit && !et_hasEcalConstit) {
     newEmPosition = rt.emPosition();
   } else if (!rt_hasEcalConstit && et_hasEcalConstit) {
     newEmPosition = et.emPosition();
   }
  
   GlobalPoint newHadPosition(0.0, 0.0, 0.0);
   // had positions are the same if there is at least one constituent
   if (rt_hasHcalConstit) {
     newHadPosition = rt.hadPosition();
   } else if (et_hasHcalConstit) {
     newHadPosition = et.hadPosition();
   }
  
   // MAke the new tower and set all values
  
   CaloTower mergedTower(rt.id(),
                         rt.emEnergy() + et.emEnergy(),
                         rt.hadEnergy() + et.hadEnergy(),
                         newOuterE,
                         -1,
                         -1,
                         rt.p4() + et.p4(),
                         newEmPosition,
                         newHadPosition);
  
   mergedTower.addConstituents(combinedConstituents);
  
   (rt.hottestCellE() > et.hottestCellE()) ? mergedTower.setHottestCellE(rt.hottestCellE())
                                           : mergedTower.setHottestCellE(et.hottestCellE());
  
   unsigned int numBadHcalChan = rt.numBadHcalCells() - et.numProblematicHcalCells() - rt.numRecoveredHcalCells();
   unsigned int numBadEcalChan = rt.numBadEcalCells() - et.numProblematicEcalCells() - rt.numRecoveredEcalCells();
  
   unsigned int numProbHcalChan = rt.numProblematicHcalCells() + et.numProblematicHcalCells();
   unsigned int numProbEcalChan = rt.numProblematicEcalCells() + et.numProblematicEcalCells();
  
   unsigned int numRecHcalChan = rt.numRecoveredHcalCells() + et.numRecoveredHcalCells();
   unsigned int numRecEcalChan = rt.numRecoveredEcalCells() + et.numRecoveredEcalCells();
  
   mergedTower.setCaloTowerStatus(
       numBadHcalChan, numBadEcalChan, numRecHcalChan, numRecEcalChan, numProbHcalChan, numProbEcalChan);
  
   // use timing from the good tower only (for now, in default reco we use information from good hits only)
   // time is saved as integer but returned as float in (ns)
   mergedTower.setEcalTime(int(rt.ecalTime() * 100.0 + 0.5));
   mergedTower.setHcalTime(int(rt.hcalTime() * 100.0 + 0.5));
  
   return mergedTower;
 }

References CaloTower::addConstituents(), DetId::Ecal, EgHLTOffHistBins_cfi::et, spr::find(), DetId::Hcal, hcal_runs::rt, CaloTower::setCaloTowerStatus(), CaloTower::setEcalTime(), CaloTower::setHcalTime(), CaloTower::setHottestCellE(), x, y, and z.

Referenced by produce().

◆ produce()

void CaloTowersMerger::produce	(	edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

overrideprivate

Definition at line 94 of file CaloTowersMerger.cc.

                                                                             {
   edm::Handle<CaloTowerCollection> regTower, extraTower;
  
   iEvent.getByToken(tok_reg_, regTower);
   iEvent.getByToken(tok_ext_, extraTower);
  
   if (!regTower.isValid() && !extraTower.isValid()) {
     edm::LogError("CaloTowersMerger") << "both input tag:" << regularTowerTag << " and " << extraTowerTag
                                       << " are invalid. empty merged collection";
     iEvent.put(std::make_unique<CaloTowerCollection>());
     return;
   } else if (!regTower.isValid() || !extraTower.isValid()) {
     if (!regTower.isValid() && extraTower.isValid())
       regTower = extraTower;
     iEvent.put(std::make_unique<CaloTowerCollection>(*regTower));
     return;
   } else {
     //both valid input collections: merging
     auto output = std::make_unique<CaloTowerCollection>();
     output->reserve(regTower->size() + extraTower->size());
  
     CaloTowerCollection::const_iterator rt_begin = regTower->begin();
     CaloTowerCollection::const_iterator rt_end = regTower->end();
     CaloTowerCollection::const_iterator rt_it = rt_begin;
  
     //vector of overlapping towers
     std::vector<CaloTowerCollection::const_iterator> overlappingTowers;
     overlappingTowers.reserve(extraTower->size());
  
     for (; rt_it != rt_end; ++rt_it) {
       CaloTowerCollection::const_iterator et_it = extraTower->find(rt_it->id());
       if (et_it != extraTower->end()) {
         //need to merge the components
         //FIXME
  
         //one needs to merge t1 and t2 into mergedTower
         //end FIXME
         CaloTower mt = mergedTower(*rt_it, *et_it);
  
         output->push_back(mt);
         overlappingTowers.push_back(et_it);
  
       } else {
         //just copy the regular tower over
         output->push_back(*rt_it);
       }
     }
     CaloTowerCollection::const_iterator et_begin = extraTower->begin();
     CaloTowerCollection::const_iterator et_end = extraTower->end();
     CaloTowerCollection::const_iterator et_it = et_begin;
     for (; et_it != et_end; ++et_it) {
       if (std::find(overlappingTowers.begin(), overlappingTowers.end(), et_it) == overlappingTowers.end())
         //non overlapping tower
         //copy the extra tower over
         output->push_back(*et_it);
     }
     iEvent.put(std::move(output));
   }
 }