#include <ESTrivialConditionRetriever.h>

Inheritance diagram for ESTrivialConditionRetriever:

Public Member Functions
	ESTrivialConditionRetriever (const edm::ParameterSet &pset)

	ESTrivialConditionRetriever (const ESTrivialConditionRetriever &)=delete

virtual std::unique_ptr< ESChannelStatus >	getChannelStatusFromConfiguration (const ESChannelStatusRcd &)

const ESTrivialConditionRetriever &	operator= (const ESTrivialConditionRetriever &)=delete

virtual std::unique_ptr< ESADCToGeVConstant >	produceESADCToGeVConstant (const ESADCToGeVConstantRcd &)

virtual std::unique_ptr< ESChannelStatus >	produceESChannelStatus (const ESChannelStatusRcd &)

virtual std::unique_ptr< ESIntercalibConstants >	produceESIntercalibConstants (const ESIntercalibConstantsRcd &)

virtual std::unique_ptr< ESPedestals >	produceESPedestals (const ESPedestalsRcd &)

virtual std::unique_ptr< ESTBWeights >	produceESTBWeights (const ESTBWeightsRcd &)

virtual std::unique_ptr< ESWeightStripGroups >	produceESWeightStripGroups (const ESWeightStripGroupsRcd &)

	~ESTrivialConditionRetriever () 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
void	getWeightsFromConfiguration (const edm::ParameterSet &ps)

Private Attributes
double	adcToGeVHighConstant_

double	adcToGeVLowConstant_

ESWeightSet	amplWeights_

std::string	amplWeightsFile_

std::string	channelStatusFile_

double	ESpedMean_

double	ESpedRMS_

bool	getWeightsFromFile_

double	intercalibConstantMean_

std::string	intercalibConstantsFile_

double	intercalibConstantSigma_

bool	producedESADCToGeVConstant_

bool	producedESChannelStatus_

bool	producedESIntercalibConstants_

bool	producedESPedestals_

bool	producedESWeights_

int	verbose_

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 40 of file ESTrivialConditionRetriever.h.

Constructor & Destructor Documentation

◆ ESTrivialConditionRetriever() [1/2]

ESTrivialConditionRetriever::ESTrivialConditionRetriever ( const edm::ParameterSet & pset )

Definition at line 17 of file ESTrivialConditionRetriever.cc.

References getChannelStatusFromConfiguration(), edm::ParameterSet::getUntrackedParameter(), castor_dqm_sourceclient_file_cfg::path, produceESADCToGeVConstant(), produceESChannelStatus(), produceESIntercalibConstants(), produceESPedestals(), produceESTBWeights(), produceESWeightStripGroups(), str, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                   {
   // initilize parameters used to produce cond DB objects
   adcToGeVLowConstant_ = ps.getUntrackedParameter<double>("adcToGeVLowConstant", 1.0);
   adcToGeVHighConstant_ = ps.getUntrackedParameter<double>("adcToGeVHighConstant", 1.0);
 
   intercalibConstantMean_ = ps.getUntrackedParameter<double>("intercalibConstantMean", 1.0);
   intercalibConstantSigma_ = ps.getUntrackedParameter<double>("intercalibConstantSigma", 0.0);
 
   //  intercalibErrorMean_ = ps.getUntrackedParameter<double>("IntercalibErrorMean",0.0);
 
   ESpedMean_ = ps.getUntrackedParameter<double>("ESpedMean", 200.);
   ESpedRMS_ = ps.getUntrackedParameter<double>("ESpedRMS", 1.00);
 
   getWeightsFromFile_ = ps.getUntrackedParameter<bool>("getWeightsFromFile", false);
 
   std::string path = "CalibCalorimetry/EcalTrivialCondModules/data/";
   std::string weightType;
   std::ostringstream str;
 
   weightType = str.str();
 
   amplWeightsFile_ = ps.getUntrackedParameter<std::string>("amplWeightsFile", path + "ampWeightsES" + weightType);
 
   // default weights for MGPA shape after pedestal subtraction
   getWeightsFromConfiguration(ps);
 
   producedESPedestals_ = ps.getUntrackedParameter<bool>("producedESPedestals", true);
   producedESWeights_ = ps.getUntrackedParameter<bool>("producedESWeights", true);
 
   producedESADCToGeVConstant_ = ps.getUntrackedParameter<bool>("producedESADCToGeVConstant", true);
 
   verbose_ = ps.getUntrackedParameter<int>("verbose", 0);
 
   //Tell Producer what we produce
   //setWhatproduce(this);
   if (producedESPedestals_)
     setWhatProduced(this, &ESTrivialConditionRetriever::produceESPedestals);
 
   if (producedESWeights_) {
     setWhatProduced(this, &ESTrivialConditionRetriever::produceESWeightStripGroups);
     setWhatProduced(this, &ESTrivialConditionRetriever::produceESTBWeights);
   }
 
   if (producedESADCToGeVConstant_)
     setWhatProduced(this, &ESTrivialConditionRetriever::produceESADCToGeVConstant);
 
   // intercalibration constants
   producedESIntercalibConstants_ = ps.getUntrackedParameter<bool>("producedESIntercalibConstants", true);
   intercalibConstantsFile_ = ps.getUntrackedParameter<std::string>("intercalibConstantsFile", "");
 
   if (producedESIntercalibConstants_) {      // user asks to produce constants
     if (intercalibConstantsFile_.empty()) {  // if file provided read constants
       //    setWhatProduced (this, &ESTrivialConditionRetriever::getIntercalibConstantsFromConfiguration ) ;
       //  } else { // set all constants to 1. or smear as specified by user
       setWhatProduced(this, &ESTrivialConditionRetriever::produceESIntercalibConstants);
     }
     findingRecord<ESIntercalibConstantsRcd>();
   }
 
   // intercalibration constants errors
   /*  producedESIntercalibErrors_ = ps.getUntrackedParameter<bool>("producedESIntercalibErrors",true);
       intercalibErrorsFile_ = ps.getUntrackedParameter<std::string>("intercalibErrorsFile","") ;
       
       if (producedESIntercalibErrors_) { // user asks to produce constants
       if(intercalibErrorsFile_ != "") {  // if file provided read constants
       setWhatProduced (this, &ESTrivialConditionRetriever::getIntercalibErrorsFromConfiguration ) ;
       } else { // set all constants to 1. or smear as specified by user
       setWhatProduced (this, &ESTrivialConditionRetriever::produceESIntercalibErrors ) ;
       }
       findingRecord<ESIntercalibErrorsRcd> () ;
       }
   */
 
   // channel status
   producedESChannelStatus_ = ps.getUntrackedParameter<bool>("producedESChannelStatus", true);
   channelStatusFile_ = ps.getUntrackedParameter<std::string>("channelStatusFile", "");
 
   if (producedESChannelStatus_) {
     if (!channelStatusFile_.empty()) {  // if file provided read channel map
       setWhatProduced(this, &ESTrivialConditionRetriever::getChannelStatusFromConfiguration);
     } else {  // set all channels to working -- FIXME might be changed
       setWhatProduced(this, &ESTrivialConditionRetriever::produceESChannelStatus);
     }
     findingRecord<ESChannelStatusRcd>();
   }
 
   //Tell Finder what records we find
   if (producedESPedestals_)
     findingRecord<ESPedestalsRcd>();
 
   if (producedESWeights_) {
     findingRecord<ESWeightStripGroupsRcd>();
     findingRecord<ESTBWeightsRcd>();
   }
 
   if (producedESADCToGeVConstant_)
     findingRecord<ESADCToGeVConstantRcd>();
 }

◆ ESTrivialConditionRetriever() [2/2]

ESTrivialConditionRetriever::ESTrivialConditionRetriever ( const ESTrivialConditionRetriever & )

delete

◆ ~ESTrivialConditionRetriever()

ESTrivialConditionRetriever::~ESTrivialConditionRetriever ( )

override

Definition at line 116 of file ESTrivialConditionRetriever.cc.

116 {}

Member Function Documentation

◆ getChannelStatusFromConfiguration()

std::unique_ptr< ESChannelStatus > ESTrivialConditionRetriever::getChannelStatusFromConfiguration ( const ESChannelStatusRcd & )

virtual

Definition at line 271 of file ESTrivialConditionRetriever.cc.

References MillePedeFileConverter_cfg::e, Exception, contentValuesFiles::fullPath, edm::FileInPath::fullPath(), ESDetId::ISTRIP_MAX, ESDetId::ISTRIP_MIN, ESDetId::IX_MAX, ESDetId::IX_MIN, ESDetId::IY_MAX, ESDetId::IY_MIN, mps_update::status, str, AlCaHLTBitMon_QueryRunRegistry::string, and ESDetId::unhashIndex().

Referenced by ESTrivialConditionRetriever().

                                {
   auto ecalStatus = std::make_unique<ESChannelStatus>();
 
   // start by setting all statuses to 0
 
   for (int istrip = ESDetId::ISTRIP_MIN; istrip <= ESDetId::ISTRIP_MAX; istrip++) {
     for (int ix = ESDetId::IX_MIN; ix <= ESDetId::IX_MAX; ix++) {
       for (int iy = ESDetId::IY_MIN; iy <= ESDetId::IY_MAX; iy++) {
         for (int iplane = 1; iplane <= 2; iplane++) {
           for (int izeta = -1; izeta <= 1; ++izeta) {
             if (izeta == 0)
               continue;
             try {
               //ESDetId Plane iplane Zside izeta
               ESDetId anESId(istrip, ix, iy, iplane, izeta);
               //      xtalGroups->setValue(ebid.rawId(), ESStripGroupId(ieta) ); // define rings in eta
               ecalStatus->setValue(anESId, 0);
             } catch (cms::Exception& e) {
             }
           }
         }
       }
     }
   }
 
   // overwrite the statuses which are in the file
 
   edm::LogInfo("ESTrivialConditionRetriever")
       << "Reading channel statuses from file " << edm::FileInPath(channelStatusFile_).fullPath().c_str();
   std::ifstream statusFile(edm::FileInPath(channelStatusFile_).fullPath().c_str());
   if (!statusFile.good()) {
     edm::LogError("ESTrivialConditionRetriever") << "*** Problems opening file: " << channelStatusFile_;
     throw cms::Exception("Cannot open ECAL channel status file");
   }
 
   std::string ESSubDet;
   std::string str;
   int hashIndex(0);
   int status(0);
 
   while (!statusFile.eof()) {
     statusFile >> ESSubDet;
     if (ESSubDet != std::string("ES")) {
       std::getline(statusFile, str);
       continue;
     } else {
       statusFile >> hashIndex >> status;
     }
     // std::cout << ESSubDet << " " << hashIndex << " " << status;
 
     if (ESSubDet == std::string("ES")) {
       ESDetId esid = ESDetId::unhashIndex(hashIndex);
       ecalStatus->setValue(esid, status);
     } else {
       edm::LogError("ESTrivialConditionRetriever") << " *** " << ESSubDet << " is not ES ";
     }
   }
   // the file is supposed to be in the form
   // ES hashed_index status
   // ES 132332 1  --> higher than 0  means bad
 
   statusFile.close();
   return ecalStatus;
 }

◆ getWeightsFromConfiguration()

void ESTrivialConditionRetriever::getWeightsFromConfiguration ( const edm::ParameterSet & ps )

private

Definition at line 238 of file ESTrivialConditionRetriever.cc.

References Exception, contentValuesFiles::fullPath, edm::FileInPath::fullPath(), dqmiolumiharvest::j, and dqmdumpme::k.

                                                                                        {
   ESWeightSet::ESWeightMatrix vampl;
 
   if (!getWeightsFromFile_) {
     //      vampl.set(1.);
 
     // amplwgtv[0]= ps.getUntrackedParameter< std::vector<double> >("amplWeights", vampl);
   } else if (getWeightsFromFile_) {
     edm::LogInfo("ESTrivialConditionRetriever")
         << "Reading amplitude weights from file " << edm::FileInPath(amplWeightsFile_).fullPath().c_str();
     std::ifstream amplFile(edm::FileInPath(amplWeightsFile_).fullPath().c_str());
     while (!amplFile.eof()) {
       for (int j = 0; j < 2; ++j) {
         std::vector<float> vec(3);
         for (int k = 0; k < 3; ++k) {
           float ww;
           amplFile >> ww;
           vec[k] = ww;
         }
         // vampl.putRow(vec);
       }
     }
   } else {
     //Not supported
     edm::LogError("ESTrivialConditionRetriever") << "Configuration not supported. Exception is raised ";
     throw cms::Exception("WrongConfig");
   }
 
   amplWeights_ = ESWeightSet(vampl);
 }

◆ operator=()

const ESTrivialConditionRetriever& ESTrivialConditionRetriever::operator= ( const ESTrivialConditionRetriever & )

delete

◆ produceESADCToGeVConstant()

std::unique_ptr< ESADCToGeVConstant > ESTrivialConditionRetriever::produceESADCToGeVConstant ( const ESADCToGeVConstantRcd & )

virtual

Definition at line 220 of file ESTrivialConditionRetriever.cc.

Referenced by ESTrivialConditionRetriever().

                                   {
   return std::make_unique<ESADCToGeVConstant>(adcToGeVLowConstant_, adcToGeVHighConstant_);
 }

◆ produceESChannelStatus()

std::unique_ptr< ESChannelStatus > ESTrivialConditionRetriever::produceESChannelStatus ( const ESChannelStatusRcd & )

virtual

Definition at line 337 of file ESTrivialConditionRetriever.cc.

References MillePedeFileConverter_cfg::e, ESDetId::ISTRIP_MAX, ESDetId::ISTRIP_MIN, ESDetId::IX_MAX, ESDetId::IX_MIN, ESDetId::IY_MAX, and ESDetId::IY_MIN.

Referenced by ESTrivialConditionRetriever().

                                                                                                             {
   auto ical = std::make_unique<ESChannelStatus>();
   for (int istrip = ESDetId::ISTRIP_MIN; istrip <= ESDetId::ISTRIP_MAX; istrip++) {
     for (int ix = ESDetId::IX_MIN; ix <= ESDetId::IX_MAX; ix++) {
       for (int iy = ESDetId::IY_MIN; iy <= ESDetId::IY_MAX; iy++) {
         for (int iplane = 1; iplane <= 2; iplane++) {
           for (int izeta = -1; izeta <= 1; ++izeta) {
             if (izeta == 0)
               continue;
             try {
               //ESDetId Plane iplane Zside izeta
               ESDetId anESId(istrip, ix, iy, iplane, izeta);
               //      xtalGroups->setValue(ebid.rawId(), ESStripGroupId(ieta) ); // define rings in eta
               ical->setValue(anESId, 0);
             } catch (cms::Exception& e) {
             }
           }
         }
       }
     }
   }
 
   return ical;
 }

◆ produceESIntercalibConstants()

std::unique_ptr< ESIntercalibConstants > ESTrivialConditionRetriever::produceESIntercalibConstants ( const ESIntercalibConstantsRcd & )

virtual

Definition at line 191 of file ESTrivialConditionRetriever.cc.

References gather_cfg::cout, MillePedeFileConverter_cfg::e, ESDetId::ISTRIP_MAX, ESDetId::ISTRIP_MIN, ESDetId::IX_MAX, ESDetId::IX_MIN, ESDetId::IY_MAX, ESDetId::IY_MIN, alignCSCRings::r, and DetId::rawId().

Referenced by ESTrivialConditionRetriever().

                                      {
   auto ical = std::make_unique<ESIntercalibConstants>();
   std::cout << "entring produce intercalib " << std::endl;
 
   for (int istrip = ESDetId::ISTRIP_MIN; istrip <= ESDetId::ISTRIP_MAX; istrip++) {
     for (int ix = ESDetId::IX_MIN; ix <= ESDetId::IX_MAX; ix++) {
       for (int iy = ESDetId::IY_MIN; iy <= ESDetId::IY_MAX; iy++) {
         for (int iplane = 1; iplane <= 2; iplane++) {
           for (int izeta = -1; izeta <= 1; ++izeta) {
             if (izeta == 0)
               continue;
             try {
               //ESDetId Plane iplane Zside izeta
               ESDetId anESId(istrip, ix, iy, iplane, izeta);
               double r = (double)std::rand() / (double(RAND_MAX) + double(1));
               ical->setValue(anESId.rawId(), intercalibConstantMean_ + r * intercalibConstantSigma_);
             } catch (cms::Exception& e) {
             }
           }
         }
       }
     }
   }
   std::cout << "done produce intercalib" << std::endl;
 
   return ical;
 }

◆ produceESPedestals()

std::unique_ptr< ESPedestals > ESTrivialConditionRetriever::produceESPedestals ( const ESPedestalsRcd & )

virtual

Definition at line 132 of file ESTrivialConditionRetriever.cc.

References gather_cfg::cout, MillePedeFileConverter_cfg::e, ESDetId::ISTRIP_MAX, ESDetId::ISTRIP_MIN, ESDetId::IX_MAX, ESDetId::IX_MIN, ESDetId::IY_MAX, ESDetId::IY_MIN, ESPedestal::mean, and DetId::rawId().

Referenced by ESTrivialConditionRetriever().

                                                                                                 {
   std::cout << " producing pedestals" << std::endl;
   auto peds = std::make_unique<ESPedestals>();
   ESPedestals::Item ESitem;
   ESitem.mean = ESpedMean_;
   ESitem.rms = ESpedRMS_;
 
   for (int istrip = ESDetId::ISTRIP_MIN; istrip <= ESDetId::ISTRIP_MAX; istrip++) {
     for (int ix = ESDetId::IX_MIN; ix <= ESDetId::IX_MAX; ix++) {
       for (int iy = ESDetId::IY_MIN; iy <= ESDetId::IY_MAX; iy++) {
         for (int iplane = 1; iplane <= 2; iplane++) {
           for (int izeta = -1; izeta <= 1; ++izeta) {
             if (izeta == 0)
               continue;
             try {
               //ESDetId Plane iplane Zside izeta
               ESDetId aPositiveId(istrip, ix, iy, iplane, izeta);
               peds->insert(std::make_pair(aPositiveId.rawId(), ESitem));
             } catch (cms::Exception& e) {
             }
           }
         }
       }
     }
   }
   //return std::unique_ptr<ESPedestals>( peds );
   std::cout << " produced pedestals" << std::endl;
   return peds;
 }

◆ produceESTBWeights()

std::unique_ptr< ESTBWeights > ESTrivialConditionRetriever::produceESTBWeights ( const ESTBWeightsRcd & )

virtual

Definition at line 225 of file ESTrivialConditionRetriever.cc.

Referenced by ESTrivialConditionRetriever().

                                                                                                 {
   // create weights for the test-beam
   auto tbwgt = std::make_unique<ESTBWeights>();
 
   int igrp = 1;
   ESWeightSet wgt = ESWeightSet(amplWeights_);
   //  ESWeightSet::ESWeightMatrix& mat1 = wgt.getWeights();
 
   tbwgt->setValue(igrp, wgt);
 
   return tbwgt;
 }

◆ produceESWeightStripGroups()

std::unique_ptr< ESWeightStripGroups > ESTrivialConditionRetriever::produceESWeightStripGroups ( const ESWeightStripGroupsRcd & )

virtual

Definition at line 162 of file ESTrivialConditionRetriever.cc.

References gather_cfg::cout, MillePedeFileConverter_cfg::e, ESDetId::ISTRIP_MAX, ESDetId::ISTRIP_MIN, ESDetId::IX_MAX, ESDetId::IX_MIN, ESDetId::IY_MAX, ESDetId::IY_MIN, and DetId::rawId().

Referenced by ESTrivialConditionRetriever().

                                    {
   auto xtalGroups = std::make_unique<ESWeightStripGroups>();
   ESStripGroupId defaultGroupId(1);
   std::cout << "entering produce weight groups" << std::endl;
   for (int istrip = ESDetId::ISTRIP_MIN; istrip <= ESDetId::ISTRIP_MAX; istrip++) {
     for (int ix = ESDetId::IX_MIN; ix <= ESDetId::IX_MAX; ix++) {
       for (int iy = ESDetId::IY_MIN; iy <= ESDetId::IY_MAX; iy++) {
         for (int iplane = 1; iplane <= 2; iplane++) {
           for (int izeta = -1; izeta <= 1; ++izeta) {
             if (izeta == 0)
               continue;
             try {
               //ESDetId Plane iplane Zside izeta
               ESDetId anESId(istrip, ix, iy, iplane, izeta);
               //      xtalGroups->setValue(ebid.rawId(), ESStripGroupId(ieta) ); // define rings in eta
               xtalGroups->setValue(anESId.rawId(), defaultGroupId);  // define rings in eta
             } catch (cms::Exception& e) {
             }
           }
         }
       }
     }
   }
   std::cout << "done with produce weight groups" << std::endl;
 
   return xtalGroups;
 }

◆ setIntervalFor()

void ESTrivialConditionRetriever::setIntervalFor	(	const edm::eventsetup::EventSetupRecordKey &	rk,
		const edm::IOVSyncValue &	iTime,
		edm::ValidityInterval &	oValidity
	)

overrideprotectedvirtual

Implements edm::EventSetupRecordIntervalFinder.

Definition at line 121 of file ESTrivialConditionRetriever.cc.

References edm::IOVSyncValue::beginOfTime(), gather_cfg::cout, edm::IOVSyncValue::endOfTime(), edm::eventsetup::EventSetupRecordKey::name(), edm::IOVSyncValue::time(), and edm::Timestamp::value().

                                                                                  {
   if (verbose_ >= 1)
     std::cout << "ESTrivialConditionRetriever::setIntervalFor(): record key = " << rk.name()
               << "\ttime: " << iTime.time().value() << std::endl;
   //For right now, we will just use an infinite interval of validity
   oValidity = edm::ValidityInterval(edm::IOVSyncValue::beginOfTime(), edm::IOVSyncValue::endOfTime());
 }