Inheritance diagram for cms::SiPixelCondObjOfflineBuilder:

Classes
class	CalParameters

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

void	beginJob () override

bool	loadFromFile ()

	SiPixelCondObjOfflineBuilder (const edm::ParameterSet &iConfig)

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

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

const edm::ESGetToken< TrackerGeometry, TrackerDigiGeometryRecord >	pddToken_

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

SiPixelGainCalibrationOfflineService	SiPixelGainCalibrationService_

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 SiPixelCondObjOfflineBuilder.cc.

Constructor & Destructor Documentation

◆ SiPixelCondObjOfflineBuilder()

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

explicit

Definition at line 93 of file SiPixelCondObjOfflineBuilder.cc.

       : appendMode_(iConfig.getUntrackedParameter<bool>("appendMode", true)),
         pddToken_(esConsumes()),
         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");
   }

Member Function Documentation

◆ analyze()

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

overridevirtual

Implements edm::one::EDAnalyzerBase.

Definition at line 119 of file SiPixelCondObjOfflineBuilder.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::SiPixelCondObjOfflineBuilder::CalParameters::p0, cms::SiPixelCondObjOfflineBuilder::CalParameters::p1, pddToken_, PixelIndices::pixelToChannelROC(), FastTimerService_cff::range, nano_mu_digi_cff::rawId, recordName_, rmsGain_, rmsGainFPix_, rmsPed_, rmsPedFPix_, writedatasetfile::run, secondRocRowGainOffset_, secondRocRowPedOffset_, SiPixelGainCalibration_, PixelGeomDetUnit::specificTopology(), 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("SiPixelCondObjOfflineBuilder")
         << "... 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 minped = 0.;
     float maxped = 100.;
     float mingain = 0.;
     float maxgain = 10.;
     SiPixelGainCalibration_ = std::make_unique<SiPixelGainCalibrationOffline>(minped, maxped, mingain, maxgain);
 
     const TrackerGeometry* pDD = &iSetup.getData(pddToken_);
     edm::LogInfo("SiPixelCondObjOfflineBuilder") << " 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("SiPixelCondObjOfflineBuilder") << " ---> 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 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("SiPixelCondObjOfflineBuilder") << "dead pixel " << detid << " " << i << "," << j << " " << val << std::endl;
                 }
               }
               if (deadFraction_ > 0 && !isDead) {
                 double val = CLHEP::RandFlat::shoot();
                 if (val < noisyFraction_) {
                   isNoisy = true;
                   //         edm::LogPrint("SiPixelCondObjOfflineBuilder") << "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) {
             //       edm::LogPrint("SiPixelCondObjOfflineBuilder") << "       Col "<<i<<" Row "<<j<<" Ped "<<ped<<" Gain "<<gain<<std::endl;
             //     }
 
             //         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;
             }
 
             totalGain += gain;
 
             if (!isDead && !isNoisy) {
               SiPixelGainCalibration_->setDataPedestal(ped, theSiPixelGainCalibration);
             } else if (isDead)  // dead pixel
               //         edm::LogPrint("SiPixelCondObjOfflineBuilder") << "filling pixel as dead for detid " << detid <<", col " << i << ", row" << j <<  std::endl;
               SiPixelGainCalibration_->setDeadPixel(theSiPixelGainCalibration);
             else if (isNoisy)  // dead pixel
               //         edm::LogPrint("SiPixelCondObjOfflineBuilder") << "filling pixel as dead for detid " << detid <<", col " << i << ", row" << j <<  std::endl;
               SiPixelGainCalibration_->setNoisyPixel(theSiPixelGainCalibration);
             if ((j + 1) % 80 == 0)  // fill the column average after ever ROC!
             {
               float averageGain = totalGain / static_cast<float>(80);
 
               if (generateColumns_) {
                 averageGain = gain;
               }
 
               //edm::LogPrint("SiPixelCondObjOfflineBuilder") << "Filling gain " << averageGain << " for col: " << i << " row: " << j << std::endl;
               SiPixelGainCalibration_->setDataGain(averageGain, 80, theSiPixelGainCalibration);
               totalGain = 0;
             }
           }
         }
 
         SiPixelGainCalibrationOffline::Range range(theSiPixelGainCalibration.begin(), theSiPixelGainCalibration.end());
         if (!SiPixelGainCalibration_->put(detid, range, ncols))
           edm::LogError("SiPixelCondObjOfflineBuilder")
               << "[SiPixelCondObjOfflineBuilder::analyze] detid already exists" << std::endl;
       }
     }
     edm::LogPrint("SiPixelCondObjOfflineBuilder") << " ---> PIXEL Modules  " << nmodules << std::endl;
     edm::LogPrint("SiPixelCondObjOfflineBuilder") << " ---> 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("SiPixelCondObjOfflineBuilder")<<" PEDESTAL "<< mypedestal<<" GAIN "<<mygain<<std::endl;
     //      }
     //    }
     // Write into DB
     edm::LogInfo("SiPixelCondOfflineBuilder") << "writing to DB, record = \"" << recordName_ << "\"";
     edm::Service<cond::service::PoolDBOutputService> mydbservice;
     if (!mydbservice.isAvailable()) {
       edm::LogError("SiPixelCondOfflineBuilder") << " db service unavailable";
       return;
     } else {
       edm::LogInfo("SiPixelCondOfflineBuilder") << " DB service OK";
     }
 
     try {
       if (mydbservice->isNewTagRequest(recordName_)) {
         mydbservice->createOneIOV<SiPixelGainCalibrationOffline>(
             *SiPixelGainCalibration_, mydbservice->beginOfTime(), recordName_);
       } else {
         mydbservice->appendOneIOV<SiPixelGainCalibrationOffline>(
             *SiPixelGainCalibration_, mydbservice->currentTime(), recordName_);
       }
       edm::LogInfo(" --- all OK");
     } catch (const cond::Exception& er) {
       edm::LogError("SiPixelCondObjOfflineBuilder") << er.what() << std::endl;
     } catch (const std::exception& er) {
       edm::LogError("SiPixelCondObjOfflineBuilder") << "caught std::exception " << er.what() << std::endl;
     } catch (...) {
       edm::LogError("SiPixelCondObjOfflineBuilder") << "Funny error" << std::endl;
     }
   }

◆ beginJob()

void SiPixelCondObjOfflineBuilder::beginJob ( )

overridevirtual

Reimplemented from edm::one::EDAnalyzerBase.

Definition at line 326 of file SiPixelCondObjOfflineBuilder.cc.

References calmap_, fromFile_, and loadFromFile().

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

◆ loadFromFile()

bool SiPixelCondObjOfflineBuilder::loadFromFile ( )

Definition at line 335 of file SiPixelCondObjOfflineBuilder.cc.

References calmap_, officialStyle::chan, fileName_, RemoveAddSevLevel::flag, mps_fire::i, recoMuon::in, runGCPTkAlMap::in_file, mps_splice::line, Skims_PA_cff::name, cms::SiPixelCondObjOfflineBuilder::CalParameters::p0, cms::SiPixelCondObjOfflineBuilder::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("SiPixelCondObjOfflineBuilder") << "Input file not found" << std::endl;
     }
     if (in_file.eof() != 0) {
       edm::LogError("SiPixelCondObjOfflineBuilder") << 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("SiPixelCondObjOfflineBuilder") << 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("SiPixelCondObjOfflineBuilder")
           << " 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;
   }