HFPhase1Reconstructor Class Reference

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

Inheritance diagram for HFPhase1Reconstructor:

Public Member Functions
	HFPhase1Reconstructor (const edm::ParameterSet &)
	~HFPhase1Reconstructor () override
Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default
	EDProducer (const EDProducer &)=delete
bool	hasAbilityToProduceInBeginLumis () const final
bool	hasAbilityToProduceInBeginProcessBlocks () const final
bool	hasAbilityToProduceInBeginRuns () const final
bool	hasAbilityToProduceInEndLumis () const final
bool	hasAbilityToProduceInEndProcessBlocks () const final
bool	hasAbilityToProduceInEndRuns () const final
const EDProducer &	operator= (const EDProducer &)=delete

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

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

Private Attributes
std::string	algoConfigClass_
bool	checkChannelQualityForDepth3and4_
edm::ESGetToken< HcalDbService, HcalDbRecord >	conditionsToken_
std::unique_ptr< HcalHF_PETalgorithm >	hfPET_
std::unique_ptr< HcalHF_S9S1algorithm >	hfS8S1_
std::unique_ptr< HcalHF_S9S1algorithm >	hfS9S1_
std::unique_ptr< HFStripFilter >	hfStripFilter_
edm::ESGetToken< HcalChannelQuality, HcalChannelQualityRcd >	qualToken_
std::unique_ptr< AbsHFPhase1Algo >	reco_
std::unique_ptr< AbsHcalAlgoData >	recoConfig_
bool	runHFStripFilter_
bool	setNoiseFlags_
edm::ESGetToken< HcalSeverityLevelComputer, HcalSeverityLevelComputerRcd >	sevToken_
edm::EDGetTokenT< HFPreRecHitCollection >	tok_PreRecHit_
bool	useChannelQualityFromDB_

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer<>
using	CacheTypes = CacheContexts< T... >
using	GlobalCache = typename CacheTypes::GlobalCache
using	HasAbility = AbilityChecker< T... >
using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache
using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache
using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >
using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache
using	RunCache = typename CacheTypes::RunCache
using	RunContext = RunContextT< RunCache, GlobalCache >
using	RunSummaryCache = typename CacheTypes::RunSummaryCache

Detailed Description

Description: Phase 1 HF reco with QIE 10 and split-anode readout

Implementation: [Notes on implementation]

Definition at line 54 of file HFPhase1Reconstructor.cc.

Constructor & Destructor Documentation

HFPhase1Reconstructor()

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

explicit

Definition at line 92 of file HFPhase1Reconstructor.cc.

    : algoConfigClass_(conf.getParameter<std::string>("algoConfigClass")),
      setNoiseFlags_(conf.getParameter<bool>("setNoiseFlags")),
      runHFStripFilter_(conf.getParameter<bool>("runHFStripFilter")),
      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"));
 
    // Configure HFStripFilter
    if (runHFStripFilter_) {
      const edm::ParameterSet& psStripFilter = conf.getParameter<edm::ParameterSet>("HFStripFilter");
      hfStripFilter_ = HFStripFilter::parseParameterSet(psStripFilter);
    }
  }
 
  // Describe consumed data
  tok_PreRecHit_ = consumes<HFPreRecHitCollection>(conf.getParameter<edm::InputTag>("inputLabel"));
 
  // Register the product
  produces<HFRecHitCollection>();
 
  // ES tokens
  conditionsToken_ = esConsumes<HcalDbService, HcalDbRecord>();
  qualToken_ = esConsumes<HcalChannelQuality, HcalChannelQualityRcd>(edm::ESInputTag("", "withTopo"));
  sevToken_ = esConsumes<HcalSeverityLevelComputer, HcalSeverityLevelComputerRcd>();
}

References conditionsToken_, edm::ParameterSet::getParameter(), hfPET_, hfS8S1_, hfS9S1_, hfStripFilter_, HFStripFilter::parseParameterSet(), qualToken_, reco_, runHFStripFilter_, setNoiseFlags_, sevToken_, and tok_PreRecHit_.

~HFPhase1Reconstructor()

HFPhase1Reconstructor::~HFPhase1Reconstructor ( )

override

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

beginRun()

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

overrideprivate

Definition at line 160 of file HFPhase1Reconstructor.cc.

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

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

fillDescriptions()

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

static

Definition at line 275 of file HFPhase1Reconstructor.cc.

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

References add_param_set, edm::ConfigurationDescriptions::addDefault(), submitPVResolutionJobs::desc, HFStripFilter::fillDescription(), fillDescriptionForParseHFPhase1AlgoDescription(), HLT_FULL_cff::PETstat, HLT_FULL_cff::S8S1stat, HLT_FULL_cff::S9S1stat, and AlCaHLTBitMon_QueryRunRegistry::string.

produce()

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

overrideprivate

Definition at line 174 of file HFPhase1Reconstructor.cc.

                                                                                {
  using namespace edm;
 
  // Fetch the calibrations
  const HcalDbService* conditions = &eventSetup.getData(conditionsToken_);
  const HcalChannelQuality* myqual = &eventSetup.getData(qualToken_);
  const HcalSeverityLevelComputer* mySeverity = &eventSetup.getData(sevToken_);
 
  // 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);
    }
 
    // Step 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);
    }
 
    // Step 4:  Run HFStripFilter if requested
    if (runHFStripFilter_)
      hfStripFilter_->runFilter(*rec, myqual);
  }
 
  // Add the output collection to the event record
  e.put(std::move(rec));
}

References funct::abs(), b, edm::SortedCollection< T, SORT >::begin(), checkChannelQualityForDepth3and4_, submitPVValidationJobs::conditions, conditionsToken_, LEDCalibrationChannels::depth, HcalSeverityLevelComputer::dropChannel(), MillePedeFileConverter_cfg::e, edm::SortedCollection< T, SORT >::end(), edm::EventSetup::getData(), HcalChannelStatus::getValue(), HcalCondObjectContainer< Item >::getValues(), hfPET_, hfS8S1_, hfS9S1_, hfStripFilter_, mps_fire::i, HFRecHit::id(), LEDCalibrationChannels::ieta, eostools::move(), qualToken_, DetId::rawId(), reco_, runHFStripFilter_, HcalDetId::secondAnodeId(), setNoiseFlags_, sevToken_, edm::SortedCollection< T, SORT >::size(), tok_PreRecHit_, and useChannelQualityFromDB_.

Member Data Documentation

algoConfigClass_

std::string HFPhase1Reconstructor::algoConfigClass_

private

Definition at line 66 of file HFPhase1Reconstructor.cc.

Referenced by beginRun().

checkChannelQualityForDepth3and4_

bool HFPhase1Reconstructor::checkChannelQualityForDepth3and4_

private

Definition at line 70 of file HFPhase1Reconstructor.cc.

Referenced by produce().

conditionsToken_

edm::ESGetToken<HcalDbService, HcalDbRecord> HFPhase1Reconstructor::conditionsToken_

private

Definition at line 84 of file HFPhase1Reconstructor.cc.

Referenced by HFPhase1Reconstructor(), and produce().

hfPET_

std::unique_ptr<HcalHF_PETalgorithm> HFPhase1Reconstructor::hfPET_

private

Definition at line 80 of file HFPhase1Reconstructor.cc.

Referenced by HFPhase1Reconstructor(), and produce().

hfS8S1_

std::unique_ptr<HcalHF_S9S1algorithm> HFPhase1Reconstructor::hfS8S1_

private

Definition at line 79 of file HFPhase1Reconstructor.cc.

Referenced by HFPhase1Reconstructor(), and produce().

hfS9S1_

std::unique_ptr<HcalHF_S9S1algorithm> HFPhase1Reconstructor::hfS9S1_

private

Definition at line 78 of file HFPhase1Reconstructor.cc.

Referenced by HFPhase1Reconstructor(), and produce().

hfStripFilter_

std::unique_ptr<HFStripFilter> HFPhase1Reconstructor::hfStripFilter_

private

Definition at line 81 of file HFPhase1Reconstructor.cc.

Referenced by HFPhase1Reconstructor(), and produce().

qualToken_

edm::ESGetToken<HcalChannelQuality, HcalChannelQualityRcd> HFPhase1Reconstructor::qualToken_

private

Definition at line 85 of file HFPhase1Reconstructor.cc.

Referenced by HFPhase1Reconstructor(), and produce().

reco_

std::unique_ptr<AbsHFPhase1Algo> HFPhase1Reconstructor::reco_

private

Definition at line 74 of file HFPhase1Reconstructor.cc.

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

recoConfig_

std::unique_ptr<AbsHcalAlgoData> HFPhase1Reconstructor::recoConfig_

private

Definition at line 75 of file HFPhase1Reconstructor.cc.

Referenced by beginRun().

runHFStripFilter_

bool HFPhase1Reconstructor::runHFStripFilter_

private

Definition at line 68 of file HFPhase1Reconstructor.cc.

Referenced by HFPhase1Reconstructor(), and produce().

setNoiseFlags_

bool HFPhase1Reconstructor::setNoiseFlags_

private

Definition at line 67 of file HFPhase1Reconstructor.cc.

Referenced by HFPhase1Reconstructor(), and produce().

sevToken_

edm::ESGetToken<HcalSeverityLevelComputer, HcalSeverityLevelComputerRcd> HFPhase1Reconstructor::sevToken_

private

Definition at line 86 of file HFPhase1Reconstructor.cc.

Referenced by HFPhase1Reconstructor(), and produce().

tok_PreRecHit_

edm::EDGetTokenT<HFPreRecHitCollection> HFPhase1Reconstructor::tok_PreRecHit_

private

Definition at line 73 of file HFPhase1Reconstructor.cc.

Referenced by HFPhase1Reconstructor(), and produce().

useChannelQualityFromDB_

bool HFPhase1Reconstructor::useChannelQualityFromDB_

private

Definition at line 69 of file HFPhase1Reconstructor.cc.

Referenced by produce().