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
bool	hasAbilityToProduceInBeginLumis () const final
bool	hasAbilityToProduceInBeginRuns () const final
bool	hasAbilityToProduceInEndLumis () const final
bool	hasAbilityToProduceInEndRuns () const final

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_
std::unique_ptr< HcalHF_PETalgorithm >	hfPET_
std::unique_ptr< HcalHF_S9S1algorithm >	hfS8S1_
std::unique_ptr< HcalHF_S9S1algorithm >	hfS9S1_
std::unique_ptr< HFStripFilter >	hfStripFilter_
std::unique_ptr< AbsHFPhase1Algo >	reco_
std::unique_ptr< AbsHcalAlgoData >	recoConfig_
bool	runHFStripFilter_
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

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 87 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>();
}

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

~HFPhase1Reconstructor()

HFPhase1Reconstructor::~HFPhase1Reconstructor ( )

override

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

beginRun()

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

overrideprivate

Definition at line 150 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 272 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 edm::ParameterSetDescription::add(), add_param_set, edm::ConfigurationDescriptions::addDefault(), HFStripFilter::fillDescription(), fillDescriptionForParseHFPhase1AlgoDescription(), HLT_2018_cff::PETstat, HLT_2018_cff::S8S1stat, HLT_2018_cff::S9S1stat, and AlCaHLTBitMon_QueryRunRegistry::string.

produce()

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

overrideprivate

Definition at line 164 of file HFPhase1Reconstructor.cc.

                                                                                {
  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);
    }
 
    // 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_, LEDCalibrationChannels::depth, HcalSeverityLevelComputer::dropChannel(), MillePedeFileConverter_cfg::e, edm::SortedCollection< T, SORT >::end(), edm::EventSetup::get(), get, HcalDbService::getHcalCalibrations(), HcalChannelStatus::getValue(), HcalCondObjectContainer< Item >::getValues(), hfPET_, hfS8S1_, hfS9S1_, hfStripFilter_, mps_fire::i, HFRecHit::id(), LEDCalibrationChannels::ieta, eostools::move(), AlCaHLTBitMon_ParallelJobs::p, edm::ESHandle< T >::product(), DetId::rawId(), reco_, runHFStripFilter_, HcalDetId::secondAnodeId(), setNoiseFlags_, 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().

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

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

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