#include <L1Trigger/L1GctConfigProducers/interface/L1GctConfigProducers.h>

Inheritance diagram for L1GctConfigProducers:

Public Types
using	ChanMaskReturnType = std::unique_ptr< L1GctChannelMask >

using	JfParamsReturnType = std::unique_ptr< L1GctJetFinderParams >

Public Member Functions
std::vector< double >	etToEnergyConversion (const L1CaloGeometry *geom) const
	Legacy nonsense. More...

	L1GctConfigProducers (const edm::ParameterSet &)

ChanMaskReturnType	produceChanMask (const L1GctChannelMaskRcd &)

JfParamsReturnType	produceJfParams (const L1GctJetFinderParamsRcd &)

	~L1GctConfigProducers () override

Public Member Functions inherited from edm::ESProducer
	ESProducer ()

	ESProducer (const ESProducer &)=delete

ESProxyIndex const *	getTokenIndices (unsigned int iIndex) const

ESProducer const &	operator= (const ESProducer &)=delete

template<typename Record >
void	updateFromMayConsumes (unsigned int iIndex, const Record &iRecord)

void	updateLookup (eventsetup::ESRecordsToProxyIndices const &) final

	~ESProducer () noexcept(false) override

Public Member Functions inherited from edm::ESProxyFactoryProducer
	ESProxyFactoryProducer ()

	ESProxyFactoryProducer (const ESProxyFactoryProducer &)=delete

const ESProxyFactoryProducer &	operator= (const ESProxyFactoryProducer &)=delete

	~ESProxyFactoryProducer () noexcept(false) override

Public Member Functions inherited from edm::eventsetup::DataProxyProvider
void	createKeyedProxies (EventSetupRecordKey const &key, unsigned int nConcurrentIOVs)

	DataProxyProvider ()

	DataProxyProvider (const DataProxyProvider &)=delete

const ComponentDescription &	description () const

void	fillRecordsNotAllowingConcurrentIOVs (std::set< EventSetupRecordKey > &recordsNotAllowingConcurrentIOVs) const

virtual void	initConcurrentIOVs (EventSetupRecordKey const &key, unsigned int nConcurrentIOVs)

bool	isUsingRecord (const EventSetupRecordKey &key) const

KeyedProxies &	keyedProxies (const EventSetupRecordKey &iRecordKey, unsigned int iovIndex=0)

const DataProxyProvider &	operator= (const DataProxyProvider &)=delete

void	setAppendToDataLabel (const edm::ParameterSet &)

void	setDescription (const ComponentDescription &iDescription)

std::set< EventSetupRecordKey >	usingRecords () const

virtual	~DataProxyProvider () noexcept(false)

Private Attributes
double	m_CenJetSeed

bool	m_convertToEnergy

unsigned	m_corrFunType

unsigned	m_EtaBoundry

double	m_FwdJetSeed

double	m_htJetThresh

double	m_htLsb

std::vector< std::vector< double > >	m_jetCalibFunc

unsigned	m_metEtaMask

unsigned	m_mhtEtaMask

double	m_mhtJetThresh

double	m_rgnEtLsb

std::vector< std::vector< double > >	m_tauCalibFunc

double	m_tauIsoThresh

double	m_TauJetSeed

unsigned	m_tetEtaMask

unsigned	m_thtEtaMask

Additional Inherited Members
Static Public Member Functions inherited from edm::eventsetup::DataProxyProvider
static void	prevalidate (ConfigurationDescriptions &)

Protected Types inherited from edm::ESProxyFactoryProducer
using	EventSetupRecordKey = eventsetup::EventSetupRecordKey

Protected Types inherited from edm::eventsetup::DataProxyProvider
using	KeyedProxiesVector = std::vector< std::pair< DataKey, std::shared_ptr< DataProxy > >>

Protected Member Functions inherited from edm::ESProducer
template<typename T >
auto	setWhatProduced (T iThis, const char iLabel)

template<typename T >
auto	setWhatProduced (T *iThis, const es::Label &iLabel={})

template<typename T >
auto	setWhatProduced (T *iThis, const std::string &iLabel)

template<typename T , typename TDecorator >
auto	setWhatProduced (T *iThis, const TDecorator &iDec, const es::Label &iLabel={})

template<typename T , typename TReturn , typename TRecord >
auto	setWhatProduced (T iThis, TReturn(T ::iMethod)(const TRecord &), const es::Label &iLabel={})

template<typename T , typename TReturn , typename TRecord , typename TArg >
ESConsumesCollectorT< TRecord >	setWhatProduced (T iThis, TReturn(T ::iMethod)(const TRecord &), const TArg &iDec, const es::Label &iLabel={})

Protected Member Functions inherited from edm::ESProxyFactoryProducer
template<class TFactory >
void	registerFactory (std::unique_ptr< TFactory > iFactory, const std::string &iLabel=std::string())

virtual void	registerFactoryWithKey (const EventSetupRecordKey &iRecord, std::unique_ptr< eventsetup::ProxyFactoryBase > iFactory, const std::string &iLabel=std::string())

KeyedProxiesVector	registerProxies (const EventSetupRecordKey &, unsigned int iovIndex) override

Protected Member Functions inherited from edm::eventsetup::DataProxyProvider
template<class T >
void	usingRecord ()

void	usingRecordWithKey (const EventSetupRecordKey &key)

Detailed Description

Description: <one line="" class="" summary>="">

Implementation: <Notes on="" implementation>="">

Definition at line 47 of file L1GctConfigProducers.h.

Member Typedef Documentation

◆ ChanMaskReturnType

using L1GctConfigProducers::ChanMaskReturnType = std::unique_ptr<L1GctChannelMask>

Definition at line 53 of file L1GctConfigProducers.h.

◆ JfParamsReturnType

using L1GctConfigProducers::JfParamsReturnType = std::unique_ptr<L1GctJetFinderParams>

Definition at line 52 of file L1GctConfigProducers.h.

Constructor & Destructor Documentation

◆ L1GctConfigProducers()

L1GctConfigProducers::L1GctConfigProducers ( const edm::ParameterSet & iConfig )

Definition at line 26 of file L1GctConfigProducers.cc.

     : m_rgnEtLsb(iConfig.getParameter<double>("RctRegionEtLSB")),
       m_htLsb(iConfig.getParameter<double>("GctHtLSB")),
       m_CenJetSeed(iConfig.getParameter<double>("JetFinderCentralJetSeed")),
       m_FwdJetSeed(iConfig.getParameter<double>("JetFinderForwardJetSeed")),
       m_TauJetSeed(iConfig.getParameter<double>("JetFinderCentralJetSeed")),  // no separate tau jet seed yet
       m_tauIsoThresh(iConfig.getParameter<double>("TauIsoEtThreshold")),
       m_htJetThresh(iConfig.getParameter<double>("HtJetEtThreshold")),
       m_mhtJetThresh(iConfig.getParameter<double>("MHtJetEtThreshold")),
       m_EtaBoundry(7),  // not programmable!
       m_corrFunType(0),
       m_convertToEnergy(iConfig.getParameter<bool>("ConvertEtValuesToEnergy")),
       m_jetCalibFunc(),
       m_tauCalibFunc(),
       m_metEtaMask(iConfig.getParameter<unsigned>("MEtEtaMask")),
       m_tetEtaMask(iConfig.getParameter<unsigned>("TEtEtaMask")),
       m_mhtEtaMask(iConfig.getParameter<unsigned>("MHtEtaMask")),
       m_thtEtaMask(iConfig.getParameter<unsigned>("HtEtaMask")) {
   //the following lines are needed to tell the framework what
   // data is being produced
   setWhatProduced(this, &L1GctConfigProducers::produceJfParams);
   setWhatProduced(this, &L1GctConfigProducers::produceChanMask);
  
   //now do what ever other initialization is needed
   std::string CalibStyle = iConfig.getParameter<std::string>("CalibrationStyle");
   edm::ParameterSet calibCoeffs;
  
   if (CalibStyle == "PowerSeries") {
     m_corrFunType = 1;
     calibCoeffs = iConfig.getParameter<edm::ParameterSet>("PowerSeriesCoefficients");
   }
  
   if (CalibStyle == "ORCAStyle") {
     m_corrFunType = 2;
     calibCoeffs = iConfig.getParameter<edm::ParameterSet>("OrcaStyleCoefficients");
   }
  
   if (CalibStyle == "Simple") {
     m_corrFunType = 3;
     calibCoeffs = iConfig.getParameter<edm::ParameterSet>("SimpleCoefficients");
   }
  
   if (CalibStyle == "PiecewiseCubic") {
     m_corrFunType = 4;
     calibCoeffs = iConfig.getParameter<edm::ParameterSet>("PiecewiseCubicCoefficients");
   }
  
   if (CalibStyle == "PF") {
     m_corrFunType = 5;
     calibCoeffs = iConfig.getParameter<edm::ParameterSet>("PFCoefficients");
   }
  
   // check
   if (CalibStyle != "None") {
     // Read the coefficients from file
     // coefficients for non-tau jet corrections
     for (unsigned i = 0; i < L1GctJetFinderParams::NUMBER_ETA_VALUES; ++i) {
       std::stringstream ss;
       std::string str;
       ss << "nonTauJetCalib" << i;
       ss >> str;
       m_jetCalibFunc.push_back(calibCoeffs.getParameter<std::vector<double> >(str));
     }
     // coefficients for tau jet corrections
     for (unsigned i = 0; i < L1GctJetFinderParams::N_CENTRAL_ETA_VALUES; ++i) {
       std::stringstream ss;
       std::string str;
       ss << "tauJetCalib" << i;
       ss >> str;
       m_tauCalibFunc.push_back(calibCoeffs.getParameter<std::vector<double> >(str));
     }
  
   } else {
     // No corrections to be applied
     m_corrFunType = 0;  // no correction
     // Set the vector sizes to those expected by the CalibrationFunction
     m_jetCalibFunc.resize(L1GctJetFinderParams::NUMBER_ETA_VALUES);
     m_tauCalibFunc.resize(L1GctJetFinderParams::N_CENTRAL_ETA_VALUES);
   }
  
   edm::LogWarning("L1GctConfig") << "Calibration Style option " << CalibStyle << std::endl;
 }

References edm::ParameterSet::getParameter(), mps_fire::i, m_corrFunType, m_jetCalibFunc, m_tauCalibFunc, L1GctJetFinderParams::N_CENTRAL_ETA_VALUES, L1GctJetFinderParams::NUMBER_ETA_VALUES, produceChanMask(), produceJfParams(), edm::ESProducer::setWhatProduced(), contentValuesCheck::ss, str, and AlCaHLTBitMon_QueryRunRegistry::string.

◆ ~L1GctConfigProducers()

L1GctConfigProducers::~L1GctConfigProducers ( )

override

Definition at line 109 of file L1GctConfigProducers.cc.

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

Member Function Documentation

◆ etToEnergyConversion()

std::vector< double > L1GctConfigProducers::etToEnergyConversion ( const L1CaloGeometry * geom ) const

Legacy nonsense.

Calculate Et-to-energy conversion factors for eta bins

Definition at line 161 of file L1GctConfigProducers.cc.

                                                                                              {
   //  L1CaloGeometry* geom = new L1CaloGeometry();
   std::vector<double> result;
   // Factors for central eta bins
   for (unsigned ieta = 0; ieta < 7; ieta++) {
     double bineta = geom->etaBinCenter(ieta, true);
     double factor = 0.5 * (exp(bineta) + exp(-bineta));  // Conversion from eta to cosec(theta)
     result.push_back(factor);
   }
   // Factors for forward eta bins
   for (unsigned ieta = 0; ieta < 4; ieta++) {
     double bineta = geom->etaBinCenter(ieta, false);
     double factor = 0.5 * (exp(bineta) + exp(-bineta));  // Conversion from eta to cosec(theta)
     result.push_back(factor);
   }
   return result;
 }

References JetChargeProducer_cfi::exp, DQMScaleToClient_cfi::factor, relativeConstraints::geom, LEDCalibrationChannels::ieta, and mps_fire::result.

Referenced by produceJfParams().

◆ produceChanMask()

L1GctConfigProducers::ChanMaskReturnType L1GctConfigProducers::produceChanMask ( const L1GctChannelMaskRcd & )

Definition at line 141 of file L1GctConfigProducers.cc.

                                                                                                        {
   L1GctChannelMask* mask = new L1GctChannelMask;
  
   for (unsigned ieta = 0; ieta < 22; ++ieta) {
     if (((m_metEtaMask >> ieta) & 0x1) == 1)
       mask->maskMissingEt(ieta);
     if (((m_tetEtaMask >> ieta) & 0x1) == 1)
       mask->maskTotalEt(ieta);
     if (((m_mhtEtaMask >> ieta) & 0x1) == 1)
       mask->maskMissingHt(ieta);
     if (((m_thtEtaMask >> ieta) & 0x1) == 1)
       mask->maskTotalHt(ieta);
   }
  
   return std::unique_ptr<L1GctChannelMask>(mask);
 }

References LEDCalibrationChannels::ieta, m_metEtaMask, m_mhtEtaMask, m_tetEtaMask, m_thtEtaMask, L1GctChannelMask::maskMissingEt(), L1GctChannelMask::maskMissingHt(), L1GctChannelMask::maskTotalEt(), L1GctChannelMask::maskTotalHt(), and testProducerWithPsetDescEmpty_cfi::x1.

Referenced by L1GctConfigProducers().

◆ produceJfParams()

L1GctConfigProducers::JfParamsReturnType L1GctConfigProducers::produceJfParams ( const L1GctJetFinderParamsRcd & aRcd )

Definition at line 116 of file L1GctConfigProducers.cc.

                                                                                                                 {
   // get geometry
   const L1CaloGeometryRecord& geomRcd = aRcd.getRecord<L1CaloGeometryRecord>();
   edm::ESHandle<L1CaloGeometry> geom;
   geomRcd.get(geom);
  
   // construct jet finder params object
   auto pL1GctJetFinderParams = std::make_unique<L1GctJetFinderParams>(m_rgnEtLsb,
                                                                       m_htLsb,
                                                                       m_CenJetSeed,
                                                                       m_FwdJetSeed,
                                                                       m_TauJetSeed,
                                                                       m_tauIsoThresh,
                                                                       m_htJetThresh,
                                                                       m_mhtJetThresh,
                                                                       m_EtaBoundry,
                                                                       m_corrFunType,
                                                                       m_jetCalibFunc,
                                                                       m_tauCalibFunc,
                                                                       m_convertToEnergy,
                                                                       etToEnergyConversion(geom.product()));
  
   return pL1GctJetFinderParams;
 }