Inheritance diagram for HcalTTPDigiProducer:

Public Member Functions
	HcalTTPDigiProducer (const edm::ParameterSet &ps)

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

	~HcalTTPDigiProducer () override=default

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

Private Member Functions
bool	decision (int nP, int nM, int bit)

bool	isMasked (HcalDetId id)

Private Attributes
std::string	bit_ [4]

int	calc_ [4]

int	fwAlgo_

int	id_

int	iEtaMax_

int	iEtaMin_

std::vector< unsigned int >	maskedChannels_

char	mReq_ [4]

int	nHFm_ [4]

int	nHFp_ [4]

int	nHits_ [4]

char	pmLogic_ [4]

char	pReq_ [4]

int	presamples_

int	samples_

int	SoI_

unsigned int	threshold_

edm::EDGetTokenT< HFDigiCollection >	tok_hf_

edm::ESGetToken< HcalTPGCoder, HcalTPGRecord >	tok_tpgCoder_

Static Private Attributes
static const int	inputs_ []

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

Definition at line 18 of file HcalTTPDigiProducer.cc.

Constructor & Destructor Documentation

◆ HcalTTPDigiProducer()

HcalTTPDigiProducer::HcalTTPDigiProducer ( const edm::ParameterSet & ps )

explicit

Definition at line 52 of file HcalTTPDigiProducer.cc.

References bit_, calc_, Exception, fwAlgo_, edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), mps_fire::i, id_, iEtaMax_, iEtaMin_, maskedChannels_, mReq_, nHFm_, nHFp_, nHits_, pmLogic_, pReq_, presamples_, samples_, SoI_, AlCaHLTBitMon_QueryRunRegistry::string, threshold_, tok_hf_, and tok_tpgCoder_.

                                                                   {
   tok_hf_ = consumes<HFDigiCollection>(ps.getParameter<edm::InputTag>("HFDigiCollection"));
   tok_tpgCoder_ = esConsumes<HcalTPGCoder, HcalTPGRecord>();
   maskedChannels_ = ps.getParameter<std::vector<unsigned int> >("maskedChannels");
   bit_[0] = ps.getParameter<std::string>("defTT8");
   bit_[1] = ps.getParameter<std::string>("defTT9");
   bit_[2] = ps.getParameter<std::string>("defTT10");
   bit_[3] = ps.getParameter<std::string>("defTTLocal");
 
   for (int i = 0; i < 4; i++) {
     nHits_[i] = -1;
     nHFp_[i] = -1;
     nHFm_[i] = -1;
     pReq_[i] = ' ';
     mReq_[i] = ' ';
     pmLogic_[i] = ' ';
     calc_[i] = sscanf(bit_[i].c_str(),
                       "hits>=%d:hfp%c=%d%chfm%c=%d",
                       &(nHits_[i]),
                       &(pReq_[i]),
                       &(nHFp_[i]),
                       &(pmLogic_[i]),
                       &(mReq_[i]),
                       &(nHFm_[i]));
     if (calc_[i] == 1) {
       if (nHits_[i] < 0)
         throw cms::Exception("HcalTTPDigiProducer") << "Unable to read logic for technical trigger";
     } else if (calc_[i] == 6) {
       if (nHits_[i] < 0 || nHFp_[i] < 0 || nHFm_[i] < 0)
         throw cms::Exception("HcalTTPDigiProducer") << "Unable to read logic for technical trigger";
       if ((pReq_[i] != '>' && pReq_[i] != '<') || (mReq_[i] != '>' && mReq_[i] != '<') ||
           (pmLogic_[i] != ':' && pmLogic_[i] != '|'))
         throw cms::Exception("HcalTTPDigiProducer") << "Technical Trigger logic must obey the following format:\n"
                                                        "\"hits>=[A1]:hfp[B1]=[A2][C]hfm[B2]=[A3]\",\n"
                                                        "or \"hits>=[A1]\",\n"
                                                        "with A# >= 0, B# = (</>) and C = (:/|)";
     } else {
       throw cms::Exception("HcalTTPDigiProducer") << "Unable to read logic for technical trigger";
     }
   }
 
   id_ = ps.getUntrackedParameter<int>("id", -1);
   samples_ = ps.getParameter<int>("samples");
   presamples_ = ps.getParameter<int>("presamples");
   iEtaMin_ = ps.getParameter<int>("iEtaMin");
   iEtaMax_ = ps.getParameter<int>("iEtaMax");
   threshold_ = ps.getParameter<unsigned int>("threshold");
   fwAlgo_ = ps.getParameter<int>("fwAlgorithm");
 
   SoI_ = ps.getParameter<int>("HFSoI");
 
   if (samples_ > 8) {
     samples_ = 8;
     edm::LogWarning("HcalTTPDigiProducer") << "Samples forced to maximum value of 8";
   }
   if (presamples_ - SoI_ > 0) {  // Too many presamples
     presamples_ = SoI_;
     edm::LogWarning("HcalTTPDigiProducer") << "Presamples reset to HF SoI value";
   }
 
   produces<HcalTTPDigiCollection>();
 }

◆ ~HcalTTPDigiProducer()

HcalTTPDigiProducer::~HcalTTPDigiProducer ( )

overridedefault

Member Function Documentation

◆ decision()

bool HcalTTPDigiProducer::decision	(	int	nP,
		int	nM,
		int	bit
	)

private

Definition at line 122 of file HcalTTPDigiProducer.cc.

References triggerObjects_cff::bit, calc_, mReq_, nHFm_, nHFp_, nHits_, pmLogic_, and pReq_.

Referenced by produce().

                                                           {
   bool pOK = false;
   bool mOK = false;
   if ((nP + nM) < nHits_[bit])
     return false;
   if (calc_[bit] == 1)
     return ((nP + nM) >= nHits_[bit]);
 
   if (pReq_[bit] == '>')
     pOK = (nP >= nHFp_[bit]);
   else if (pReq_[bit] == '<')
     pOK = (nP <= nHFp_[bit]);
 
   if (mReq_[bit] == '>')
     mOK = (nM >= nHFm_[bit]);
   else if (mReq_[bit] == '<')
     mOK = (nM <= nHFm_[bit]);
 
   if (pmLogic_[bit] == ':')
     return (pOK && mOK);
   else if (pmLogic_[bit] == '|')
     return (pOK || mOK);
 
   // Should not ever get here...need to create a warning message
   edm::LogWarning("HcalTTPDigiProducer") << "Trigger logic exhausted.  Returning false";
   return false;
 }

◆ isMasked()

bool HcalTTPDigiProducer::isMasked ( HcalDetId id )

private

Definition at line 115 of file HcalTTPDigiProducer.cc.

References mps_fire::i, maskedChannels_, and nano_mu_digi_cff::rawId.

Referenced by produce().

                                                {
   for (unsigned int i = 0; i < maskedChannels_.size(); i++)
     if (id.rawId() == maskedChannels_.at(i))
       return true;
   return false;
 }

◆ produce()

void HcalTTPDigiProducer::produce	(	edm::Event &	e,
		const edm::EventSetup &	c
	)

override

Definition at line 150 of file HcalTTPDigiProducer.cc.

References HcalTPGCoder::adc2Linear(), edm::SortedCollection< T, SORT >::begin(), decision(), MillePedeFileConverter_cfg::e, edm::SortedCollection< T, SORT >::end(), options_cfi::eventSetup, fwAlgo_, watchdog::group, mps_fire::i, id_, ALPAKA_ACCELERATOR_NAMESPACE::ecal::reconstruction::internal::barrel::ietaAbs(), iEtaMax_, iEtaMin_, inputs_, isMasked(), dqmiolumiharvest::j, eostools::move(), hltrates_dqm_sourceclient-live_cfg::offset, presamples_, EgammaValidation_cff::samples, samples_, HcalTTPDigi::setSample(), edm::shift, SoI_, threshold_, tok_hf_, and tok_tpgCoder_.

                                                                               {
   // Step A: Get Inputs
   edm::Handle<HFDigiCollection> hfDigiCollection;
   e.getByToken(tok_hf_, hfDigiCollection);
   edm::ESHandle<HcalTPGCoder> inputCoder = eventSetup.getHandle(tok_tpgCoder_);
 
   // Step B: Create empty output
   std::unique_ptr<HcalTTPDigiCollection> ttpResult(new HcalTTPDigiCollection());
 
   // Step C: Compute TTP inputs
   uint16_t trigInputs[40];
   int nP[8];
   int nM[8];
   for (int i = 0; i < 8; i++) {
     nP[i] = 0;
     nM[i] = 0;
     for (int j = 0; j < 5; j++)
       trigInputs[j * 8 + i] = 0;
   }
   for (HFDigiCollection::const_iterator theDigi = hfDigiCollection->begin(); theDigi != hfDigiCollection->end();
        theDigi++) {
     HcalDetId id = HcalDetId(theDigi->id());
     if (isMasked(id))
       continue;
     if (id.ietaAbs() < iEtaMin_ || id.ietaAbs() > iEtaMax_)
       continue;
 
     IntegerCaloSamples samples(id, theDigi->size());
     inputCoder->adc2Linear(*theDigi, samples);
 
     for (int relSample = -presamples_; relSample < (samples_ - presamples_); relSample++) {
       if (samples[SoI_ + relSample] >= threshold_) {
         int linSample = presamples_ + relSample;
         int offset = (-1 + id.zside()) / 2;
         int shift = inputs_[id.iphi() + offset];
         int group = 0;
         while (shift >= 16) {
           shift -= 16;
           group++;
         }
         if (!(trigInputs[(linSample * 8) + group] & (1 << shift)))
           (id.ieta() > 0) ? (nP[linSample]++) : (nM[linSample]++);
         trigInputs[(linSample * 8) + group] |= (1 << shift);
       }
     }
   }
 
   // Step D: Compute trigger decision and fill TTP digi
   uint8_t trigOutput[8];
   uint32_t algoDepBits[8];
   HcalTTPDigi ttpDigi(id_, samples_, presamples_, 0, fwAlgo_, 0);
   for (int linSample = 0; linSample < 8; linSample++) {
     trigOutput[linSample] = 0;
     algoDepBits[linSample] = 0;
     if (linSample < samples_) {
       for (int j = 0; j < 4; j++)
         trigOutput[linSample] |= (decision(nP[linSample], nM[linSample], j) << j);
       int nT = nP[linSample] + nM[linSample];
 
       // Algorithm Dependent bits for FW flavor = 1
       // NOTE: this disagrees with the fw var. names that implies (LSB) T,M,P (MSB)
       if (fwAlgo_ == 1)
         algoDepBits[linSample] = (nT & 0x7F) | ((nP[linSample] & 0x3F) << 7) | ((nM[linSample] & 0x3F) << 13);
       ttpDigi.setSample(
           (linSample - presamples_), &trigInputs[linSample * 8], algoDepBits[linSample], trigOutput[linSample]);
     }
   }
   ttpResult->push_back(ttpDigi);
 
   // Step E: Put outputs into event
   e.put(std::move(ttpResult));
 }

Member Data Documentation

◆ bit_

std::string HcalTTPDigiProducer::bit_[4]

private

Definition at line 32 of file HcalTTPDigiProducer.cc.

Referenced by HcalTTPDigiProducer().

◆ calc_

int HcalTTPDigiProducer::calc_[4]

private

Definition at line 33 of file HcalTTPDigiProducer.cc.

Referenced by decision(), and HcalTTPDigiProducer().

◆ fwAlgo_

int HcalTTPDigiProducer::fwAlgo_

private

Definition at line 37 of file HcalTTPDigiProducer.cc.

Referenced by HcalTTPDigiProducer(), and produce().

◆ id_

int HcalTTPDigiProducer::id_

private

Definition at line 36 of file HcalTTPDigiProducer.cc.

Referenced by HcalTTPDigiProducer(), and produce().

◆ iEtaMax_

int HcalTTPDigiProducer::iEtaMax_

private

Definition at line 38 of file HcalTTPDigiProducer.cc.

Referenced by HcalTTPDigiProducer(), and produce().

◆ iEtaMin_

int HcalTTPDigiProducer::iEtaMin_

private

Definition at line 38 of file HcalTTPDigiProducer.cc.

Referenced by HcalTTPDigiProducer(), and produce().

◆ inputs_

const int HcalTTPDigiProducer::inputs_

staticprivate

Initial value:

= {30, 66, 4,  44, 4,  44, 0,  68, 0,  68, 16, 48, 16, 48, 6,  46, 6,  46,
                                            2,  70, 2,  70, 18, 50, 18, 50, 12, 40, 12, 40, 8,  52, 8,  52, 20, 36,
                                            20, 36, 14, 42, 14, 42, 10, 54, 10, 54, 22, 38, 22, 38, 24, 56, 24, 56,
                                            32, 60, 32, 60, 28, 64, 28, 64, 26, 58, 26, 58, 34, 62, 34, 62, 30, 66}

Definition at line 43 of file HcalTTPDigiProducer.cc.

Referenced by produce().