#include <RecoLocalCalo/HcalRecProducers/src/HFPhase1Reconstructor.cc>

Inheritance diagram for HFPhase1Reconstructor:

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

	~HFPhase1Reconstructor ()

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

Public Member Functions inherited from edm::stream::EDProducerBase
	EDProducerBase ()

ModuleDescription const &	moduleDescription () const

virtual	~EDProducerBase ()

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

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)

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

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Private Member Functions
virtual void	beginRun (const edm::Run &, const edm::EventSetup &) override

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

Private Attributes
std::string	algoConfigClass_

bool	checkChannelQualityForDepth3and4_

std::unique_ptr< HcalHF_PETalgorithm >	hfPET_

std::unique_ptr< HcalHF_S9S1algorithm >	hfS8S1_

std::unique_ptr< HcalHF_S9S1algorithm >	hfS9S1_

std::unique_ptr< AbsHFPhase1Algo >	reco_

std::unique_ptr< AbsHcalAlgoData >	recoConfig_

bool	setNoiseFlags_

edm::EDGetTokenT< HFPreRecHitCollection >	tok_PreRecHit_

bool	useChannelQualityFromDB_

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

typedef CacheTypes::GlobalCache	GlobalCache

typedef AbilityChecker< T... >	HasAbility

typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache

typedef LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext

typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache

typedef CacheTypes::RunCache	RunCache

typedef RunContextT< RunCache, GlobalCache >	RunContext

typedef CacheTypes::RunSummaryCache	RunSummaryCache

Public Types inherited from edm::stream::EDProducerBase
typedef EDProducerAdaptorBase	ModuleType

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

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

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: Phase 1 HF reco with QIE 10 and split-anode readout

Implementation: [Notes on implementation]

Definition at line 53 of file HFPhase1Reconstructor.cc.

Constructor & Destructor Documentation

HFPhase1Reconstructor::HFPhase1Reconstructor ( const edm::ParameterSet & conf )

explicit

Definition at line 85 of file HFPhase1Reconstructor.cc.

References edm::ParameterSet::getParameter(), hfPET_, hfS8S1_, hfS9S1_, reco_, setNoiseFlags_, and tok_PreRecHit_.

     : algoConfigClass_(conf.getParameter<std::string>("algoConfigClass")),
       setNoiseFlags_(conf.getParameter<bool>("setNoiseFlags")),
       useChannelQualityFromDB_(conf.getParameter<bool>("useChannelQualityFromDB")),
       checkChannelQualityForDepth3and4_(conf.getParameter<bool>("checkChannelQualityForDepth3and4")),
       reco_(parseHFPhase1AlgoDescription(conf.getParameter<edm::ParameterSet>("algorithm")))
 {
     // Check that the reco algorithm has been successfully configured
     if (!reco_.get())
         throw cms::Exception("HFPhase1BadConfig")
             << "Invalid HFPhase1Reconstructor algorithm configuration"
             << std::endl;
 
     // Configure the noise cleanup algorithms
     if (setNoiseFlags_)
     {
         const edm::ParameterSet& psS9S1 = conf.getParameter<edm::ParameterSet>("S9S1stat");
         hfS9S1_ = std::make_unique<HcalHF_S9S1algorithm>(
             psS9S1.getParameter<std::vector<double> >("short_optimumSlope"),
             psS9S1.getParameter<std::vector<double> >("shortEnergyParams"),
             psS9S1.getParameter<std::vector<double> >("shortETParams"),
             psS9S1.getParameter<std::vector<double> >("long_optimumSlope"),
             psS9S1.getParameter<std::vector<double> >("longEnergyParams"),
             psS9S1.getParameter<std::vector<double> >("longETParams"),
             psS9S1.getParameter<int>("HcalAcceptSeverityLevel"),
             psS9S1.getParameter<bool>("isS8S1") );
 
         const edm::ParameterSet& psS8S1 = conf.getParameter<edm::ParameterSet>("S8S1stat");
         hfS8S1_ = std::make_unique<HcalHF_S9S1algorithm>(
             psS8S1.getParameter<std::vector<double> >("short_optimumSlope"),
             psS8S1.getParameter<std::vector<double> >("shortEnergyParams"),
             psS8S1.getParameter<std::vector<double> >("shortETParams"),
             psS8S1.getParameter<std::vector<double> >("long_optimumSlope"),
             psS8S1.getParameter<std::vector<double> >("longEnergyParams"),
             psS8S1.getParameter<std::vector<double> >("longETParams"),
             psS8S1.getParameter<int>("HcalAcceptSeverityLevel"),
             psS8S1.getParameter<bool>("isS8S1") );
 
         const edm::ParameterSet& psPET = conf.getParameter<edm::ParameterSet>("PETstat");
         hfPET_ = std::make_unique<HcalHF_PETalgorithm>(
             psPET.getParameter<std::vector<double> >("short_R"),
             psPET.getParameter<std::vector<double> >("shortEnergyParams"),
             psPET.getParameter<std::vector<double> >("shortETParams"),
             psPET.getParameter<std::vector<double> >("long_R"),
             psPET.getParameter<std::vector<double> >("longEnergyParams"),
             psPET.getParameter<std::vector<double> >("longETParams"),
             psPET.getParameter<int>("HcalAcceptSeverityLevel"),
             psPET.getParameter<std::vector<double> >("short_R_29"),
             psPET.getParameter<std::vector<double> >("long_R_29") );
     }
 
     // Describe consumed data
     tok_PreRecHit_ = consumes<HFPreRecHitCollection>(
         conf.getParameter<edm::InputTag>("inputLabel"));
 
     // Register the product
     produces<HFRecHitCollection>();
 }

HFPhase1Reconstructor::~HFPhase1Reconstructor ( )

Definition at line 145 of file HFPhase1Reconstructor.cc.

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

Member Function Documentation

void HFPhase1Reconstructor::beginRun	(	const edm::Run &	r,
		const edm::EventSetup &	es
	)

overrideprivatevirtual

Definition at line 155 of file HFPhase1Reconstructor.cc.

References algoConfigClass_, Exception, fetchHcalAlgoData(), reco_, and recoConfig_.

 {
     if (reco_->isConfigurable())
     {
         recoConfig_ = fetchHcalAlgoData(algoConfigClass_, es);
         if (!recoConfig_.get())
             throw cms::Exception("HFPhase1BadConfig")
                 << "Invalid HFPhase1Reconstructor \"algoConfigClass\" parameter value \""
                 << algoConfigClass_ << '"' << std::endl;
         if (!reco_->configure(recoConfig_.get()))
             throw cms::Exception("HFPhase1BadConfig")
                 << "Failed to configure HFPhase1Reconstructor algorithm from EventSetup"
                 << std::endl;
     }
 }

void HFPhase1Reconstructor::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

static

Definition at line 291 of file HFPhase1Reconstructor.cc.

References edm::ParameterSetDescription::add(), add_param_set, edm::ConfigurationDescriptions::addDefault(), electronCleaner_cfi::algorithm, DEFINE_FWK_MODULE, HcalHitReconstructor_hf_cfi::PETstat, HcalHitReconstructor_hf_cfi::S8S1stat, HcalHitReconstructor_hf_cfi::S9S1stat, and AlCaHLTBitMon_QueryRunRegistry::string.

 {
     edm::ParameterSetDescription desc;
 
     desc.add<edm::InputTag>("inputLabel");
     desc.add<std::string>("algoConfigClass");
     desc.add<bool>("setNoiseFlags");
     desc.add<bool>("useChannelQualityFromDB");
     desc.add<bool>("checkChannelQualityForDepth3and4");
 
     add_param_set(algorithm);
     add_param_set(S9S1stat);
     add_param_set(S8S1stat);
     add_param_set(PETstat);
     
     descriptions.addDefault(desc);
 }

void HFPhase1Reconstructor::produce	(	edm::Event &	e,
		const edm::EventSetup &	eventSetup
	)

overrideprivatevirtual

Definition at line 173 of file HFPhase1Reconstructor.cc.

References funct::abs(), b, edm::SortedCollection< T, SORT >::begin(), checkChannelQualityForDepth3and4_, particleFlowClusterECALTimeSelected_cfi::depth, HcalSeverityLevelComputer::dropChannel(), edm::SortedCollection< T, SORT >::end(), edm::EventSetup::get(), edm::Event::getByToken(), HcalDbService::getHcalCalibrations(), HcalChannelStatus::getValue(), HcalCondObjectContainer< Item >::getValues(), hfPET_, hfS8S1_, hfS9S1_, mps_fire::i, HFRecHit::id(), eostools::move(), AlCaHLTBitMon_ParallelJobs::p, edm::ESHandle< T >::product(), edm::Event::put(), DetId::rawId(), reco_, HcalDetId::secondAnodeId(), setNoiseFlags_, edm::SortedCollection< T, SORT >::size(), tok_PreRecHit_, and useChannelQualityFromDB_.

 {
     using namespace edm;
 
     // Fetch the calibrations
     ESHandle<HcalDbService> conditions;
     eventSetup.get<HcalDbRecord>().get(conditions);
 
     ESHandle<HcalChannelQuality> p;
     eventSetup.get<HcalChannelQualityRcd>().get("withTopo", p);
     const HcalChannelQuality* myqual = p.product();
  
     ESHandle<HcalSeverityLevelComputer> mycomputer;
     eventSetup.get<HcalSeverityLevelComputerRcd>().get(mycomputer);
     const HcalSeverityLevelComputer* mySeverity = mycomputer.product();
 
     // Get the input data
     Handle<HFPreRecHitCollection> preRecHits;
     e.getByToken(tok_PreRecHit_, preRecHits);
 
     // Create a new output collection
     std::unique_ptr<HFRecHitCollection> rec(std::make_unique<HFRecHitCollection>());
     rec->reserve(preRecHits->size());
 
     // Iterate over the input and fill the output collection
     for (HFPreRecHitCollection::const_iterator it = preRecHits->begin();
          it != preRecHits->end(); ++it)
     {
         // The check whether this PMT is single-anode one should go here.
         // Fix this piece of code if/when mixed-anode readout configurations
         // become available.
         const bool thisIsSingleAnodePMT = false;
 
         // Check if the anodes were tagged bad in the database
         bool taggedBadByDb[2] = {false, false};
         if (useChannelQualityFromDB_)
         {
             if (checkChannelQualityForDepth3and4_ && !thisIsSingleAnodePMT)
             {
                 HcalDetId anodeIds[2];
                 anodeIds[0] = it->id();
                 anodeIds[1] = anodeIds[0].secondAnodeId();
                 for (unsigned i=0; i<2; ++i)
                 {
                     const HcalChannelStatus* mydigistatus = myqual->getValues(anodeIds[i].rawId());
                     taggedBadByDb[i] = mySeverity->dropChannel(mydigistatus->getValue());
                 }
             }
             else
             {
                 const HcalChannelStatus* mydigistatus = myqual->getValues(it->id().rawId());
                 const bool b = mySeverity->dropChannel(mydigistatus->getValue());
                 taggedBadByDb[0] = b;
                 taggedBadByDb[1] = b;
             }
         }
 
         // Reconstruct the rechit
         const HFRecHit& rh = reco_->reconstruct(
             *it, conditions->getHcalCalibrations(it->id()),
             taggedBadByDb, thisIsSingleAnodePMT);
 
         // The rechit will have the id of 0 if the algorithm
         // decides that it should be dropped
         if (rh.id().rawId())
             rec->push_back(rh);
     }
 
     // At this point, the rechits contain energy, timing,
     // as well as proper auxiliary words. We do still need
     // to set certain flags using the noise cleanup algoritms.
 
     // The following flags require the full set of rechits.
     // These flags need to be set consecutively.
     if (setNoiseFlags_)
     {
         // Step 1:  Set PET flag  (short fibers of |ieta|==29)
         for (HFRecHitCollection::iterator i = rec->begin(); i != rec->end(); ++i)
         {
             int depth=i->id().depth();
             int ieta=i->id().ieta();
             // Short fibers and all channels at |ieta|=29 use PET settings in Algo 3
             if (depth==2 || abs(ieta)==29 ) 
                 hfPET_->HFSetFlagFromPET(*i, *rec, myqual, mySeverity);
         }
 
         // Step 2:  Set S8S1 flag (short fibers or |ieta|==29)
         for (HFRecHitCollection::iterator i = rec->begin(); i != rec->end(); ++i)
         {
             int depth=i->id().depth();
             int ieta=i->id().ieta();
             // Short fibers and all channels at |ieta|=29 use PET settings in Algo 3
             if (depth==2 || abs(ieta)==29 ) 
                 hfS8S1_->HFSetFlagFromS9S1(*i, *rec, myqual, mySeverity);
         }
 
         // Set 3:  Set S9S1 flag (long fibers)
         for (HFRecHitCollection::iterator i = rec->begin(); i != rec->end(); ++i)
         {
             int depth=i->id().depth();
             int ieta=i->id().ieta();
             // Short fibers and all channels at |ieta|=29 use PET settings in Algo 3
             if (depth==1 && abs(ieta)!=29 ) 
                 hfS9S1_->HFSetFlagFromS9S1(*i, *rec, myqual, mySeverity);
         }
     }
 
     // Add the output collection to the event record
     e.put(std::move(rec));
 }

Member Data Documentation

std::string HFPhase1Reconstructor::algoConfigClass_

private

Definition at line 66 of file HFPhase1Reconstructor.cc.

Referenced by beginRun().

bool HFPhase1Reconstructor::checkChannelQualityForDepth3and4_

private

Definition at line 69 of file HFPhase1Reconstructor.cc.

Referenced by produce().

std::unique_ptr<HcalHF_PETalgorithm> HFPhase1Reconstructor::hfPET_

private

Definition at line 79 of file HFPhase1Reconstructor.cc.

Referenced by HFPhase1Reconstructor(), and produce().

std::unique_ptr<HcalHF_S9S1algorithm> HFPhase1Reconstructor::hfS8S1_

private

Definition at line 78 of file HFPhase1Reconstructor.cc.

Referenced by HFPhase1Reconstructor(), and produce().

std::unique_ptr<HcalHF_S9S1algorithm> HFPhase1Reconstructor::hfS9S1_

private

Definition at line 77 of file HFPhase1Reconstructor.cc.

Referenced by HFPhase1Reconstructor(), and produce().

std::unique_ptr<AbsHFPhase1Algo> HFPhase1Reconstructor::reco_

private

Definition at line 73 of file HFPhase1Reconstructor.cc.

Referenced by beginRun(), HFPhase1Reconstructor(), and produce().

std::unique_ptr<AbsHcalAlgoData> HFPhase1Reconstructor::recoConfig_

private

Definition at line 74 of file HFPhase1Reconstructor.cc.

Referenced by beginRun().

bool HFPhase1Reconstructor::setNoiseFlags_

private

Definition at line 67 of file HFPhase1Reconstructor.cc.

Referenced by HFPhase1Reconstructor(), and produce().

edm::EDGetTokenT<HFPreRecHitCollection> HFPhase1Reconstructor::tok_PreRecHit_

private

Definition at line 72 of file HFPhase1Reconstructor.cc.

Referenced by HFPhase1Reconstructor(), and produce().

bool HFPhase1Reconstructor::useChannelQualityFromDB_

private

Definition at line 68 of file HFPhase1Reconstructor.cc.

Referenced by produce().

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation