Inheritance diagram for cms::SiPixelCondObjForHLTBuilder:

Classes
class	CalParameters

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

void	beginJob () override

bool	loadFromFile ()

	SiPixelCondObjForHLTBuilder (const edm::ParameterSet &iConfig)

	~SiPixelCondObjForHLTBuilder () override=default

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

	EDAnalyzer (const EDAnalyzer &)=delete

SerialTaskQueue *	globalLuminosityBlocksQueue () final

SerialTaskQueue *	globalRunsQueue () final

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

bool	wantsGlobalLuminosityBlocks () const noexcept final

bool	wantsGlobalRuns () const noexcept final

bool	wantsInputProcessBlocks () const noexcept final

bool	wantsProcessBlocks () const noexcept 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 noexcept

bool	wantsStreamRuns () const noexcept

	~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

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

std::vector< ESResolverIndex > 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

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

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

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

void	updateLookup (eventsetup::ESRecordsToProductResolverIndices const &)

virtual	~EDConsumerBase () noexcept(false)

Private Attributes
bool	appendMode_

std::map< int, CalParameters, std::less< int > >	calmap_

const double	deadFraction_

const std::string	fileName_

const bool	fromFile_

const bool	generateColumns_

const double	meanGain_

const double	meanGainFPix_

const double	meanPed_

const double	meanPedFPix_

const double	noisyFraction_

const int	numberOfModules_

PixelIndices *	pIndexConverter_

const std::string	recordName_

const double	rmsGain_

const double	rmsGainFPix_

const double	rmsPed_

const double	rmsPedFPix_

const double	secondRocRowGainOffset_

const double	secondRocRowPedOffset_

std::unique_ptr< SiPixelGainCalibrationForHLT >	SiPixelGainCalibration_

SiPixelGainCalibrationForHLTService	SiPixelGainCalibrationService_

const edm::ESGetToken< TrackerGeometry, TrackerDigiGeometryRecord >	tkGeometryToken_

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

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

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

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

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

Definition at line 48 of file SiPixelCondObjForHLTBuilder.cc.

Constructor & Destructor Documentation

◆ SiPixelCondObjForHLTBuilder()

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

explicit

Definition at line 94 of file SiPixelCondObjForHLTBuilder.cc.

       : tkGeometryToken_(esConsumes()),
         appendMode_(iConfig.getUntrackedParameter<bool>("appendMode", true)),
         SiPixelGainCalibration_(nullptr),
         SiPixelGainCalibrationService_(iConfig, consumesCollector()),
         recordName_(iConfig.getParameter<std::string>("record")),
         meanPed_(iConfig.getParameter<double>("meanPed")),
         rmsPed_(iConfig.getParameter<double>("rmsPed")),
         meanGain_(iConfig.getParameter<double>("meanGain")),
         rmsGain_(iConfig.getParameter<double>("rmsGain")),
         meanPedFPix_(iConfig.getUntrackedParameter<double>("meanPedFPix", meanPed_)),
         rmsPedFPix_(iConfig.getUntrackedParameter<double>("rmsPedFPix", rmsPed_)),
         meanGainFPix_(iConfig.getUntrackedParameter<double>("meanGainFPix", meanGain_)),
         rmsGainFPix_(iConfig.getUntrackedParameter<double>("rmsGainFPix", rmsGain_)),
         deadFraction_(iConfig.getParameter<double>("deadFraction")),
         noisyFraction_(iConfig.getParameter<double>("noisyFraction")),
         secondRocRowGainOffset_(iConfig.getParameter<double>("secondRocRowGainOffset")),
         secondRocRowPedOffset_(iConfig.getParameter<double>("secondRocRowPedOffset")),
         numberOfModules_(iConfig.getParameter<int>("numberOfModules")),
         fromFile_(iConfig.getParameter<bool>("fromFile")),
         fileName_(iConfig.getParameter<std::string>("fileName")),
         generateColumns_(iConfig.getUntrackedParameter<bool>("generateColumns", true))
 
   {
     ::putenv((char*)"CORAL_AUTH_USER=me");
     ::putenv((char*)"CORAL_AUTH_PASSWORD=test");
   }

◆ ~SiPixelCondObjForHLTBuilder()

cms::SiPixelCondObjForHLTBuilder::~SiPixelCondObjForHLTBuilder ( )

overridedefault

Member Function Documentation

◆ analyze()

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

overridevirtual

Implements edm::one::EDAnalyzerBase.

Definition at line 122 of file SiPixelCondObjForHLTBuilder.cc.

References cond::service::PoolDBOutputService::appendOneIOV(), cond::service::PoolDBOutputService::beginOfTime(), calmap_, cond::service::PoolDBOutputService::createOneIOV(), cond::service::PoolDBOutputService::currentTime(), deadFraction_, hcalRecHitTable_cff::detId, cppFunctionSkipper::exception, fromFile_, PedestalClient_cfi::gain, generateColumns_, edm::EventSetup::getData(), mps_fire::i, iEvent, edm::Service< T >::isAvailable(), cond::service::PoolDBOutputService::isNewTagRequest(), ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, dqmiolumiharvest::j, meanGain_, meanGainFPix_, meanPed_, meanPedFPix_, hgcalPlots::ncols, PixelTopology::ncolumns(), noisyFraction_, PixelTopology::nrows(), numberOfModules_, cms::SiPixelCondObjForHLTBuilder::CalParameters::p0, cms::SiPixelCondObjForHLTBuilder::CalParameters::p1, QIE10Task_cfi::ped, PixelIndices::pixelToChannelROC(), FastTimerService_cff::range, nano_mu_digi_cff::rawId, recordName_, rmsGain_, rmsGainFPix_, rmsPed_, rmsPedFPix_, writedatasetfile::run, secondRocRowGainOffset_, secondRocRowPedOffset_, SiPixelGainCalibration_, PixelGeomDetUnit::specificTopology(), tkGeometryToken_, PixelIndices::transformToROC(), heppy_batch::val, and cms::Exception::what().

                                                                                                {
     using namespace edm;
     unsigned int run = iEvent.id().run();
     int nmodules = 0;
     uint32_t nchannels = 0;
     //    int mycol = 415;
     //    int myrow = 159;
 
     edm::LogInfo("SiPixelCondObjForHLTBuilder")
         << "... creating dummy SiPixelGainCalibration Data for Run " << run << "\n " << std::endl;
     //
     // Instantiate Gain calibration offset and define pedestal/gain range
     //
     // note: the hard-coded range values are also used in random generation. That is why they're defined here
 
     float mingain = 0;
     float maxgain = 10;
     float minped = 0;
     float maxped = 255;
     SiPixelGainCalibration_ = std::make_unique<SiPixelGainCalibrationForHLT>(minped, maxped, mingain, maxgain);
 
     const TrackerGeometry* pDD = &iSetup.getData(tkGeometryToken_);
     edm::LogInfo("SiPixelCondObjForHLTBuilder") << " There are " << pDD->dets().size() << " detectors" << std::endl;
 
     for (TrackerGeometry::DetContainer::const_iterator it = pDD->dets().begin(); it != pDD->dets().end(); it++) {
       if (dynamic_cast<PixelGeomDetUnit const*>((*it)) != nullptr) {
         uint32_t detid = ((*it)->geographicalId()).rawId();
 
         // Stop if module limit reached
         nmodules++;
         if (nmodules > numberOfModules_)
           break;
 
         const PixelGeomDetUnit* pixDet = dynamic_cast<const PixelGeomDetUnit*>((*it));
         const PixelTopology& topol = pixDet->specificTopology();
         // Get the module sizes.
         int nrows = topol.nrows();     // rows in x
         int ncols = topol.ncolumns();  // cols in y
         //edm::LogPrint("SiPixelCondObjForHLTBuilder") << " ---> PIXEL DETID " << detid << " Cols " << ncols << " Rows " << nrows << std::endl;
 
         double meanPedWork = meanPed_;
         double rmsPedWork = rmsPed_;
         double meanGainWork = meanGain_;
         double rmsGainWork = rmsGain_;
         DetId detId(detid);
         if (detId.subdetId() == 2) {  // FPIX
           meanPedWork = meanPedFPix_;
           rmsPedWork = rmsPedFPix_;
           meanGainWork = meanGainFPix_;
           rmsGainWork = rmsGainFPix_;
         }
 
         PixelIndices pIndexConverter(ncols, nrows);
 
         std::vector<char> theSiPixelGainCalibration;
 
         // Loop over columns and rows of this DetID
         for (int i = 0; i < ncols; i++) {
           float totalPed = 0.0;
           float totalGain = 0.0;
           for (int j = 0; j < nrows; j++) {
             nchannels++;
             bool isDead = false;
             bool isNoisy = false;
             float ped = 0.0, gain = 0.0;
 
             if (fromFile_) {
               // Use calibration from a file
               int chipIndex = 0, colROC = 0, rowROC = 0;
 
               pIndexConverter.transformToROC(i, j, chipIndex, colROC, rowROC);
               int chanROC = PixelIndices::pixelToChannelROC(rowROC, colROC);  // use ROC coordinates
               //         float pp0=0, pp1=0;
               std::map<int, CalParameters, std::less<int> >::const_iterator it = calmap_.find(chanROC);
               CalParameters theCalParameters = (*it).second;
               ped = theCalParameters.p0;
               gain = theCalParameters.p1;
 
             } else {
               if (deadFraction_ > 0) {
                 double val = CLHEP::RandFlat::shoot();
                 if (val < deadFraction_) {
                   isDead = true;
                   //         edm::LogPrint("SiPixelCondObjForHLTBuilder") << "dead pixel " << detid << " " << i << "," << j << " " << val << std::endl;
                 }
               }
               if (deadFraction_ > 0 && !isDead) {
                 double val = CLHEP::RandFlat::shoot();
                 if (val < noisyFraction_) {
                   isNoisy = true;
                   //         edm::LogPrint("SiPixelCondObjForHLTBuilder") << "noisy pixel " << detid << " " << i << "," << j << " " << val << std::endl;
                 }
               }
 
               if (rmsPedWork > 0) {
                 ped = CLHEP::RandGauss::shoot(meanPedWork, rmsPedWork);
                 while (ped < minped || ped > maxped)
                   ped = CLHEP::RandGauss::shoot(meanPedWork, rmsPedWork);
               } else
                 ped = meanPedWork;
               if (rmsGainWork > 0) {
                 gain = CLHEP::RandGauss::shoot(meanGainWork, rmsGainWork);
                 while (gain < mingain || gain > maxgain)
                   gain = CLHEP::RandGauss::shoot(meanGainWork, rmsGainWork);
               } else
                 gain = meanGainWork;
             }
 
             //     if(i==mycol && j==myrow) {
             //     }
 
             //     gain =  2.8;
             //     ped  = 28.2;
 
             //if in the second row of rocs (i.e. a 2xN plaquette) add an offset (if desired) for testing
             if (j >= 80) {
               ped += secondRocRowPedOffset_;
               gain += secondRocRowGainOffset_;
 
               if (gain > maxgain)
                 gain = maxgain;
               else if (gain < mingain)
                 gain = mingain;
 
               if (ped > maxped)
                 ped = maxped;
               else if (ped < minped)
                 ped = minped;
             }
 
             totalPed += ped;
             totalGain += gain;
 
             if ((j + 1) % 80 == 0) {
               //edm::LogPrint("SiPixelCondObjForHLTBuilder") << "Filling   Col "<<i<<" Row "<<j<<" Ped "<<totalPed<<" Gain "<<totalGain<<std::endl;
               float averagePed = totalPed / static_cast<float>(80);
               float averageGain = totalGain / static_cast<float>(80);
 
               if (generateColumns_) {
                 averagePed = ped;
                 averageGain = gain;
               }
               //only fill by column after each roc
               if (!isDead && !isNoisy)
                 SiPixelGainCalibration_->setData(averagePed, averageGain, theSiPixelGainCalibration);
               else if (isDead)
                 SiPixelGainCalibration_->setDeadColumn(80, theSiPixelGainCalibration);
               else if (isNoisy)
                 SiPixelGainCalibration_->setNoisyColumn(80, theSiPixelGainCalibration);
 
               totalPed = 0;
               totalGain = 0;
             }
           }
         }
 
         SiPixelGainCalibrationForHLT::Range range(theSiPixelGainCalibration.begin(), theSiPixelGainCalibration.end());
         if (!SiPixelGainCalibration_->put(detid, range, ncols))
           edm::LogError("SiPixelCondObjForHLTBuilder")
               << "[SiPixelCondObjForHLTBuilder::analyze] detid already exists" << std::endl;
       }
     }
     edm::LogPrint("SiPixelCondObjForHLTBuilder") << " ---> PIXEL Modules  " << nmodules << std::endl;
     edm::LogPrint("SiPixelCondObjForHLTBuilder") << " ---> PIXEL Channels " << nchannels << std::endl;
 
     //   // Try to read object
     //    int mynmodules =0;
     //    for(TrackerGeometry::DetContainer::const_iterator it = pDD->dets().begin(); it != pDD->dets().end(); it++){
     //      if( dynamic_cast<PixelGeomDetUnit const*>((*it))!=0){
     //        uint32_t mydetid=((*it)->geographicalId()).rawId();
     //        mynmodules++;
     //        if( mynmodules > numberOfModules_) break;
     //        SiPixelGainCalibration::Range myrange = SiPixelGainCalibration_->getRange(mydetid);
     //        float mypedestal = SiPixelGainCalibration_->getPed (mycol,myrow,myrange,416);
     //        float mygain     = SiPixelGainCalibration_->getGain(mycol,myrow,myrange,416);
     //        //edm::LogPrint("SiPixelCondObjForHLTBuilder")<<" PEDESTAL "<< mypedestal<<" GAIN "<<mygain<<std::endl;
     //      }
     //    }
     // Write into DB
     edm::LogInfo(" --- writeing to DB!");
     edm::Service<cond::service::PoolDBOutputService> mydbservice;
     if (!mydbservice.isAvailable()) {
       edm::LogError("db service unavailable");
       return;
     } else {
       edm::LogInfo("DB service OK");
     }
 
     try {
       //     size_t callbackToken = mydbservice->callbackToken("SiPixelGainCalibration");
       //     edm::LogInfo("SiPixelCondObjForHLTBuilder")<<"CallbackToken SiPixelGainCalibration "
       //         <<callbackToken<<std::endl;
       //       unsigned long long tillTime;
       //     if ( appendMode_)
       //     tillTime = mydbservice->currentTime();
       //       else
       //     tillTime = mydbservice->endOfTime();
       //     edm::LogInfo("SiPixelCondObjForHLTBuilder")<<"[SiPixelCondObjForHLTBuilder::analyze] tillTime = "
       //         <<tillTime<<std::endl;
       //     mydbservice->newValidityForNewPayload<SiPixelGainCalibration>(
       //           SiPixelGainCalibration_, tillTime , callbackToken);
 
       if (mydbservice->isNewTagRequest(recordName_)) {
         mydbservice->createOneIOV<SiPixelGainCalibrationForHLT>(
             *SiPixelGainCalibration_, mydbservice->beginOfTime(), recordName_);
       } else {
         mydbservice->appendOneIOV<SiPixelGainCalibrationForHLT>(
             *SiPixelGainCalibration_, mydbservice->currentTime(), recordName_);
       }
       edm::LogInfo(" --- all OK");
     } catch (const cond::Exception& er) {
       edm::LogError("SiPixelCondObjForHLTBuilder") << er.what() << std::endl;
     } catch (const std::exception& er) {
       edm::LogError("SiPixelCondObjForHLTBuilder") << "caught std::exception " << er.what() << std::endl;
     } catch (...) {
       edm::LogError("SiPixelCondObjForHLTBuilder") << "Funny error" << std::endl;
     }
   }

◆ beginJob()

void SiPixelCondObjForHLTBuilder::beginJob ( )

overridevirtual

Reimplemented from edm::one::EDAnalyzerBase.

Definition at line 342 of file SiPixelCondObjForHLTBuilder.cc.

References calmap_, fromFile_, and loadFromFile().

                                              {
     if (fromFile_) {
       if (loadFromFile()) {
         edm::LogInfo("SiPixelCondObjForHLTBuilder") << " Calibration loaded: Map size " << calmap_.size() << " max "
                                                     << calmap_.max_size() << " " << calmap_.empty() << std::endl;
       }
     }
   }

◆ loadFromFile()

bool SiPixelCondObjForHLTBuilder::loadFromFile ( )

Definition at line 351 of file SiPixelCondObjForHLTBuilder.cc.

References calmap_, officialStyle::chan, fileName_, RemoveAddSevLevel::flag, mps_fire::i, recoMuon::in, runGCPTkAlMap::in_file, mps_splice::line, Skims_PA_cff::name, cms::SiPixelCondObjForHLTBuilder::CalParameters::p0, cms::SiPixelCondObjForHLTBuilder::CalParameters::p1, pfMETCorrectionType0_cfi::par0, pfMETCorrectionType0_cfi::par1, PixelIndices::pixelToChannelROC(), and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by beginJob(), and VarParsing.VarParsing::parseArguments().

                                                  {
     float par0, par1;  //,par2,par3;
     int colid, rowid;  //rocid
     std::string name;
 
     std::ifstream in_file;                          // data file pointer
     in_file.open(fileName_.c_str(), std::ios::in);  // in C++
     if (in_file.bad()) {
       edm::LogError("SiPixelCondObjForHLTBuilder") << "Input file not found" << std::endl;
     }
     if (in_file.eof() != 0) {
       edm::LogError("SiPixelCondObjForHLTBuilder") << in_file.eof() << " " << in_file.gcount() << " " << in_file.fail()
                                                    << " " << in_file.good() << " end of file " << std::endl;
       return false;
     }
     //Load file header
     char line[500];
     for (int i = 0; i < 3; i++) {
       in_file.getline(line, 500, '\n');
       edm::LogInfo("SiPixelCondObjForHLTBuilder") << line << std::endl;
     }
     //Loading calibration constants from file, loop on pixels
     for (int i = 0; i < (52 * 80); i++) {
       in_file >> par0 >> par1 >> name >> colid >> rowid;
 
       edm::LogPrint("SiPixelCondObjForHLTBuilder")
           << " Col " << colid << " Row " << rowid << " P0 " << par0 << " P1 " << par1 << std::endl;
 
       CalParameters onePix;
       onePix.p0 = par0;
       onePix.p1 = par1;
 
       // Convert ROC pixel index to channel
       int chan = PixelIndices::pixelToChannelROC(rowid, colid);
       calmap_.insert(std::pair<int, CalParameters>(chan, onePix));
     }
 
     bool flag;
     if (calmap_.size() == 4160) {
       flag = true;
     } else {
       flag = false;
     }
     return flag;
   }