#include <Tools/SiPixelGainCalibScaler/plugins/SiPixelGainCalibScaler.cc>

Inheritance diagram for SiPixelGainCalibScaler:

Public Member Functions
	SiPixelGainCalibScaler (const edm::ParameterSet &)

	~SiPixelGainCalibScaler () override

Public Member Functions inherited from edm::one::EDAnalyzer< edm::one::SharedResources >
	EDAnalyzer ()=default

	EDAnalyzer (const EDAnalyzer &)=delete

SerialTaskQueue *	globalLuminosityBlocksQueue () final

SerialTaskQueue *	globalRunsQueue () final

const EDAnalyzer &	operator= (const EDAnalyzer &)=delete

bool	wantsGlobalLuminosityBlocks () const final

bool	wantsGlobalRuns () const final

bool	wantsInputProcessBlocks () const final

bool	wantsProcessBlocks () const final

Public Member Functions inherited from edm::one::EDAnalyzerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

	EDAnalyzerBase ()

ModuleDescription const &	moduleDescription () const

bool	wantsStreamLuminosityBlocks () const

bool	wantsStreamRuns () const

	~EDAnalyzerBase () override

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

ESProxyIndex const *	esGetTokenIndices (edm::Transition iTrans) const

std::vector< ESProxyIndex > const &	esGetTokenIndicesVector (edm::Transition iTrans) const

std::vector< ESRecordIndex > const &	esGetTokenRecordIndicesVector (edm::Transition iTrans) const

ProductResolverIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

std::vector < ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesWhoseProductsAreConsumed (std::array< std::vector< ModuleDescription const * > , NumBranchTypes > &modulesAll, std::vector< ModuleProcessName > &modulesInPreviousProcesses, ProductRegistry const &preg, std::map< std::string, ModuleDescription const > const &labelsToDesc, std::string const &processName) const

EDConsumerBase const &	operator= (EDConsumerBase const &)=delete

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	selectInputProcessBlocks (ProductRegistry const &productRegistry, ProcessBlockHelperBase const &processBlockHelperBase)

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

void	updateLookup (eventsetup::ESRecordsToProxyIndices const &)

virtual	~EDConsumerBase () noexcept(false)

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

Static Public Member Functions inherited from edm::one::EDAnalyzerBase
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Private Member Functions
void	analyze (const edm::Event &, const edm::EventSetup &) override

void	beginJob () override

template<class tokenType , class PayloadType >
void	computeAndStorePalyoads (const edm::EventSetup &iSetup, const tokenType &token)

void	endJob () override

Private Attributes
edm::ESGetToken < SiPixelGainCalibrationForHLT, SiPixelGainCalibrationForHLTRcd >	gainHLTCalibToken_

edm::ESGetToken < SiPixelGainCalibrationOffline, SiPixelGainCalibrationOfflineRcd >	gainOfflineCalibToken_

const bool	isForHLT_

const std::vector < edm::ParameterSet >	m_parameters

gainScale::VCalInfo	phase0VCal

gainScale::VCalInfo	phase1VCal

edm::ESWatcher < SiPixelGainCalibrationForHLTRcd >	pixelHLTGainWatcher_

edm::ESWatcher < SiPixelGainCalibrationOfflineRcd >	pixelOfflineGainWatcher_

const std::string	recordName_

edm::ESGetToken < TrackerGeometry, TrackerDigiGeometryRecord >	tkGeomToken_

edm::ESGetToken < TrackerTopology, TrackerTopologyRcd >	tkTopoToken_

const bool	verbose_

Additional Inherited Members
Public Types inherited from edm::one::EDAnalyzerBase
typedef EDAnalyzerBase	ModuleType

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

template<BranchType B = InEvent>
EDConsumerBaseAdaptor< B >	consumes (edm::InputTag tag) noexcept

EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes ()

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)

template<Transition Tr = Transition::Event>
constexpr auto	esConsumes () noexcept

template<Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag tag) noexcept

template<Transition Tr = Transition::Event>
ESGetTokenGeneric	esConsumes (eventsetup::EventSetupRecordKey const &iRecord, eventsetup::DataKey const &iKey)
	Used with EventSetupRecord::doGet. More...

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

void	resetItemsToGetFrom (BranchType iType)

Detailed Description

Description: Scales Pixel Gain Payloads by applying the VCal offset and slopes.

Implementation: Makes use of trick to loop over all IOVs in a tag by running on all the runs with EmptySource and just access DB once the IOV has changed via ESWatcher mechanism

Definition at line 94 of file SiPixelGainCalibScaler.cc.

Constructor & Destructor Documentation

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

explicit

Definition at line 129 of file SiPixelGainCalibScaler.cc.

References edm::EDConsumerBase::esConsumes(), Exception, gainHLTCalibToken_, gainOfflineCalibToken_, gainScale::VCalInfo::init(), m_parameters, phase0VCal, phase1VCal, tkGeomToken_, and tkTopoToken_.

     : recordName_(iConfig.getParameter<std::string>("record")),
       isForHLT_(iConfig.getParameter<bool>("isForHLT")),
       verbose_(iConfig.getUntrackedParameter<bool>("verbose", false)),
       m_parameters(iConfig.getParameter<std::vector<edm::ParameterSet> >("parameters")) {
   gainHLTCalibToken_ = esConsumes();
   gainOfflineCalibToken_ = esConsumes();
   tkGeomToken_ = esConsumes();
   tkTopoToken_ = esConsumes();
 
   for (auto& thePSet : m_parameters) {
     const unsigned int phase(thePSet.getParameter<unsigned int>("phase"));
     switch (phase) {
       case 0: {
         phase0VCal.init(thePSet.getParameter<double>("conversionFactor"),
                         thePSet.getParameter<double>("conversionFactorL1"),
                         thePSet.getParameter<double>("offset"),
                         thePSet.getParameter<double>("offsetL1"));
         break;
       }
       case 1: {
         phase1VCal.init(thePSet.getParameter<double>("conversionFactor"),
                         thePSet.getParameter<double>("conversionFactorL1"),
                         thePSet.getParameter<double>("offset"),
                         thePSet.getParameter<double>("offsetL1"));
         break;
       }
       default:
         throw cms::Exception("LogicError") << "Unrecongnized phase: " << phase << ". Exiting!";
     }
   }
 }

SiPixelGainCalibScaler::~SiPixelGainCalibScaler ( )

override

Definition at line 162 of file SiPixelGainCalibScaler.cc.

162 {}

Member Function Documentation

void SiPixelGainCalibScaler::analyze	(	const edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

overrideprivatevirtual

Implements edm::one::EDAnalyzerBase.

Definition at line 169 of file SiPixelGainCalibScaler.cc.

References edm::ESWatcher< T >::check(), gainHLTCalibToken_, gainOfflineCalibToken_, edm::EventBase::id(), isForHLT_, pixelHLTGainWatcher_, pixelOfflineGainWatcher_, edm::EventID::run(), and submitPVValidationJobs::run.

                                                                                         {
   using namespace edm;
 
   int run = iEvent.id().run();
   bool hasPixelHLTGainIOV = pixelHLTGainWatcher_.check(iSetup);
   bool hasPixelOfflineGainIOV = pixelOfflineGainWatcher_.check(iSetup);
 
   if ((hasPixelHLTGainIOV && isForHLT_) || (hasPixelOfflineGainIOV && !isForHLT_)) {
     edm::LogPrint("SiPixelGainCalibScaler") << " Pixel Gains have a new IOV for run: " << run << std::endl;
 
     if (isForHLT_) {
       computeAndStorePalyoads<edm::ESGetToken<SiPixelGainCalibrationForHLT, SiPixelGainCalibrationForHLTRcd>,
                               SiPixelGainCalibrationForHLT>(iSetup, gainHLTCalibToken_);
     } else {
       computeAndStorePalyoads<edm::ESGetToken<SiPixelGainCalibrationOffline, SiPixelGainCalibrationOfflineRcd>,
                               SiPixelGainCalibrationOffline>(iSetup, gainOfflineCalibToken_);
     }
   }  // if new IOV
 }

void SiPixelGainCalibScaler::beginJob ( void )

overrideprivatevirtual

Reimplemented from edm::one::EDAnalyzerBase.

Definition at line 344 of file SiPixelGainCalibScaler.cc.

344 {}

template<class tokenType , class PayloadType >

void SiPixelGainCalibScaler::computeAndStorePalyoads	(	const edm::EventSetup &	iSetup,
		const tokenType &	token
	)

private

Definition at line 191 of file SiPixelGainCalibScaler.cc.

References cond::service::PoolDBOutputService::appendOneIOV(), cond::service::PoolDBOutputService::beginOfTime(), cuy::col, cond::service::PoolDBOutputService::createOneIOV(), cond::service::PoolDBOutputService::currentTime(), ztail::d, TrackerGeometry::dets(), cppFunctionSkipper::exception, gainScale::VCalInfo::getConversionFactor(), gainScale::VCalInfo::getConversionFactorL1(), edm::EventSetup::getData(), gainScale::VCalInfo::getOffset(), gainScale::VCalInfo::getOffsetL1(), edm::Service< T >::isAvailable(), cond::service::PoolDBOutputService::isNewTagRequest(), TrackerGeometry::isThere(), phase1PixelTopology::layer, SiStripPI::max, GeomDetEnumerators::P1PXB, GeomDetEnumerators::P1PXEC, jetCorrFactors_cfi::payload, phase0VCal, phase1VCal, PixelSubdetector::PixelBarrel, gainScale::VCalInfo::printAllInfo(), TrackerTopology::pxbLayer(), sistrip::SpyUtilities::range(), recordName_, DetId::subdetId(), tkGeomToken_, tkTopoToken_, verbose_, and cms::Exception::what().

                                                                                                         {
   gainScale::VCalInfo myVCalInfo;
 
   //=======================================================
   // Retrieve geometry information
   //=======================================================
   const TrackerGeometry* pDD = &iSetup.getData(tkGeomToken_);
   edm::LogInfo("SiPixelGainCalibScaler") << "There are: " << pDD->dets().size() << " detectors";
 
   // switch on the phase1
   if ((pDD->isThere(GeomDetEnumerators::P1PXB)) || (pDD->isThere(GeomDetEnumerators::P1PXEC))) {
     myVCalInfo = phase1VCal;
     edm::LogInfo("SiPixelGainCalibScaler") << " ==> This is a phase1 IOV";
   } else {
     myVCalInfo = phase0VCal;
     edm::LogInfo("SiPixelGainCalibScaler") << " ==> This is a phase0 IOV";
   }
 
   myVCalInfo.printAllInfo();
 
   // if need the ESHandle to check if the SetupData was there or not
   auto payload = &iSetup.getData(token);
   std::vector<uint32_t> detids;
   payload->getDetIds(detids);
 
   float mingain = payload->getGainLow();
   float maxgain = (payload->getGainHigh()) * myVCalInfo.getConversionFactorL1();
   float minped = payload->getPedLow();
   float maxped = payload->getPedHigh() * 1.10;
 
   PayloadType SiPixelGainCalibration_(minped, maxped, mingain, maxgain);
 
   //Retrieve tracker topology from geometry
   const TrackerTopology* tTopo = &iSetup.getData(tkTopoToken_);
 
   // possible to load it not from EventSetup
   //const char* path_toTopologyXML = "Geometry/TrackerCommonData/data/PhaseI/trackerParameters.xml";
   //TrackerTopology tTopo = StandaloneTrackerTopology::fromTrackerParametersXMLFile(edm::FileInPath(path_toTopologyXML).fullPath());
 
   for (const auto& d : detids) {
     bool isLayer1 = false;
     int subid = DetId(d).subdetId();
     if (subid == PixelSubdetector::PixelBarrel) {
       auto layer = tTopo->pxbLayer(DetId(d));
       if (layer == 1) {
         isLayer1 = true;
       }
     }
 
     std::vector<char> theSiPixelGainCalibration;
 
     auto range = payload->getRange(d);
     int numberOfRowsToAverageOver = payload->getNumberOfRowsToAverageOver();
     int ncols = payload->getNCols(d);
     int nRocsInRow = (range.second - range.first) / ncols / numberOfRowsToAverageOver;
     unsigned int nRowsForHLT = 1;
     int nrows = std::max((payload->getNumberOfRowsToAverageOver() * nRocsInRow),
                          nRowsForHLT);  // dirty trick to make it work for the HLT payload
 
     auto rangeAndCol = payload->getRangeAndNCols(d);
     bool isDeadColumn;
     bool isNoisyColumn;
 
     if (verbose_) {
       edm::LogVerbatim("SiPixelGainCalibScaler")
           << "NCOLS: " << payload->getNCols(d) << " " << rangeAndCol.second << " NROWS:" << nrows
           << ", RANGES: " << rangeAndCol.first.second - rangeAndCol.first.first
           << ", Ratio: " << float(rangeAndCol.first.second - rangeAndCol.first.first) / rangeAndCol.second << std::endl;
     }
 
     for (int col = 0; col < ncols; col++) {
       for (int row = 0; row < nrows; row++) {
         float gain = payload->getGain(col, row, rangeAndCol.first, rangeAndCol.second, isDeadColumn, isNoisyColumn);
         float ped = payload->getPed(col, row, rangeAndCol.first, rangeAndCol.second, isDeadColumn, isNoisyColumn);
 
         if (verbose_)
           edm::LogInfo("SiPixelGainCalibScaler") << "pre-change gain: " << gain << " pede:" << ped << std::endl;
 
         //
         // From here https://github.com/cms-sw/cmssw/blob/master/CalibTracker/SiPixelESProducers/src/SiPixelGainCalibrationForHLTService.cc#L20-L47
         //
         // vcal = ADC * DBgain - DBped * DBgain
         // electrons = vcal * conversionFactor + offset
         //
         // follows:
         // electrons = (ADC*DBgain � DBped*DBgain)*conversionFactor + offset
         // electrons = ADC*conversionFactor*DBgain - conversionFactor*DBped*DBgain + offset
         //
         // this should equal the new equation:
         //
         // electrons = ADC*DBgain' - DBPed' * DBgain'
         //
         // So equating piece by piece:
         //
         // DBgain' = conversionFactor*DBgain
         // DBped' = (conversionFactor*DBped*Dbgain � offset)/(conversionFactor*DBgain)
         //        = DBped - offset/DBgain'
         //
 
         if (isLayer1) {
           gain = gain * myVCalInfo.getConversionFactorL1();
           ped = ped - myVCalInfo.getOffsetL1() / gain;
         } else {
           gain = gain * myVCalInfo.getConversionFactor();
           ped = ped - myVCalInfo.getOffset() / gain;
         }
 
         if (verbose_)
           edm::LogInfo("SiPixelGainCalibScaler") << "post-change gain: " << gain << " pede:" << ped << std::endl;
 
         if constexpr (std::is_same_v<PayloadType, SiPixelGainCalibrationForHLT>) {
           SiPixelGainCalibration_.setData(ped, gain, theSiPixelGainCalibration, false, false);
         } else {
           SiPixelGainCalibration_.setDataPedestal(ped, theSiPixelGainCalibration);
           if ((row + 1) % numberOfRowsToAverageOver == 0) {  // fill the column average after every ROC!
             SiPixelGainCalibration_.setDataGain(gain, numberOfRowsToAverageOver, theSiPixelGainCalibration);
           }
         }
       }  // loop on rows
     }    // loop on columns
 
     typename PayloadType::Range outrange(theSiPixelGainCalibration.begin(), theSiPixelGainCalibration.end());
     if (!SiPixelGainCalibration_.put(d, outrange, ncols))
       edm::LogError("SiPixelGainCalibScaler") << "[SiPixelGainCalibScaler::analyze] detid already exists" << std::endl;
   }  // loop on DetIds
 
   // Write into DB
   edm::LogInfo(" --- writing to DB!");
   edm::Service<cond::service::PoolDBOutputService> mydbservice;
   if (!mydbservice.isAvailable()) {
     edm::LogError("db service unavailable");
     return;
   } else {
     edm::LogInfo("DB service OK");
   }
 
   try {
     if (mydbservice->isNewTagRequest(recordName_)) {
       mydbservice->createOneIOV<PayloadType>(SiPixelGainCalibration_, mydbservice->beginOfTime(), recordName_);
     } else {
       mydbservice->appendOneIOV<PayloadType>(SiPixelGainCalibration_, mydbservice->currentTime(), recordName_);
     }
     edm::LogInfo(" --- all OK");
   } catch (const cond::Exception& er) {
     edm::LogError("SiPixelGainCalibScaler") << er.what() << std::endl;
   } catch (const std::exception& er) {
     edm::LogError("SiPixelGainCalibScaler") << "caught std::exception " << er.what() << std::endl;
   } catch (...) {
     edm::LogError("SiPixelGainCalibScaler") << "Funny error" << std::endl;
   }
 }

void SiPixelGainCalibScaler::endJob ( void )

overrideprivatevirtual

Reimplemented from edm::one::EDAnalyzerBase.

Definition at line 347 of file SiPixelGainCalibScaler.cc.

347 {}

void SiPixelGainCalibScaler::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

static

Definition at line 350 of file SiPixelGainCalibScaler.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), edm::ParameterSet::addParameter(), edm::ParameterSetDescription::addUntracked(), edm::ParameterSetDescription::addVPSet(), submitPVResolutionJobs::desc, phase0VCal, phase1VCal, AlCaHLTBitMon_QueryRunRegistry::string, and createJobs::tmp.

                                                                                         {
   edm::ParameterSetDescription desc;
   desc.add<std::string>("record", "SiPixelGainCalibrationForHLTRcd");
   desc.add<bool>("isForHLT", true);
 
   edm::ParameterSetDescription vcalInfos;
   vcalInfos.add<unsigned int>("phase");
   vcalInfos.add<double>("conversionFactor");
   vcalInfos.add<double>("conversionFactorL1");
   vcalInfos.add<double>("offset");
   vcalInfos.add<double>("offsetL1");
 
   std::vector<edm::ParameterSet> tmp;
   tmp.reserve(2);
   {
     edm::ParameterSet phase0VCal;
     phase0VCal.addParameter<unsigned int>("phase", 0);
     phase0VCal.addParameter<double>("conversionFactor", 65.);
     phase0VCal.addParameter<double>("conversionFactorL1", 65.);
     phase0VCal.addParameter<double>("offset", -414.);
     phase0VCal.addParameter<double>("offsetL1", -414.);
     tmp.push_back(phase0VCal);
   }
   {
     edm::ParameterSet phase1VCal;
     phase1VCal.addParameter<unsigned int>("phase", 1);
     phase1VCal.addParameter<double>("conversionFactor", 47.);
     phase1VCal.addParameter<double>("conversionFactorL1", 50.);
     phase1VCal.addParameter<double>("offset", -60.);
     phase1VCal.addParameter<double>("offsetL1", -670.);
     tmp.push_back(phase1VCal);
   }
   desc.addVPSet("parameters", vcalInfos, tmp);
 
   desc.addUntracked<bool>("verbose", false);
 
   descriptions.add("siPixelGainCalibScaler", desc);
 }