#include <AlCaHcalNoiseProducer.h>

Inheritance diagram for AlCaHcalNoiseProducer:

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

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

	~AlCaHcalNoiseProducer ()

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

ModuleDescription const &	moduleDescription () const

virtual	~EDProducer ()

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 ()

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, std::unordered_multimap< std::string, edm::ProductResolverIndex > const &iIndicies, std::string const &moduleLabel)

virtual	~ProducerBase () noexcept(false)

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

	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 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
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

Definition at line 44 of file AlCaHcalNoiseProducer.h.

Constructor & Destructor Documentation

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

explicit

Definition at line 27 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 ( )

Definition at line 63 of file AlCaHcalNoiseProducer.cc.

64 {

65 }

Member Function Documentation

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

virtual

Definition at line 70 of file AlCaHcalNoiseProducer.cc.

References edm::SortedCollection< T, SORT >::begin(), FEDRawData::data(), data, deltaR(), PFRecoTauDiscriminationAgainstElectronDeadECAL_cfi::dR, 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.size() > 0) {
      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"); 
 }