CSCL1TPLookupTableEP Class Reference

Inheritance diagram for CSCL1TPLookupTableEP:

Public Member Functions
	CSCL1TPLookupTableEP (const edm::ParameterSet &)
std::unique_ptr< CSCL1TPLookupTableCCLUT >	produceCCLUT (const CSCL1TPLookupTableCCLUTRcd &)
std::unique_ptr< CSCL1TPLookupTableME11ILT >	produceME11ILT (const CSCL1TPLookupTableME11ILTRcd &)
std::unique_ptr< CSCL1TPLookupTableME21ILT >	produceME21ILT (const CSCL1TPLookupTableME21ILTRcd &)
	~CSCL1TPLookupTableEP () override
Public Member Functions inherited from edm::ESProducer
	ESProducer ()
	ESProducer (const ESProducer &)=delete
ESProxyIndex const *	getTokenIndices (unsigned int iIndex) const
ESRecordIndex const *	getTokenRecordIndices (unsigned int iIndex) const
bool	hasMayConsumes () const noexcept
size_t	numberOfTokenIndices (unsigned int iIndex) const
ESProducer const &	operator= (const ESProducer &)=delete
SerialTaskQueueChain &	queue ()
template<typename Record >
std::optional< std::vector< ESProxyIndex > >	updateFromMayConsumes (unsigned int iIndex, const Record &iRecord) const
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)
Public Member Functions inherited from edm::EventSetupRecordIntervalFinder
bool	concurrentFinder () const
const eventsetup::ComponentDescription &	descriptionForFinder () const
	EventSetupRecordIntervalFinder ()
	EventSetupRecordIntervalFinder (const EventSetupRecordIntervalFinder &)=delete
std::set< eventsetup::EventSetupRecordKey >	findingForRecords () const
const ValidityInterval &	findIntervalFor (const eventsetup::EventSetupRecordKey &, const IOVSyncValue &)
bool	nonconcurrentAndIOVNeedsUpdate (const eventsetup::EventSetupRecordKey &key, const IOVSyncValue &syncValue) const
const EventSetupRecordIntervalFinder &	operator= (const EventSetupRecordIntervalFinder &)=delete
void	resetInterval (const eventsetup::EventSetupRecordKey &)
void	setDescriptionForFinder (const eventsetup::ComponentDescription &iDescription)
virtual	~EventSetupRecordIntervalFinder () noexcept(false)

Protected Member Functions
void	setIntervalFor (const edm::eventsetup::EventSetupRecordKey &, const edm::IOVSyncValue &, edm::ValidityInterval &) override
Protected Member Functions inherited from edm::ESProducer
template<typename T >
auto	setWhatProduced (T *iThis, const es::Label &iLabel={})
template<typename T >
auto	setWhatProduced (T *iThis, const char *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={})
void	usesResources (std::vector< std::string > const &)
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)
Protected Member Functions inherited from edm::EventSetupRecordIntervalFinder
template<class T >
void	findingRecord ()
void	findingRecordWithKey (const eventsetup::EventSetupRecordKey &)

Private Member Functions
std::vector< unsigned >	load (std::string fileName) const

Private Attributes
const edm::ParameterSet	pset_

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 > >>

Detailed Description

Definition at line 23 of file CSCL1TPLookupTableEP.cc.

Constructor & Destructor Documentation

CSCL1TPLookupTableEP()

CSCL1TPLookupTableEP::CSCL1TPLookupTableEP

(

const edm::ParameterSet &

pset

)

Definition at line 42 of file CSCL1TPLookupTableEP.cc.

References produceCCLUT(), produceME11ILT(), produceME21ILT(), and edm::ESProducer::setWhatProduced().

                                                                      : pset_(pset) {
  setWhatProduced(this, &CSCL1TPLookupTableEP::produceCCLUT);
  setWhatProduced(this, &CSCL1TPLookupTableEP::produceME11ILT);
  setWhatProduced(this, &CSCL1TPLookupTableEP::produceME21ILT);
  findingRecord<CSCL1TPLookupTableCCLUTRcd>();
  findingRecord<CSCL1TPLookupTableME11ILTRcd>();
  findingRecord<CSCL1TPLookupTableME21ILTRcd>();
}

~CSCL1TPLookupTableEP()

CSCL1TPLookupTableEP::~CSCL1TPLookupTableEP ( )

inlineoverride

Definition at line 26 of file CSCL1TPLookupTableEP.cc.

{}

Member Function Documentation

load()

std::vector< unsigned > CSCL1TPLookupTableEP::load ( std::string  fileName ) const

private

Definition at line 265 of file CSCL1TPLookupTableEP.cc.

References mps_splice::entry, MillePedeFileConverter_cfg::fileName, spr::find(), contentValuesFiles::fullPath, mps_splice::line, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by MatrixToProcess.MatrixToProcess::getProcess(), MatrixToProcess.MatrixToProcess::listAll(), ConfigBuilder.ConfigBuilder::prepare_FILTER(), produceCCLUT(), produceME11ILT(), and produceME21ILT().

                                                                       {
  std::vector<unsigned> returnV;
  std::ifstream fstream;
  fstream.open(edm::FileInPath(fileName.c_str()).fullPath());
  // empty file, return empty lut
  if (!fstream.good()) {
    fstream.close();
    return returnV;
  }

  std::string line;

  while (std::getline(fstream, line)) {
    //ignore comments
    line.erase(std::find(line.begin(), line.end(), '#'), line.end());
    std::istringstream lineStream(line);
    std::pair<unsigned, unsigned> entry;
    while (lineStream >> entry.first >> entry.second) {
      returnV.push_back(entry.second);
    }
  }
  return returnV;
}

produceCCLUT()

std::unique_ptr< CSCL1TPLookupTableCCLUT > CSCL1TPLookupTableEP::produceCCLUT

(

const CSCL1TPLookupTableCCLUTRcd &

)

Definition at line 58 of file CSCL1TPLookupTableEP.cc.

References edm::ParameterSet::getParameter(), mps_fire::i, load(), eostools::move(), and pset_.

Referenced by CSCL1TPLookupTableEP().

                                                                                                           {
  // make the LUT object
  std::unique_ptr<CSCL1TPLookupTableCCLUT> lut = std::make_unique<CSCL1TPLookupTableCCLUT>();

  // get the text files
  std::vector<std::string> positionLUTFiles_ = pset_.getParameter<std::vector<std::string>>("positionLUTFiles");
  std::vector<std::string> slopeLUTFiles_ = pset_.getParameter<std::vector<std::string>>("slopeLUTFiles");

  std::unordered_map<unsigned, std::vector<unsigned>> cclutPosition;
  std::unordered_map<unsigned, std::vector<unsigned>> cclutSlope;

  // read the text files and extract the data
  for (int i = 0; i < 5; ++i) {
    cclutPosition[i] = load(positionLUTFiles_[i]);
    cclutSlope[i] = load(slopeLUTFiles_[i]);
  }

  // set the data in the LUT object
  lut->set_cclutPosition(std::move(cclutPosition));
  lut->set_cclutSlope(std::move(cclutSlope));

  return lut;
}

produceME11ILT()

std::unique_ptr< CSCL1TPLookupTableME11ILT > CSCL1TPLookupTableEP::produceME11ILT

(

const CSCL1TPLookupTableME11ILTRcd &

)

Definition at line 82 of file CSCL1TPLookupTableEP.cc.

References edm::ParameterSet::getParameter(), load(), eostools::move(), and pset_.

Referenced by CSCL1TPLookupTableEP().

                                                                                                                 {
  // make the LUT object
  std::unique_ptr<CSCL1TPLookupTableME11ILT> lut = std::make_unique<CSCL1TPLookupTableME11ILT>();

  // get the text files
  std::vector<std::string> padToHsME1aFiles_ = pset_.getParameter<std::vector<std::string>>("padToHsME1aFiles");
  std::vector<std::string> padToHsME1bFiles_ = pset_.getParameter<std::vector<std::string>>("padToHsME1bFiles");

  std::vector<std::string> padToEsME1aFiles_ = pset_.getParameter<std::vector<std::string>>("padToEsME1aFiles");
  std::vector<std::string> padToEsME1bFiles_ = pset_.getParameter<std::vector<std::string>>("padToEsME1bFiles");

  std::vector<std::string> rollToMaxWgME11Files_ = pset_.getParameter<std::vector<std::string>>("rollToMaxWgME11Files");
  std::vector<std::string> rollToMinWgME11Files_ = pset_.getParameter<std::vector<std::string>>("rollToMinWgME11Files");

  std::vector<std::string> gemCscSlopeCosiFiles_ = pset_.getParameter<std::vector<std::string>>("gemCscSlopeCosiFiles");
  std::vector<std::string> gemCscSlopeCosiCorrectionFiles_ =
      pset_.getParameter<std::vector<std::string>>("gemCscSlopeCosiCorrectionFiles");
  std::vector<std::string> gemCscSlopeCorrectionFiles_ =
      pset_.getParameter<std::vector<std::string>>("gemCscSlopeCorrectionFiles");

  std::vector<std::string> esDiffToSlopeME1aFiles_ =
      pset_.getParameter<std::vector<std::string>>("esDiffToSlopeME1aFiles");
  std::vector<std::string> esDiffToSlopeME1bFiles_ =
      pset_.getParameter<std::vector<std::string>>("esDiffToSlopeME1bFiles");

  // read the text files and extract the data
  auto GEM_pad_CSC_hs_ME1a_even_ = load(padToHsME1aFiles_[0]);
  auto GEM_pad_CSC_hs_ME1a_odd_ = load(padToHsME1aFiles_[1]);
  auto GEM_pad_CSC_hs_ME1b_even_ = load(padToHsME1bFiles_[0]);
  auto GEM_pad_CSC_hs_ME1b_odd_ = load(padToHsME1bFiles_[1]);

  auto GEM_pad_CSC_es_ME1a_even_ = load(padToEsME1aFiles_[0]);
  auto GEM_pad_CSC_es_ME1a_odd_ = load(padToEsME1aFiles_[1]);
  auto GEM_pad_CSC_es_ME1b_even_ = load(padToEsME1bFiles_[0]);
  auto GEM_pad_CSC_es_ME1b_odd_ = load(padToEsME1bFiles_[1]);

  auto GEM_roll_L1_CSC_min_wg_ME11_even_ = load(rollToMinWgME11Files_[0]);
  auto GEM_roll_L1_CSC_min_wg_ME11_odd_ = load(rollToMinWgME11Files_[1]);
  auto GEM_roll_L2_CSC_min_wg_ME11_even_ = load(rollToMinWgME11Files_[2]);
  auto GEM_roll_L2_CSC_min_wg_ME11_odd_ = load(rollToMinWgME11Files_[3]);

  auto GEM_roll_L1_CSC_max_wg_ME11_even_ = load(rollToMaxWgME11Files_[0]);
  auto GEM_roll_L1_CSC_max_wg_ME11_odd_ = load(rollToMaxWgME11Files_[1]);
  auto GEM_roll_L2_CSC_max_wg_ME11_even_ = load(rollToMaxWgME11Files_[2]);
  auto GEM_roll_L2_CSC_max_wg_ME11_odd_ = load(rollToMaxWgME11Files_[3]);

  auto CSC_slope_cosi_2to1_L1_ME11_even_ = load(gemCscSlopeCosiFiles_[0]);
  auto CSC_slope_cosi_2to1_L1_ME11_odd_ = load(gemCscSlopeCosiFiles_[1]);
  auto CSC_slope_cosi_3to1_L1_ME11_even_ = load(gemCscSlopeCosiFiles_[2]);
  auto CSC_slope_cosi_3to1_L1_ME11_odd_ = load(gemCscSlopeCosiFiles_[3]);

  auto CSC_slope_cosi_corr_L1_ME11_even_ = load(gemCscSlopeCosiCorrectionFiles_[0]);
  auto CSC_slope_cosi_corr_L2_ME11_even_ = load(gemCscSlopeCosiCorrectionFiles_[1]);
  auto CSC_slope_cosi_corr_L1_ME11_odd_ = load(gemCscSlopeCosiCorrectionFiles_[2]);
  auto CSC_slope_cosi_corr_L2_ME11_odd_ = load(gemCscSlopeCosiCorrectionFiles_[3]);

  auto CSC_slope_corr_L1_ME11_even_ = load(gemCscSlopeCorrectionFiles_[0]);
  auto CSC_slope_corr_L2_ME11_even_ = load(gemCscSlopeCorrectionFiles_[1]);
  auto CSC_slope_corr_L1_ME11_odd_ = load(gemCscSlopeCorrectionFiles_[2]);
  auto CSC_slope_corr_L2_ME11_odd_ = load(gemCscSlopeCorrectionFiles_[3]);

  auto es_diff_slope_L1_ME1a_even_ = load(esDiffToSlopeME1aFiles_[0]);
  auto es_diff_slope_L1_ME1a_odd_ = load(esDiffToSlopeME1aFiles_[1]);
  auto es_diff_slope_L2_ME1a_even_ = load(esDiffToSlopeME1aFiles_[2]);
  auto es_diff_slope_L2_ME1a_odd_ = load(esDiffToSlopeME1aFiles_[3]);

  auto es_diff_slope_L1_ME1b_even_ = load(esDiffToSlopeME1bFiles_[0]);
  auto es_diff_slope_L1_ME1b_odd_ = load(esDiffToSlopeME1bFiles_[1]);
  auto es_diff_slope_L2_ME1b_even_ = load(esDiffToSlopeME1bFiles_[2]);
  auto es_diff_slope_L2_ME1b_odd_ = load(esDiffToSlopeME1bFiles_[3]);

  // set the data in the LUT object
  lut->set_GEM_pad_CSC_hs_ME1b_even(std::move(GEM_pad_CSC_hs_ME1b_even_));
  lut->set_GEM_pad_CSC_hs_ME1a_even(std::move(GEM_pad_CSC_hs_ME1a_even_));
  lut->set_GEM_pad_CSC_hs_ME1b_odd(std::move(GEM_pad_CSC_hs_ME1b_odd_));
  lut->set_GEM_pad_CSC_hs_ME1a_odd(std::move(GEM_pad_CSC_hs_ME1a_odd_));

  lut->set_GEM_pad_CSC_es_ME1b_even(std::move(GEM_pad_CSC_es_ME1b_even_));
  lut->set_GEM_pad_CSC_es_ME1a_even(std::move(GEM_pad_CSC_es_ME1a_even_));
  lut->set_GEM_pad_CSC_es_ME1b_odd(std::move(GEM_pad_CSC_es_ME1b_odd_));
  lut->set_GEM_pad_CSC_es_ME1a_odd(std::move(GEM_pad_CSC_es_ME1a_odd_));

  lut->set_GEM_roll_L1_CSC_min_wg_ME11_even(std::move(GEM_roll_L1_CSC_min_wg_ME11_even_));
  lut->set_GEM_roll_L1_CSC_max_wg_ME11_even(std::move(GEM_roll_L1_CSC_max_wg_ME11_even_));
  lut->set_GEM_roll_L1_CSC_min_wg_ME11_odd(std::move(GEM_roll_L1_CSC_min_wg_ME11_odd_));
  lut->set_GEM_roll_L1_CSC_max_wg_ME11_odd(std::move(GEM_roll_L1_CSC_max_wg_ME11_odd_));

  lut->set_GEM_roll_L2_CSC_min_wg_ME11_even(std::move(GEM_roll_L2_CSC_min_wg_ME11_even_));
  lut->set_GEM_roll_L2_CSC_max_wg_ME11_even(std::move(GEM_roll_L2_CSC_max_wg_ME11_even_));
  lut->set_GEM_roll_L2_CSC_min_wg_ME11_odd(std::move(GEM_roll_L2_CSC_min_wg_ME11_odd_));
  lut->set_GEM_roll_L2_CSC_max_wg_ME11_odd(std::move(GEM_roll_L2_CSC_max_wg_ME11_odd_));

  // GEM-CSC trigger: slope correction
  lut->set_CSC_slope_cosi_2to1_L1_ME11_even(std::move(CSC_slope_cosi_2to1_L1_ME11_even_));
  lut->set_CSC_slope_cosi_2to1_L1_ME11_odd(std::move(CSC_slope_cosi_2to1_L1_ME11_odd_));
  lut->set_CSC_slope_cosi_3to1_L1_ME11_even(std::move(CSC_slope_cosi_3to1_L1_ME11_even_));
  lut->set_CSC_slope_cosi_3to1_L1_ME11_odd(std::move(CSC_slope_cosi_3to1_L1_ME11_odd_));

  lut->set_CSC_slope_cosi_corr_L1_ME11_even(std::move(CSC_slope_cosi_corr_L1_ME11_even_));
  lut->set_CSC_slope_cosi_corr_L1_ME11_odd(std::move(CSC_slope_cosi_corr_L1_ME11_odd_));
  lut->set_CSC_slope_cosi_corr_L2_ME11_even(std::move(CSC_slope_cosi_corr_L2_ME11_even_));
  lut->set_CSC_slope_cosi_corr_L2_ME11_odd(std::move(CSC_slope_cosi_corr_L2_ME11_odd_));

  lut->set_CSC_slope_corr_L1_ME11_even(std::move(CSC_slope_corr_L1_ME11_even_));
  lut->set_CSC_slope_corr_L1_ME11_odd(std::move(CSC_slope_corr_L1_ME11_odd_));
  lut->set_CSC_slope_corr_L2_ME11_even(std::move(CSC_slope_corr_L2_ME11_even_));
  lut->set_CSC_slope_corr_L2_ME11_odd(std::move(CSC_slope_corr_L2_ME11_odd_));

  // GEM-CSC trigger: 1/8-strip difference to slope
  lut->set_es_diff_slope_L1_ME1a_even(std::move(es_diff_slope_L1_ME1a_even_));
  lut->set_es_diff_slope_L2_ME1a_even(std::move(es_diff_slope_L2_ME1a_even_));
  lut->set_es_diff_slope_L1_ME1a_odd(std::move(es_diff_slope_L1_ME1a_odd_));
  lut->set_es_diff_slope_L2_ME1a_odd(std::move(es_diff_slope_L2_ME1a_odd_));

  lut->set_es_diff_slope_L1_ME1b_even(std::move(es_diff_slope_L1_ME1b_even_));
  lut->set_es_diff_slope_L2_ME1b_even(std::move(es_diff_slope_L2_ME1b_even_));
  lut->set_es_diff_slope_L1_ME1b_odd(std::move(es_diff_slope_L1_ME1b_odd_));
  lut->set_es_diff_slope_L2_ME1b_odd(std::move(es_diff_slope_L2_ME1b_odd_));

  return lut;
}

produceME21ILT()

std::unique_ptr< CSCL1TPLookupTableME21ILT > CSCL1TPLookupTableEP::produceME21ILT

(

const CSCL1TPLookupTableME21ILTRcd &

)

Definition at line 204 of file CSCL1TPLookupTableEP.cc.

References edm::ParameterSet::getParameter(), load(), eostools::move(), and pset_.

Referenced by CSCL1TPLookupTableEP().

                                                                                                                 {
  // make the LUT object
  std::unique_ptr<CSCL1TPLookupTableME21ILT> lut = std::make_unique<CSCL1TPLookupTableME21ILT>();

  // get the text files
  std::vector<std::string> padToHsME21Files_ = pset_.getParameter<std::vector<std::string>>("padToHsME21Files");
  std::vector<std::string> padToEsME21Files_ = pset_.getParameter<std::vector<std::string>>("padToEsME21Files");

  std::vector<std::string> rollToMaxWgME21Files_ = pset_.getParameter<std::vector<std::string>>("rollToMaxWgME21Files");
  std::vector<std::string> rollToMinWgME21Files_ = pset_.getParameter<std::vector<std::string>>("rollToMinWgME21Files");

  std::vector<std::string> esDiffToSlopeME21Files_ =
      pset_.getParameter<std::vector<std::string>>("esDiffToSlopeME21Files");

  // read the text files and extract the data
  auto GEM_pad_CSC_hs_ME21_even_ = load(padToHsME21Files_[0]);
  auto GEM_pad_CSC_hs_ME21_odd_ = load(padToHsME21Files_[1]);

  auto GEM_pad_CSC_es_ME21_even_ = load(padToEsME21Files_[0]);
  auto GEM_pad_CSC_es_ME21_odd_ = load(padToEsME21Files_[1]);

  auto GEM_roll_L1_CSC_min_wg_ME21_even_ = load(rollToMinWgME21Files_[0]);
  auto GEM_roll_L1_CSC_min_wg_ME21_odd_ = load(rollToMinWgME21Files_[1]);
  auto GEM_roll_L2_CSC_min_wg_ME21_even_ = load(rollToMinWgME21Files_[2]);
  auto GEM_roll_L2_CSC_min_wg_ME21_odd_ = load(rollToMinWgME21Files_[3]);

  auto GEM_roll_L1_CSC_max_wg_ME21_even_ = load(rollToMaxWgME21Files_[0]);
  auto GEM_roll_L1_CSC_max_wg_ME21_odd_ = load(rollToMaxWgME21Files_[1]);
  auto GEM_roll_L2_CSC_max_wg_ME21_even_ = load(rollToMaxWgME21Files_[2]);
  auto GEM_roll_L2_CSC_max_wg_ME21_odd_ = load(rollToMaxWgME21Files_[3]);

  auto es_diff_slope_L1_ME21_even_ = load(esDiffToSlopeME21Files_[0]);
  auto es_diff_slope_L1_ME21_odd_ = load(esDiffToSlopeME21Files_[1]);
  auto es_diff_slope_L2_ME21_even_ = load(esDiffToSlopeME21Files_[2]);
  auto es_diff_slope_L2_ME21_odd_ = load(esDiffToSlopeME21Files_[3]);

  // set the data in the LUT object
  lut->set_GEM_pad_CSC_hs_ME21_even(std::move(GEM_pad_CSC_hs_ME21_even_));
  lut->set_GEM_pad_CSC_hs_ME21_odd(std::move(GEM_pad_CSC_hs_ME21_odd_));

  lut->set_GEM_pad_CSC_es_ME21_even(std::move(GEM_pad_CSC_es_ME21_even_));
  lut->set_GEM_pad_CSC_es_ME21_odd(std::move(GEM_pad_CSC_es_ME21_odd_));

  lut->set_GEM_roll_L1_CSC_min_wg_ME21_even(std::move(GEM_roll_L1_CSC_min_wg_ME21_even_));
  lut->set_GEM_roll_L1_CSC_max_wg_ME21_even(std::move(GEM_roll_L1_CSC_max_wg_ME21_even_));
  lut->set_GEM_roll_L1_CSC_min_wg_ME21_odd(std::move(GEM_roll_L1_CSC_min_wg_ME21_odd_));
  lut->set_GEM_roll_L1_CSC_max_wg_ME21_odd(std::move(GEM_roll_L1_CSC_max_wg_ME21_odd_));

  lut->set_GEM_roll_L2_CSC_min_wg_ME21_even(std::move(GEM_roll_L2_CSC_min_wg_ME21_even_));
  lut->set_GEM_roll_L2_CSC_max_wg_ME21_even(std::move(GEM_roll_L2_CSC_max_wg_ME21_even_));
  lut->set_GEM_roll_L2_CSC_min_wg_ME21_odd(std::move(GEM_roll_L2_CSC_min_wg_ME21_odd_));
  lut->set_GEM_roll_L2_CSC_max_wg_ME21_odd(std::move(GEM_roll_L2_CSC_max_wg_ME21_odd_));

  lut->set_es_diff_slope_L1_ME21_even(std::move(es_diff_slope_L1_ME21_even_));
  lut->set_es_diff_slope_L2_ME21_even(std::move(es_diff_slope_L2_ME21_even_));
  lut->set_es_diff_slope_L1_ME21_odd(std::move(es_diff_slope_L1_ME21_odd_));
  lut->set_es_diff_slope_L2_ME21_odd(std::move(es_diff_slope_L2_ME21_odd_));

  return lut;
}

setIntervalFor()

void CSCL1TPLookupTableEP::setIntervalFor ( const edm::eventsetup::EventSetupRecordKey &  iKey, const edm::IOVSyncValue &  iosv, edm::ValidityInterval &  oValidity  )

overrideprotectedvirtual

Implements edm::EventSetupRecordIntervalFinder.

Definition at line 51 of file CSCL1TPLookupTableEP.cc.

References edm::IOVSyncValue::beginOfTime(), edm::IOVSyncValue::endOfTime(), and infinity.

                                                                          {
  edm::ValidityInterval infinity(iosv.beginOfTime(), iosv.endOfTime());
  oValidity = infinity;
}

Member Data Documentation

pset_

const edm::ParameterSet CSCL1TPLookupTableEP::pset_

private

Definition at line 39 of file CSCL1TPLookupTableEP.cc.

Referenced by produceCCLUT(), produceME11ILT(), and produceME21ILT().