#include <HFSimpleTimeCheck.h>

Inheritance diagram for HFSimpleTimeCheck:

Public Member Functions
	HFSimpleTimeCheck (const std::pair< float, float > tlimits[2], const float energyWeights[2 *HFAnodeStatus::N_POSSIBLE_STATES-1][2], unsigned soiPhase, float timeShift, float triseIfNoTDC, float tfallIfNoTDC, bool rejectAllFailures=true)

virtual bool	isConfigurable () const override

virtual HFRecHit	reconstruct (const HFPreRecHit &prehit, const HcalCalibrations &calibs, const bool flaggedBadInDB[2], bool expectSingleAnodePMT) override

bool	rejectingAllFailures () const

unsigned	soiPhase () const

float	tfallIfNoTDC () const

float	timeShift () const

float	triseIfNoTDC () const

virtual	~HFSimpleTimeCheck ()

Public Member Functions inherited from AbsHFPhase1Algo
virtual bool	configure (const AbsHcalAlgoData *)

virtual	~AbsHFPhase1Algo ()

Protected Member Functions
virtual unsigned	determineAnodeStatus (unsigned anodeNumber, const HFQIE10Info &anode, bool *isTimingReliable) const

Private Member Functions
unsigned	mapStatusIntoIndex (const unsigned states[2]) const

Private Attributes
float	energyWeights_ [2 *HFAnodeStatus::N_POSSIBLE_STATES-1][2]

bool	rejectAllFailures_

unsigned	soiPhase_

float	tfallIfNoTDC_

float	timeShift_

std::pair< float, float >	tlimits_ [2]

float	triseIfNoTDC_

Detailed Description

Definition at line 9 of file HFSimpleTimeCheck.h.

Constructor & Destructor Documentation

HFSimpleTimeCheck::HFSimpleTimeCheck	(	const std::pair< float, float >	tlimits[2],
		const float	energyWeights[2 *HFAnodeStatus::N_POSSIBLE_STATES-1][2],
		unsigned	soiPhase,
		float	timeShift,
		float	triseIfNoTDC,
		float	tfallIfNoTDC,
		bool	rejectAllFailures = `true`
	)

Definition at line 39 of file HFSimpleTimeCheck.cc.

References HFPhase1Reconstructor_cfi::energyWeights, energyWeights_, and tlimits_.

     : soiPhase_(i_soiPhase),
       timeShift_(i_timeShift),
       triseIfNoTDC_(i_triseIfNoTDC),
       tfallIfNoTDC_(i_tfallIfNoTDC),
       rejectAllFailures_(rejectAllFailures)
 {
     tlimits_[0] = tlimits[0];
     tlimits_[1] = tlimits[1];
     float* to = &energyWeights_[0][0];
     const float* from = &energyWeights[0][0];
     memcpy(to, from, sizeof(energyWeights_));
 }

virtual HFSimpleTimeCheck::~HFSimpleTimeCheck ( )

inlinevirtual

Definition at line 61 of file HFSimpleTimeCheck.h.

61 {}

Member Function Documentation

unsigned HFSimpleTimeCheck::determineAnodeStatus	(	unsigned	anodeNumber,
		const HFQIE10Info &	anode,
		bool *	isTimingReliable
	)		const

protectedvirtual

Reimplemented in HFFlexibleTimeCheck.

Definition at line 59 of file HFSimpleTimeCheck.cc.

References HFAnodeStatus::FAILED_TIMING, plotBeamSpotDB::first, HFAnodeStatus::HARDWARE_ERROR, HFQIE10Info::isDataframeOK(), HcalSpecialTimes::isSpecial(), HFAnodeStatus::OK, edm::second(), HFQIE10Info::timeRising(), timeShift_, and tlimits_.

Referenced by reconstruct(), and rejectingAllFailures().

 {
     // Check if this anode has a dataframe error
     if (!anode.isDataframeOK())
         return HFAnodeStatus::HARDWARE_ERROR;
 
     // Check the time limits
     float trise = anode.timeRising();
     const bool timeIsKnown = !HcalSpecialTimes::isSpecial(trise);
     trise += timeShift_;
     if (timeIsKnown &&
         tlimits_[ianode].first <= trise && trise <= tlimits_[ianode].second)
         return HFAnodeStatus::OK;
     else
         return HFAnodeStatus::FAILED_TIMING;
 }

virtual bool HFSimpleTimeCheck::isConfigurable ( ) const

inlineoverridevirtual

Implements AbsHFPhase1Algo.

Reimplemented in HFFlexibleTimeCheck.

Definition at line 63 of file HFSimpleTimeCheck.h.

References reconstruct().

63 {return false;}

unsigned HFSimpleTimeCheck::mapStatusIntoIndex ( const unsigned states[2] ) const

private

Definition at line 77 of file HFSimpleTimeCheck.cc.

References HFAnodeStatus::FAILED_OTHER, HFAnodeStatus::FAILED_TIMING, mps_fire::i, HFAnodeStatus::N_POSSIBLE_STATES, HFAnodeStatus::OK, and rejectAllFailures_.

Referenced by reconstruct(), and rejectingAllFailures().

 {
     unsigned eStates[2];
     eStates[0] = states[0];
     eStates[1] = states[1];
     if (!rejectAllFailures_)
         for (unsigned i=0; i<2; ++i)
             if (eStates[i] == HFAnodeStatus::FAILED_TIMING ||
                 eStates[i] == HFAnodeStatus::FAILED_OTHER)
                 eStates[i] = HFAnodeStatus::OK;
     if (eStates[0] == HFAnodeStatus::OK)
         return eStates[1];
     else if (eStates[1] == HFAnodeStatus::OK)
         return HFAnodeStatus::N_POSSIBLE_STATES + eStates[0] - 1;
     else
         return UINT_MAX;
 }

HFRecHit HFSimpleTimeCheck::reconstruct	(	const HFPreRecHit &	prehit,
		const HcalCalibrations &	calibs,
		const bool	flaggedBadInDB[2],
		bool	expectSingleAnodePMT
	)

overridevirtual

Implements AbsHFPhase1Algo.

Reimplemented in HFFlexibleTimeCheck.

Definition at line 95 of file HFSimpleTimeCheck.cc.

References determineAnodeStatus(), HFQIE10Info::energy(), energyWeights_, f, HFAnodeStatus::FAILED_TIMING, RemoveAddSevLevel::flag, HFAnodeStatus::FLAGGED_BAD, HFPreRecHit::getHFQIE10Info(), HFPreRecHit::id(), HcalSpecialTimes::isSpecial(), mapStatusIntoIndex(), HFAnodeStatus::NOT_DUAL, HFAnodeStatus::NOT_READ_OUT, HFRecHitAuxSetter::setAux(), CaloRecHit::setFlagField(), soiPhase_, tfallIfNoTDC_, HFQIE10Info::timeFalling(), HFQIE10Info::timeRising(), timeShift_, HcalPhase1FlagLabels::TimingFromTDC, triseIfNoTDC_, mitigatedMETSequence_cff::U, and create_public_lumi_plots::weights.

Referenced by isConfigurable(), and HFFlexibleTimeCheck::reconstruct().

 {
     HFRecHit rh;
 
     // Determine the status of each anode
     unsigned states[2] = {HFAnodeStatus::NOT_READ_OUT, HFAnodeStatus::NOT_READ_OUT};
     if (expectSingleAnodePMT)
         states[1] = HFAnodeStatus::NOT_DUAL;
 
     bool isTimingReliable[2] = {true, true};
     for (unsigned ianode=0; ianode<2; ++ianode)
     {
         const HFQIE10Info* anodeInfo = prehit.getHFQIE10Info(ianode);
         if (anodeInfo)
         {
             if (flaggedBadInDB[ianode])
                 states[ianode] = HFAnodeStatus::FLAGGED_BAD;
             else
                 states[ianode] = determineAnodeStatus(ianode, *anodeInfo,
                                                       &isTimingReliable[ianode]);
         }
     }
 
     // Reconstruct energy and time
     const unsigned lookupInd = mapStatusIntoIndex(states);
     if (lookupInd != UINT_MAX)
     {
         // In this scope, at least one of states[i] is HFAnodeStatus::OK
         // or was mapped into that status by "mapStatusIntoIndex" method
         //
         const float* weights = &energyWeights_[lookupInd][0];
         float energy = 0.f, tfallWeightedEnergySum = 0.f, triseWeightedEnergySum = 0.f;
         float tfallWeightedSum = 0.f, triseWeightedSum = 0.f;
         float tfallSum = 0.f, triseSum = 0.f;
         unsigned tfallCount = 0, triseCount = 0;
 
         for (unsigned ianode=0; ianode<2; ++ianode)
         {
             const HFQIE10Info* anodeInfo = prehit.getHFQIE10Info(ianode);
             if (anodeInfo && weights[ianode] > 0.f)
             {
                 const float weightedEnergy = weights[ianode]*anodeInfo->energy();
                 energy += weightedEnergy;
 
                 if (isTimingReliable[ianode] &&
                     states[ianode] != HFAnodeStatus::FAILED_TIMING)
                 {
                     float trise = anodeInfo->timeRising();
                     if (!HcalSpecialTimes::isSpecial(trise))
                     {
                         trise += timeShift_;
                         triseSum += trise;
                         ++triseCount;
                         if (weightedEnergy > 0.f)
                         {
                             triseWeightedSum += trise*weightedEnergy;
                             triseWeightedEnergySum += weightedEnergy;
                         }
                     }
 
                     float tfall = anodeInfo->timeFalling();
                     if (!HcalSpecialTimes::isSpecial(tfall))
                     {
                         tfall += timeShift_;
                         tfallSum += tfall;
                         ++tfallCount;
                         if (weightedEnergy > 0.f)
                         {
                             tfallWeightedSum += tfall*weightedEnergy;
                             tfallWeightedEnergySum += weightedEnergy;
                         }
                     }
                 }
             }
         }
 
         bool triseFromTDC = false;
         const float trise = build_rechit_time(
             triseWeightedEnergySum, triseWeightedSum, triseSum,
             triseCount, triseIfNoTDC_, &triseFromTDC);
 
         bool tfallFromTDC = false;
         const float tfall = build_rechit_time(
             tfallWeightedEnergySum, tfallWeightedSum, tfallSum,
             tfallCount, tfallIfNoTDC_, &tfallFromTDC);
 
         rh = HFRecHit(prehit.id(), energy, trise, tfall);
         HFRecHitAuxSetter::setAux(prehit, states, soiPhase_, &rh);
 
         // Set the "timing from TDC" flag
         const uint32_t flag = triseFromTDC ? 1U : 0U;
         rh.setFlagField(flag, HcalPhase1FlagLabels::TimingFromTDC);
     }
 
     return rh;
 }