#include <PhysicalEtAdder.h>

Inheritance diagram for l1t::PhysicalEtAdder:

Public Member Functions
	PhysicalEtAdder (const edm::ParameterSet &ps)

	~PhysicalEtAdder ()

Public Member Functions inherited from edm::EDProducer
	EDProducer ()

ModuleDescription const &	moduleDescription () const

virtual	~EDProducer ()

Public Member Functions inherited from edm::ProducerBase
	ProducerBase ()

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

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

virtual	~ProducerBase ()

Public Member Functions inherited from edm::EDConsumerBase
	EDConsumerBase ()

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

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

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

std::vector < ProductHolderIndexAndSkipBit > const &	itemsToGetFromEvent () const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesDependentUpon (const std::string &iProcessName, std::vector< const char * > &oModuleLabels) const

bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)

virtual	~EDConsumerBase ()

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Private Member Functions
virtual void	beginJob () override

virtual void	endJob () override

virtual void	produce (edm::Event &, const edm::EventSetup &) override

Private Attributes
edm::EDGetToken	CaloSpareToken_

edm::EDGetToken	EGammaToken_

edm::EDGetToken	EtSumToken_

edm::EDGetToken	JetToken_

edm::EDGetToken	TauToken_

Additional Inherited Members
Public Types inherited from edm::EDProducer
typedef EDProducer	ModuleType

Public Types inherited from edm::ProducerBase
typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

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

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

Definition at line 40 of file PhysicalEtAdder.h.

Constructor & Destructor Documentation

l1t::PhysicalEtAdder::PhysicalEtAdder ( const edm::ParameterSet & ps )

explicit

Definition at line 27 of file PhysicalEtAdder.cc.

References CaloSpareToken_, EGammaToken_, EtSumToken_, edm::ParameterSet::getParameter(), JetToken_, and TauToken_.

                                                              {
 
   produces<l1t::EGammaBxCollection>();
   produces<l1t::TauBxCollection>();
   produces<l1t::JetBxCollection>();
   produces<l1t::EtSumBxCollection>();
   produces<l1t::CaloSpareBxCollection>();
 
   EGammaToken_ = consumes<l1t::EGammaBxCollection>(ps.getParameter<edm::InputTag>("InputCollection"));
   TauToken_ = consumes<l1t::TauBxCollection>(ps.getParameter<edm::InputTag>("InputCollection"));
   JetToken_ = consumes<l1t::JetBxCollection>(ps.getParameter<edm::InputTag>("InputCollection"));
   EtSumToken_ = consumes<l1t::EtSumBxCollection>(ps.getParameter<edm::InputTag>("InputCollection"));
   CaloSpareToken_ = consumes<l1t::CaloSpareBxCollection>(ps.getParameter<edm::InputTag>("InputCollection"));
 }

l1t::PhysicalEtAdder::~PhysicalEtAdder ( )

Definition at line 42 of file PhysicalEtAdder.cc.

                                      {
 
 }

Member Function Documentation

void l1t::PhysicalEtAdder::beginJob ( void )

overrideprivatevirtual

Reimplemented from edm::EDProducer.

Definition at line 197 of file PhysicalEtAdder.cc.

198 {

199 }

void l1t::PhysicalEtAdder::endJob ( void )

overrideprivatevirtual

Reimplemented from edm::EDProducer.

Definition at line 203 of file PhysicalEtAdder.cc.

203 {

204 }

void l1t::PhysicalEtAdder::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

static

Definition at line 242 of file PhysicalEtAdder.cc.

References edm::ConfigurationDescriptions::addDefault(), and edm::ParameterSetDescription::setUnknown().

                                                                                {
   //The following says we do not know what parameters are allowed so do no validation
   // Please change this to state exactly what you do use, even if it is no parameters
   edm::ParameterSetDescription desc;
   desc.setUnknown();
   descriptions.addDefault(desc);
 }

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

overrideprivatevirtual

Implements edm::EDProducer.

Definition at line 48 of file PhysicalEtAdder.cc.

References eta(), edm::EventSetup::get(), edm::Event::getByToken(), getPhysicalEta(), getPhysicalPhi(), metsig::jet, p4, phi, edm::Event::put(), and metsig::tau.

 {
   // store new collections which include physical quantities
   std::auto_ptr<l1t::EGammaBxCollection> new_egammas (new l1t::EGammaBxCollection);
   std::auto_ptr<l1t::TauBxCollection> new_taus (new l1t::TauBxCollection);
   std::auto_ptr<l1t::JetBxCollection> new_jets (new l1t::JetBxCollection);
   std::auto_ptr<l1t::EtSumBxCollection> new_etsums (new l1t::EtSumBxCollection);
   std::auto_ptr<l1t::CaloSpareBxCollection> new_calospares (new l1t::CaloSpareBxCollection);
 
   edm::Handle<l1t::EGammaBxCollection> old_egammas;
   edm::Handle<l1t::TauBxCollection> old_taus;
   edm::Handle<l1t::JetBxCollection> old_jets;
   edm::Handle<l1t::EtSumBxCollection> old_etsums;
   edm::Handle<l1t::CaloSpareBxCollection> old_calospares;
 
   iEvent.getByToken(EGammaToken_, old_egammas);
   iEvent.getByToken(TauToken_, old_taus);
   iEvent.getByToken(JetToken_, old_jets);
   iEvent.getByToken(EtSumToken_, old_etsums);
   iEvent.getByToken(CaloSpareToken_, old_calospares);
 
   //get the proper scales for conversion to physical et
   edm::ESHandle< L1CaloEtScale > emScale ;
   iSetup.get< L1EmEtScaleRcd >().get( emScale ) ;
 
   edm::ESHandle< L1CaloEtScale > jetScale ;
   iSetup.get< L1JetEtScaleRcd >().get( jetScale ) ;
 
   edm::ESHandle< L1CaloEtScale > htMissScale ;
   iSetup.get< L1HtMissScaleRcd >().get( htMissScale ) ;
 
   int firstBX = old_egammas->getFirstBX();
   int lastBX = old_egammas->getLastBX();
 
   new_egammas->setBXRange(firstBX, lastBX);
   new_taus->setBXRange(firstBX, lastBX);
   new_jets->setBXRange(firstBX, lastBX);
   new_taus->setBXRange(firstBX, lastBX);
   new_calospares->setBXRange(firstBX, lastBX);
 
   for(int bx = firstBX; bx <= lastBX; ++bx)
   {
     for(l1t::EGammaBxCollection::const_iterator itEGamma = old_egammas->begin(bx);
     itEGamma != old_egammas->end(bx); ++itEGamma)
     {
       //const double pt = itEGamma->hwPt() * emScale->linearLsb();
       const double et = emScale->et( itEGamma->hwPt() );
       const double eta = getPhysicalEta(itEGamma->hwEta());
       const double phi = getPhysicalPhi(itEGamma->hwPhi());
       math::PtEtaPhiMLorentzVector p4(et, eta, phi, 0);
 
       l1t::EGamma eg(*&p4, itEGamma->hwPt(),
              itEGamma->hwEta(), itEGamma->hwPhi(),
              itEGamma->hwQual(), itEGamma->hwIso());
       new_egammas->push_back(bx, *&eg);
 
 
     }
 
     for(l1t::TauBxCollection::const_iterator itTau = old_taus->begin(bx);
     itTau != old_taus->end(bx); ++itTau)
     {
       // use the full-circle conversion to match l1extra, accounts for linearLsb and max value automatically
       //const uint16_t rankPt = jetScale->rank((uint16_t)itTau->hwPt());
       //const double et = jetScale->et( rankPt ) ;
 
       // or use the emScale to get finer-grained et
       //const double et = itTau->hwPt() * emScale->linearLsb();
 
       // we are now already in the rankPt
       const double et = jetScale->et( itTau->hwPt() );
 
       const double eta = getPhysicalEta(itTau->hwEta());
       const double phi = getPhysicalPhi(itTau->hwPhi());
       math::PtEtaPhiMLorentzVector p4(et, eta, phi, 0);
 
       l1t::Tau tau(*&p4, itTau->hwPt(),
            itTau->hwEta(), itTau->hwPhi(),
            itTau->hwQual(), itTau->hwIso());
       new_taus->push_back(bx, *&tau);
 
     }
 
     for(l1t::JetBxCollection::const_iterator itJet = old_jets->begin(bx);
     itJet != old_jets->end(bx); ++itJet)
     {
       // use the full-circle conversion to match l1extra, accounts for linearLsb and max value automatically
       //const uint16_t rankPt = jetScale->rank((uint16_t)itJet->hwPt());
       //const double et = jetScale->et( rankPt ) ;
 
       // or use the emScale to get finer-grained et
       //const double et = itJet->hwPt() * emScale->linearLsb();
 
       // we are now already in the rankPt
       const double et = jetScale->et( itJet->hwPt() );
 
       const bool forward = ((itJet->hwQual() & 0x2) != 0);
       const double eta = getPhysicalEta(itJet->hwEta(), forward);
       const double phi = getPhysicalPhi(itJet->hwPhi());
       math::PtEtaPhiMLorentzVector p4(et, eta, phi, 0);
 
       l1t::Jet jet(*&p4, itJet->hwPt(),
            itJet->hwEta(), itJet->hwPhi(),
            itJet->hwQual());
       new_jets->push_back(bx, *&jet);
 
     }
 
     for(l1t::EtSumBxCollection::const_iterator itEtSum = old_etsums->begin(bx);
     itEtSum != old_etsums->end(bx); ++itEtSum)
     {
       double et = itEtSum->hwPt() * emScale->linearLsb();
       //hack while we figure out the right scales
       //double et = emScale->et( itEtSum->hwPt() );
       const l1t::EtSum::EtSumType sumType = itEtSum->getType();
       if(sumType == EtSum::EtSumType::kMissingHt)
     et = htMissScale->et( itEtSum->hwPt() );
 
       const double eta = getPhysicalEta(itEtSum->hwEta());
       const double phi = getPhysicalPhi(itEtSum->hwPhi());
 
       math::PtEtaPhiMLorentzVector p4(et, eta, phi, 0);
 
       l1t::EtSum eg(*&p4, sumType, itEtSum->hwPt(),
             itEtSum->hwEta(), itEtSum->hwPhi(),
             itEtSum->hwQual());
       new_etsums->push_back(bx, *&eg);
 
 
     }
 
     for(l1t::CaloSpareBxCollection::const_iterator itCaloSpare = old_calospares->begin(bx);
     itCaloSpare != old_calospares->end(bx); ++itCaloSpare)
     {
       //just pass through for now
       //a different scale is needed depending on the type
       new_calospares->push_back(bx, *itCaloSpare);
     }
   }
 
   iEvent.put(new_egammas);
   iEvent.put(new_taus);
   iEvent.put(new_jets);
   iEvent.put(new_etsums);
   iEvent.put(new_calospares);
 }