#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::EDProducer
	EDProducer ()

ModuleDescription const &	moduleDescription () const

	~EDProducer () override

Public Member Functions inherited from edm::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

std::vector< edm::ProductResolverIndex > const &	indiciesForPutProducts (BranchType iBranchType) const

	ProducerBase ()

std::vector< edm::ProductResolverIndex > const &	putTokenIndexToProductResolverIndex () const

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...

void	resolvePutIndicies (BranchType iBranchType, ModuleToResolverIndicies const &iIndicies, std::string const &moduleLabel)

virtual	~ProducerBase () noexcept(false)

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

ProductResolverIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

EDConsumerBase const &	operator= (EDConsumerBase const &)=delete

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

virtual	~EDConsumerBase () noexcept(false)

Private Member Functions
void	beginJob () override

void	endJob () override

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::EDProducer
typedef EDProducer	ModuleType

Public Types inherited from edm::ProducerBase
using	ModuleToResolverIndicies = std::unordered_multimap< std::string, std::tuple< edm::TypeID const , const char , edm::ProductResolverIndex >>

typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Static Public Member Functions inherited from edm::EDProducer
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

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)

Detailed Description

Description: [one line class summary]

Implementation: [Notes on implementation]

Definition at line 46 of file CaloTowersMerger.cc.

Constructor & Destructor Documentation

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

explicit

Definition at line 77 of file CaloTowersMerger.cc.

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

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

CaloTowersMerger::~CaloTowersMerger ( )

override

Definition at line 91 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

void CaloTowersMerger::beginJob ( void )

overrideprivatevirtual

Reimplemented from edm::EDProducer.

Definition at line 171 of file CaloTowersMerger.cc.

172 {

173 }

void CaloTowersMerger::endJob ( void )

overrideprivatevirtual

Reimplemented from edm::EDProducer.

Definition at line 177 of file CaloTowersMerger.cc.

177 {

178 }

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

Definition at line 190 of file CaloTowersMerger.cc.

References CaloTower::addConstituents(), CaloTower::constituents(), DEFINE_FWK_MODULE, DetId::Ecal, CaloTower::ecalTime(), CaloTower::emEnergy(), CaloTower::emPosition(), spr::find(), CaloTower::hadEnergy(), CaloTower::hadPosition(), DetId::Hcal, CaloTower::hcalTime(), CaloTower::hottestCellE(), CaloTower::id(), CaloTower::ietaAbs(), CaloTower::numBadEcalCells(), CaloTower::numBadHcalCells(), CaloTower::numProblematicEcalCells(), CaloTower::numProblematicHcalCells(), CaloTower::numRecoveredEcalCells(), CaloTower::numRecoveredHcalCells(), CaloTower::outerEnergy(), CaloTower::p4(), CaloTower::setCaloTowerStatus(), CaloTower::setEcalTime(), CaloTower::setHcalTime(), CaloTower::setHottestCellE(), x, PV3DBase< T, PVType, FrameType >::x(), y, PV3DBase< T, PVType, FrameType >::y(), z, and PV3DBase< T, PVType, FrameType >::z().

Referenced by produce().

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

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

overrideprivate

Definition at line 106 of file CaloTowersMerger.cc.

References edm::SortedCollection< T, SORT >::begin(), edm::SortedCollection< T, SORT >::end(), extraTowerTag, spr::find(), edm::SortedCollection< T, SORT >::find(), edm::Event::getByToken(), edm::HandleBase::isValid(), mergedTower(), eostools::move(), TtSemiLepEvtBuilder_cfi::mt, convertSQLitetoXML_cfg::output, edm::Event::put(), regularTowerTag, edm::SortedCollection< T, SORT >::size(), tok_ext_, and tok_reg_.

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