#include <AlCaHcalNoiseProducer.h>

Inheritance diagram for AlCaHcalNoiseProducer:

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

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

	~AlCaHcalNoiseProducer () override

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

SerialTaskQueue *	globalLuminosityBlocksQueue ()

SerialTaskQueue *	globalRunsQueue ()

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)

	~ProducerBase () noexcept(false) override

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

ESProxyIndex const *	esGetTokenIndices (edm::Transition iTrans) const

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

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

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

void	updateLookup (eventsetup::ESRecordsToProxyIndices const &)

virtual	~EDConsumerBase () noexcept(false)

Private Attributes
std::vector< edm::InputTag >	ecalLabels_

double	JetHCALminEnergyFraction_

double	JetMinE_

double	MetCut_

int	nAnomalousEvents

int	nEvents

edm::EDGetTokenT< HBHERecHitCollection >	tok_hbhe_

edm::EDGetTokenT< HFRecHitCollection >	tok_hf_

edm::EDGetTokenT< HORecHitCollection >	tok_ho_

edm::EDGetTokenT< reco::CaloJetCollection >	tok_jets_

edm::EDGetTokenT< reco::CaloMETCollection >	tok_met_

edm::EDGetTokenT< EcalRecHitCollection >	tok_ps_

edm::EDGetTokenT< FEDRawDataCollection >	tok_raw_

edm::EDGetTokenT< CaloTowerCollection >	tok_tower_

std::vector< edm::EDGetTokenT< EcalRecHitCollection > >	toks_ecal_

bool	useJet_

bool	useMet_

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)

static bool	wantsGlobalLuminosityBlocks ()

static bool	wantsGlobalRuns ()

static bool	wantsStreamLuminosityBlocks ()

static bool	wantsStreamRuns ()

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 ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes ()

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)

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 42 of file AlCaHcalNoiseProducer.h.

Constructor & Destructor Documentation

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

explicit

Definition at line 25 of file AlCaHcalNoiseProducer.cc.

References ecalLabels_, edm::ParameterSet::getParameter(), mps_fire::i, JetHCALminEnergyFraction_, JetMinE_, MetCut_, tok_hbhe_, tok_hf_, tok_ho_, tok_jets_, tok_met_, tok_ps_, tok_raw_, tok_tower_, toks_ecal_, useJet_, and useMet_.

                                                                            {
   tok_jets_ = consumes<reco::CaloJetCollection>(iConfig.getParameter<edm::InputTag>("JetSource"));
   tok_met_ = consumes<reco::CaloMETCollection>(iConfig.getParameter<edm::InputTag>("MetSource"));
   tok_tower_ = consumes<CaloTowerCollection>(iConfig.getParameter<edm::InputTag>("TowerSource"));
   useMet_ = iConfig.getParameter<bool>("UseMET");
   useJet_ = iConfig.getParameter<bool>("UseJet");
   MetCut_ = iConfig.getParameter<double>("MetCut");
   JetMinE_ = iConfig.getParameter<double>("JetMinE");
   JetHCALminEnergyFraction_ = iConfig.getParameter<double>("JetHCALminEnergyFraction");
 
   tok_ho_ = consumes<HORecHitCollection>(iConfig.getParameter<edm::InputTag>("hoInput"));
   tok_hf_ = consumes<HFRecHitCollection>(iConfig.getParameter<edm::InputTag>("hfInput"));
   tok_hbhe_ = consumes<HBHERecHitCollection>(iConfig.getParameter<edm::InputTag>("hbheInput"));
   ecalLabels_ = iConfig.getParameter<std::vector<edm::InputTag> >("ecalInputs");
   tok_ps_ = consumes<EcalRecHitCollection>(iConfig.getParameter<edm::InputTag>("ecalPSInput"));
   tok_raw_ = consumes<FEDRawDataCollection>(iConfig.getParameter<edm::InputTag>("rawInput"));
 
   const unsigned nLabels = ecalLabels_.size();
   for (unsigned i = 0; i != nLabels; i++)
     toks_ecal_.push_back(consumes<EcalRecHitCollection>(ecalLabels_[i]));
 
   //register products
   produces<HBHERecHitCollection>("HBHERecHitCollectionFHN");
   produces<HORecHitCollection>("HORecHitCollectionFHN");
   produces<HFRecHitCollection>("HFRecHitCollectionFHN");
 
   produces<EcalRecHitCollection>("EcalRecHitCollectionFHN");
   produces<EcalRecHitCollection>("PSEcalRecHitCollectionFHN");
 
   produces<FEDRawDataCollection>("HcalFEDsFHN");
 }

AlCaHcalNoiseProducer::~AlCaHcalNoiseProducer ( )

override

Definition at line 57 of file AlCaHcalNoiseProducer.cc.

57 {}

Member Function Documentation

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

override

Definition at line 60 of file AlCaHcalNoiseProducer.cc.

References edm::SortedCollection< T, SORT >::begin(), FEDRawData::data(), data, boostedElectronIsolation_cff::deltaR, RecoEcal_EventContent_cff::ec, edm::SortedCollection< T, SORT >::end(), FEDRawDataCollection::FEDData(), edm::Event::getByToken(), photonIsolationHIProducer_cfi::hbhe, photonIsolationHIProducer_cfi::hf, photonIsolationHIProducer_cfi::ho, mps_fire::i, JetHCALminEnergyFraction_, JetMinE_, gen::k, FEDNumbering::MAXFEDID, FEDNumbering::MAXHCALFEDID, RazorAnalyzer::met, MetCut_, FEDNumbering::MINHCALFEDID, eostools::move(), nAnomalousEvents, nEvents, edm::Handle< T >::product(), reco::LeafCandidate::pt(), edm::SortedCollection< T, SORT >::push_back(), edm::Event::put(), rpcPointValidation_cfi::recHit, FEDRawData::resize(), FEDRawData::size(), findQualityFiles::size, tok_hbhe_, tok_hf_, tok_ho_, tok_jets_, tok_met_, tok_ps_, tok_raw_, tok_tower_, toks_ecal_, useJet_, and useMet_.

Referenced by JSONExport.JsonExport::export(), HTMLExport.HTMLExport::export(), and HTMLExport.HTMLExportStatic::export().

                                                                                  {
   bool acceptEvent = false;
 
   // filtering basing on HLTrigger/special/src/HLTHcalNoiseFilter.cc:
 
   bool isAnomalous_BasedOnMET = false;
   bool isAnomalous_BasedOnEnergyFraction = false;
 
   if (useMet_) {
     edm::Handle<reco::CaloMETCollection> metHandle;
     iEvent.getByToken(tok_met_, metHandle);
     const reco::CaloMETCollection* metCol = metHandle.product();
     const reco::CaloMET met = metCol->front();
 
     if (met.pt() > MetCut_)
       isAnomalous_BasedOnMET = true;
   }
 
   if (useJet_) {
     edm::Handle<reco::CaloJetCollection> calojetHandle;
     iEvent.getByToken(tok_jets_, calojetHandle);
 
     edm::Handle<CaloTowerCollection> towerHandle;
     iEvent.getByToken(tok_tower_, towerHandle);
 
     std::vector<CaloTower> TowerContainer;
     std::vector<reco::CaloJet> JetContainer;
     TowerContainer.clear();
     JetContainer.clear();
     CaloTower seedTower;
     nEvents++;
     for (reco::CaloJetCollection::const_iterator calojetIter = calojetHandle->begin();
          calojetIter != calojetHandle->end();
          ++calojetIter) {
       if (((calojetIter->et()) * cosh(calojetIter->eta()) > JetMinE_) &&
           (calojetIter->energyFractionHadronic() > JetHCALminEnergyFraction_)) {
         JetContainer.push_back(*calojetIter);
         double maxTowerE = 0.0;
         for (CaloTowerCollection::const_iterator kal = towerHandle->begin(); kal != towerHandle->end(); kal++) {
           double dR = deltaR((*calojetIter).eta(), (*calojetIter).phi(), (*kal).eta(), (*kal).phi());
           if ((dR < 0.50) && (kal->p() > maxTowerE)) {
             maxTowerE = kal->p();
             seedTower = *kal;
           }
         }
         TowerContainer.push_back(seedTower);
       }
     }
     if (!JetContainer.empty()) {
       nAnomalousEvents++;
       isAnomalous_BasedOnEnergyFraction = true;
     }
   }
 
   acceptEvent = ((useMet_ && isAnomalous_BasedOnMET) || (useJet_ && isAnomalous_BasedOnEnergyFraction));
 
 
   //Create empty output collections
 
   auto miniHBHERecHitCollection = std::make_unique<HBHERecHitCollection>();
   auto miniHORecHitCollection = std::make_unique<HORecHitCollection>();
   auto miniHFRecHitCollection = std::make_unique<HFRecHitCollection>();
 
   auto outputEColl = std::make_unique<EcalRecHitCollection>();
   auto outputESColl = std::make_unique<EcalRecHitCollection>();
 
   auto outputFEDs = std::make_unique<FEDRawDataCollection>();
 
   // if good event get and save all colletions
   if (acceptEvent) {
     edm::Handle<HBHERecHitCollection> hbhe;
     edm::Handle<HORecHitCollection> ho;
     edm::Handle<HFRecHitCollection> hf;
 
     iEvent.getByToken(tok_hbhe_, hbhe);
     iEvent.getByToken(tok_ho_, ho);
     iEvent.getByToken(tok_hf_, hf);
 
     edm::Handle<EcalRecHitCollection> pRecHits;
     iEvent.getByToken(tok_ps_, pRecHits);
 
     // temporary collection of EB+EE recHits
 
     auto tmpEcalRecHitCollection = std::make_unique<EcalRecHitCollection>();
 
     std::vector<edm::EDGetTokenT<EcalRecHitCollection> >::const_iterator i;
     for (i = toks_ecal_.begin(); i != toks_ecal_.end(); i++) {
       edm::Handle<EcalRecHitCollection> ec;
       iEvent.getByToken(*i, ec);
       for (EcalRecHitCollection::const_iterator recHit = (*ec).begin(); recHit != (*ec).end(); ++recHit) {
         tmpEcalRecHitCollection->push_back(*recHit);
       }
     }
 
 
     const HBHERecHitCollection Hithbhe = *(hbhe.product());
     for (HBHERecHitCollection::const_iterator hbheItr = Hithbhe.begin(); hbheItr != Hithbhe.end(); hbheItr++) {
       miniHBHERecHitCollection->push_back(*hbheItr);
     }
     const HORecHitCollection Hitho = *(ho.product());
     for (HORecHitCollection::const_iterator hoItr = Hitho.begin(); hoItr != Hitho.end(); hoItr++) {
       miniHORecHitCollection->push_back(*hoItr);
     }
 
     const HFRecHitCollection Hithf = *(hf.product());
     for (HFRecHitCollection::const_iterator hfItr = Hithf.begin(); hfItr != Hithf.end(); hfItr++) {
       miniHFRecHitCollection->push_back(*hfItr);
     }
 
     for (std::vector<EcalRecHit>::const_iterator ehit = tmpEcalRecHitCollection->begin();
          ehit != tmpEcalRecHitCollection->end();
          ehit++) {
       outputEColl->push_back(*ehit);
     }
 
     // write PS
     const EcalRecHitCollection& psrechits = *(pRecHits.product());
 
     for (EcalRecHitCollection::const_iterator i = psrechits.begin(); i != psrechits.end(); i++) {
       outputESColl->push_back(*i);
     }
 
     // get HCAL FEDs
     edm::Handle<FEDRawDataCollection> rawIn;
     iEvent.getByToken(tok_raw_, rawIn);
 
     std::vector<int> selFEDs;
     for (int i = FEDNumbering::MINHCALFEDID; i <= FEDNumbering::MAXHCALFEDID; i++) {
       selFEDs.push_back(i);
     }
 
     // Copying FEDs :
     const FEDRawDataCollection* rdc = rawIn.product();
 
     //   if ( ( rawData[i].provenance()->processName() != e.processHistory().rbegin()->processName() ) )
     //       continue ; // skip all raw collections not produced by the current process
 
     for (int j = 0; j < FEDNumbering::MAXFEDID; ++j) {
       bool rightFED = false;
       for (uint32_t k = 0; k < selFEDs.size(); k++) {
         if (j == selFEDs[k]) {
           rightFED = true;
         }
       }
       if (!rightFED)
         continue;
       const FEDRawData& fedData = rdc->FEDData(j);
       size_t size = fedData.size();
 
       if (size > 0) {
         // this fed has data -- lets copy it
         FEDRawData& fedDataProd = outputFEDs->FEDData(j);
         if (fedDataProd.size() != 0) {
           //       std::cout << " More than one FEDRawDataCollection with data in FED ";
           //       std::cout << j << " Skipping the 2nd\n";
           continue;
         }
         fedDataProd.resize(size);
         unsigned char* dataProd = fedDataProd.data();
         const unsigned char* data = fedData.data();
         for (unsigned int k = 0; k < size; ++k) {
           dataProd[k] = data[k];
         }
       }
     }
   }
 
   //Put selected information in the event
   iEvent.put(std::move(miniHBHERecHitCollection), "HBHERecHitCollectionFHN");
   iEvent.put(std::move(miniHORecHitCollection), "HORecHitCollectionFHN");
   iEvent.put(std::move(miniHFRecHitCollection), "HFRecHitCollectionFHN");
   iEvent.put(std::move(outputEColl), "EcalRecHitCollectionFHN");
   iEvent.put(std::move(outputESColl), "PSEcalRecHitCollectionFHN");
   iEvent.put(std::move(outputFEDs), "HcalFEDsFHN");
 }