Inheritance diagram for SiPixelGainCalibrationRejectNoisyAndDead:

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

	~SiPixelGainCalibrationRejectNoisyAndDead () override

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)

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	fillDatabase (const edm::EventSetup &)

void	getNoisyPixels ()

Private Attributes
const bool	DEBUG

float	gainhi_

float	gainlow_

std::map< int, std::vector< std::pair< int, int > > >	insertednoisypixel

const int	insertnoisypixelsindb_

int	nnoisyininput

std::map< int, std::vector< std::pair< int, int > > >	noisypixelkeeper

const std::string	noisypixellist_

const edm::ESGetToken< TrackerGeometry, TrackerDigiGeometryRecord >	pddToken_

float	pedhi_

float	pedlow_

const std::string	record_

SiPixelGainCalibrationForHLTService	SiPixelGainCalibrationForHLTService_

SiPixelGainCalibrationOfflineService	SiPixelGainCalibrationOfflineService_

std::unique_ptr< SiPixelGainCalibrationForHLT >	theGainCalibrationDbInputForHLT_

std::unique_ptr< SiPixelGainCalibrationOffline >	theGainCalibrationDbInputOffline_

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 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 57 of file SiPixelGainCalibrationRejectNoisyAndDead.cc.

Constructor & Destructor Documentation

◆ SiPixelGainCalibrationRejectNoisyAndDead()

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

explicit

Definition at line 105 of file SiPixelGainCalibrationRejectNoisyAndDead.cc.

     : pddToken_(esConsumes()),
       SiPixelGainCalibrationOfflineService_(iConfig, consumesCollector()),
       SiPixelGainCalibrationForHLTService_(iConfig, consumesCollector()),
       noisypixellist_(iConfig.getUntrackedParameter<std::string>("noisyPixelList", "noisypixel.txt")),
       insertnoisypixelsindb_(iConfig.getUntrackedParameter<int>("insertNoisyPixelsInDB", 1)),
       record_(iConfig.getUntrackedParameter<std::string>("record", "SiPixelGainCalibrationOfflineRcd")),
       DEBUG(iConfig.getUntrackedParameter<bool>("debug", false)) {
   //now do what ever initialization is needed
 }

◆ ~SiPixelGainCalibrationRejectNoisyAndDead()

SiPixelGainCalibrationRejectNoisyAndDead::~SiPixelGainCalibrationRejectNoisyAndDead ( )

overridedefault

Member Function Documentation

◆ analyze()

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

overrideprivatevirtual

Implements edm::one::EDAnalyzerBase.

Definition at line 119 of file SiPixelGainCalibrationRejectNoisyAndDead.cc.

References fillDatabase(), getNoisyPixels(), and insertnoisypixelsindb_.

                                                                                                           {
   if (insertnoisypixelsindb_ != 0)
     getNoisyPixels();
   fillDatabase(iSetup);
 }

◆ fillDatabase()

void SiPixelGainCalibrationRejectNoisyAndDead::fillDatabase ( const edm::EventSetup & iSetup )

private

Definition at line 125 of file SiPixelGainCalibrationRejectNoisyAndDead.cc.

Referenced by analyze().

                                                                                        {
   if (DEBUG)
     edm::LogPrint("SiPixelGainCalibrationRejectNoisyAndDead")
         << "=>=>=>=> Starting the function fillDatabase()" << endl;
 
   if (record_ != "SiPixelGainCalibrationOfflineRcd" && record_ != "SiPixelGainCalibrationForHLTRcd") {
     edm::LogPrint("SiPixelGainCalibrationRejectNoisyAndDead")
         << record_ << " : this record  can't be used !" << std::endl;
     edm::LogPrint("SiPixelGainCalibrationRejectNoisyAndDead")
         << "Please select SiPixelGainCalibrationForHLTRcd or SiPixelGainCalibrationOfflineRcd" << std::endl;
     return;
   }
 
   //Get the Calibration Data
   if (record_ == "SiPixelGainCalibrationOfflineRcd")
     SiPixelGainCalibrationOfflineService_.setESObjects(iSetup);
   if (record_ == "SiPixelGainCalibrationForHLTRcd")
     SiPixelGainCalibrationForHLTService_.setESObjects(iSetup);
 
   //Get list of ideal detids
   const TrackerGeometry* pDD = &iSetup.getData(pddToken_);
   edm::LogInfo("SiPixelCondObjOfflineBuilder") << " There are " << pDD->dets().size() << " detectors" << std::endl;
 
   if (record_ == "SiPixelGainCalibrationOfflineRcd") {
     pedlow_ = SiPixelGainCalibrationOfflineService_.getPedLow();
     pedhi_ = SiPixelGainCalibrationOfflineService_.getPedHigh();
     gainlow_ = SiPixelGainCalibrationOfflineService_.getGainLow();
     gainhi_ = SiPixelGainCalibrationOfflineService_.getGainHigh();
   } else if (record_ == "SiPixelGainCalibrationForHLTRcd") {
     pedlow_ = SiPixelGainCalibrationForHLTService_.getPedLow();
     pedhi_ = SiPixelGainCalibrationForHLTService_.getPedHigh();
     gainlow_ = SiPixelGainCalibrationForHLTService_.getGainLow();
     gainhi_ = SiPixelGainCalibrationForHLTService_.getGainHigh();
   }
   if (gainlow_ < 0)
     gainlow_ = 0;
   if (gainhi_ > 21)
     gainhi_ = 21;
   if (pedlow_ < -100)
     pedlow_ = -100;
   if (pedhi_ > 300)
     pedhi_ = 300;
 
   edm::LogPrint("SiPixelGainCalibrationRejectNoisyAndDead")
       << "New payload will have pedlow,hi " << pedlow_ << "," << pedhi_ << " and gainlow,hi " << gainlow_ << ","
       << gainhi_ << endl;
   if (record_ == "SiPixelGainCalibrationOfflineRcd")
     theGainCalibrationDbInputOffline_ =
         std::make_unique<SiPixelGainCalibrationOffline>(pedlow_, pedhi_, gainlow_, gainhi_);
   if (record_ == "SiPixelGainCalibrationForHLTRcd")
     theGainCalibrationDbInputForHLT_ =
         std::make_unique<SiPixelGainCalibrationForHLT>(pedlow_, pedhi_, gainlow_, gainhi_);
 
   int nnoisy = 0;
   int ndead = 0;
 
   int detid = 0;
 
   //checking for noisy pixels that won't be inserted ...
   bool willNoisyPixBeInserted;
   for (std::map<int, std::vector<std::pair<int, int> > >::const_iterator it = noisypixelkeeper.begin();
        it != noisypixelkeeper.end();
        it++) {
     willNoisyPixBeInserted = false;
     for (TrackerGeometry::DetContainer::const_iterator mod = pDD->dets().begin(); mod != pDD->dets().end(); mod++) {
       detid = 0;
       if (dynamic_cast<PixelGeomDetUnit const*>((*mod)) != nullptr)
         detid = ((*mod)->geographicalId()).rawId();
       if (detid == it->first) {
         willNoisyPixBeInserted = true;
         break;
       }
     }
     if (!willNoisyPixBeInserted)
       edm::LogPrint("SiPixelGainCalibrationRejectNoisyAndDead")
           << "All Noisy Pixels in detid " << it->first
           << "won't be inserted, check the TrackerGeometry you are using !! You are missing some modules" << endl;
   }
 
   if (DEBUG)
     edm::LogPrint("SiPixelGainCalibrationRejectNoisyAndDead") << "=>=>=>=> Starting Loop over all modules" << endl;
 
   //Looping over all modules
   for (TrackerGeometry::DetContainer::const_iterator it = pDD->dets().begin(); it != pDD->dets().end(); it++) {
     detid = 0;
     if (dynamic_cast<PixelGeomDetUnit const*>((*it)) != nullptr)
       detid = ((*it)->geographicalId()).rawId();
     if (detid == 0)
       continue;
 
     if (DEBUG)
       edm::LogPrint("SiPixelGainCalibrationRejectNoisyAndDead") << "=>=>=>=> We are in module " << detid << endl;
 
     // Get the module sizes
     const PixelGeomDetUnit* pixDet = dynamic_cast<const PixelGeomDetUnit*>((*it));
     const PixelTopology& topol = pixDet->specificTopology();
     int nrows = topol.nrows();     // rows in x
     int ncols = topol.ncolumns();  // cols in y
 
     float ped;
     float gainforthiscol[2];
     float pedforthiscol[2];
     int nusedrows[2];
     int nrowsrocsplit;
     if (record_ == "SiPixelGainCalibrationOfflineRcd")
       nrowsrocsplit = theGainCalibrationDbInputOffline_->getNumberOfRowsToAverageOver();
     if (record_ == "SiPixelGainCalibrationForHLTRcd")
       nrowsrocsplit = theGainCalibrationDbInputForHLT_->getNumberOfRowsToAverageOver();
 
     std::vector<char> theSiPixelGainCalibrationGainPerColPedPerPixel;
     std::vector<char> theSiPixelGainCalibrationPerCol;
 
     if (DEBUG)
       edm::LogPrint("SiPixelGainCalibrationRejectNoisyAndDead") << "=>=>=>=> Starting Loop for each rows/cols " << endl;
 
     for (int icol = 0; icol <= ncols - 1; icol++) {
       if (DEBUG)
         edm::LogPrint("SiPixelGainCalibrationRejectNoisyAndDead") << "=>=>=>=> Starting a new column" << endl;
 
       nusedrows[0] = nusedrows[1] = 0;
       gainforthiscol[0] = gainforthiscol[1] = 0;
       pedforthiscol[0] = pedforthiscol[1] = 0;
 
       for (int jrow = 0; jrow <= nrows - 1; jrow++) {
         if (DEBUG)
           edm::LogPrint("SiPixelGainCalibrationRejectNoisyAndDead")
               << "=>=>=>=> We are in col,row " << icol << "," << jrow << endl;
 
         ped = 0;
 
         size_t iglobalrow = 0;
         int noisyPixInRow = 0;
         if (jrow > nrowsrocsplit) {
           iglobalrow = 1;
           noisyPixInRow = 0;
         }
 
         bool isPixelDeadOld = false;
         bool isColumnDeadOld = false;
         //  bool isPixelDeadNew = false;
         //  bool isColumnDeadNew = false;
 
         bool isPixelNoisyOld = false;
         bool isColumnNoisyOld = false;
         bool isPixelNoisyNew = false;
         bool isColumnNoisyNew = false;
 
         bool isColumnDead = false;
         bool isColumnNoisy = false;
         bool isPixelDead = false;
         bool isPixelNoisy = false;
 
         if (DEBUG)
           edm::LogPrint("SiPixelGainCalibrationRejectNoisyAndDead") << "=>=>=>=> Trying to get gain/ped " << endl;
 
         try {
           if (record_ == "SiPixelGainCalibrationOfflineRcd") {
             isPixelDeadOld = SiPixelGainCalibrationOfflineService_.isDead(detid, icol, jrow);
             isPixelNoisyOld = SiPixelGainCalibrationOfflineService_.isNoisy(detid, icol, jrow);
             isColumnDeadOld = SiPixelGainCalibrationOfflineService_.isNoisyColumn(detid, icol, jrow);
             isColumnNoisyOld = SiPixelGainCalibrationOfflineService_.isDeadColumn(detid, icol, jrow);
           }
           if (record_ == "SiPixelGainCalibrationForHLTRcd") {
             isColumnDeadOld = SiPixelGainCalibrationForHLTService_.isNoisyColumn(detid, icol, jrow);
             isColumnNoisyOld = SiPixelGainCalibrationForHLTService_.isDeadColumn(detid, icol, jrow);
           }
           if (!isColumnDeadOld && !isColumnNoisyOld) {
             if (record_ == "SiPixelGainCalibrationOfflineRcd")
               gainforthiscol[iglobalrow] = SiPixelGainCalibrationOfflineService_.getGain(detid, icol, jrow);
             if (record_ == "SiPixelGainCalibrationForHLTRcd") {
               gainforthiscol[iglobalrow] = SiPixelGainCalibrationForHLTService_.getGain(detid, icol, jrow);
               pedforthiscol[iglobalrow] = SiPixelGainCalibrationForHLTService_.getPedestal(detid, icol, jrow);
             }
           }
           if (!isPixelDeadOld && !isPixelNoisyOld)
             if (record_ == "SiPixelGainCalibrationOfflineRcd")
               ped = SiPixelGainCalibrationOfflineService_.getPedestal(detid, icol, jrow);
         } catch (const std::exception& er) {
           edm::LogPrint("SiPixelGainCalibrationRejectNoisyAndDead")
               << "Problem trying to catch gain/ped from DETID " << detid << " @ col,row " << icol << "," << jrow
               << endl;
         }
         //edm::LogPrint("SiPixelGainCalibrationRejectNoisyAndDead")<<"For DetId "<<detid<<" we found gain : "<<gain<<", pedestal : "<<ped<<std::endl;
 
         if (DEBUG)
           edm::LogPrint("SiPixelGainCalibrationRejectNoisyAndDead")
               << "=>=>=>=> Found gain " << gainforthiscol[iglobalrow] << " and ped " << pedforthiscol[iglobalrow]
               << endl;
 
         //Check if pixel is in new noisy list
         for (std::map<int, std::vector<std::pair<int, int> > >::const_iterator it = noisypixelkeeper.begin();
              it != noisypixelkeeper.end();
              it++)
           for (unsigned int i = 0; i < (it->second).size(); i++)
             if (it->first == detid && (it->second.at(i)).first == icol && (it->second.at(i)).second == jrow)
               isPixelNoisyNew = true;
 
         isColumnDead = isColumnDeadOld;
         isPixelDead = isPixelDeadOld;
 
         if (isPixelNoisyNew)
           noisyPixInRow++;
         if (noisyPixInRow == nrowsrocsplit)
           isColumnNoisyNew = true;
 
         if (insertnoisypixelsindb_ == 0) {
           isColumnNoisy = isColumnNoisyOld;
           isPixelNoisy = isPixelNoisyOld;
         } else if (insertnoisypixelsindb_ == 1) {
           isPixelNoisy = isPixelNoisyNew;
           isColumnNoisy = isColumnNoisyNew;
         } else if (insertnoisypixelsindb_ == 2) {
           isPixelNoisy = isPixelNoisyNew || isPixelNoisyOld;
           isColumnNoisy = isColumnNoisyNew || isColumnNoisyOld;
         }
 
         if (isPixelNoisy)
           edm::LogPrint("SiPixelGainCalibrationRejectNoisyAndDead")
               << "Inserting a noisy pixel in " << detid << " at col,row " << icol << "," << jrow << endl;
         if (isColumnNoisy)
           edm::LogPrint("SiPixelGainCalibrationRejectNoisyAndDead")
               << "Inserting a noisy column in " << detid << " at col,row " << icol << "," << jrow << endl;
         if (isPixelNoisy)
           nnoisy++;
         if (isPixelDead)
           ndead++;
 
         if (DEBUG)
           edm::LogPrint("SiPixelGainCalibrationRejectNoisyAndDead") << "=>=>=>=> Now Starting to fill the DB" << endl;
 
         //**********  Fill the new DB !!
 
         if (DEBUG)
           edm::LogPrint("SiPixelGainCalibrationRejectNoisyAndDead")
               << "=>=>=>=> Filling Pixel Level Calibration" << endl;
 
         //Set Pedestal
         if (record_ == "SiPixelGainCalibrationOfflineRcd") {
           if (isPixelDead)
             theGainCalibrationDbInputOffline_->setDeadPixel(theSiPixelGainCalibrationGainPerColPedPerPixel);
           else if (isPixelNoisy)
             theGainCalibrationDbInputOffline_->setNoisyPixel(theSiPixelGainCalibrationGainPerColPedPerPixel);
           else
             theGainCalibrationDbInputOffline_->setDataPedestal(ped, theSiPixelGainCalibrationGainPerColPedPerPixel);
         }
 
         //Set Gain
         if ((jrow + 1) % nrowsrocsplit == 0) {
           if (DEBUG)
             edm::LogPrint("SiPixelGainCalibrationRejectNoisyAndDead")
                 << "=>=>=>=> Filling Column Level Calibration" << endl;
 
           if (isColumnDead) {
             if (record_ == "SiPixelGainCalibrationOfflineRcd")
               theGainCalibrationDbInputOffline_->setDeadColumn(nrowsrocsplit,
                                                                theSiPixelGainCalibrationGainPerColPedPerPixel);
             if (record_ == "SiPixelGainCalibrationForHLTRcd")
               theGainCalibrationDbInputForHLT_->setDeadColumn(nrowsrocsplit, theSiPixelGainCalibrationPerCol);
           } else if (isColumnNoisy) {
             if (record_ == "SiPixelGainCalibrationOfflineRcd")
               theGainCalibrationDbInputOffline_->setNoisyColumn(nrowsrocsplit,
                                                                 theSiPixelGainCalibrationGainPerColPedPerPixel);
             if (record_ == "SiPixelGainCalibrationForHLTRcd")
               theGainCalibrationDbInputForHLT_->setNoisyColumn(nrowsrocsplit, theSiPixelGainCalibrationPerCol);
           } else {
             if (record_ == "SiPixelGainCalibrationOfflineRcd")
               theGainCalibrationDbInputOffline_->setDataGain(
                   gainforthiscol[iglobalrow], nrowsrocsplit, theSiPixelGainCalibrationGainPerColPedPerPixel);
             if (record_ == "SiPixelGainCalibrationForHLTRcd")
               theGainCalibrationDbInputForHLT_->setData(
                   pedforthiscol[iglobalrow], gainforthiscol[iglobalrow], theSiPixelGainCalibrationPerCol);
           }
         }
 
         if (DEBUG)
           edm::LogPrint("SiPixelGainCalibrationRejectNoisyAndDead")
               << "=>=>=>=> This pixel is finished inserting" << endl;
 
       }  //end of loop over rows
 
       if (DEBUG)
         edm::LogPrint("SiPixelGainCalibrationRejectNoisyAndDead")
             << "=>=>=>=> This column is finished inserting" << endl;
 
     }  //end of loop over col
 
     if (DEBUG)
       edm::LogPrint("SiPixelGainCalibrationRejectNoisyAndDead") << "=>=>=>=> Loop over rows/cols is finished" << endl;
 
     if (record_ == "SiPixelGainCalibrationOfflineRcd") {
       SiPixelGainCalibrationOffline::Range offlinerange(theSiPixelGainCalibrationGainPerColPedPerPixel.begin(),
                                                         theSiPixelGainCalibrationGainPerColPedPerPixel.end());
       if (!theGainCalibrationDbInputOffline_->put(detid, offlinerange, ncols))
         edm::LogError("SiPixelGainCalibrationAnalysis")
             << "warning: detid already exists for Offline (gain per col, ped per pixel) calibration database"
             << std::endl;
     }
     if (record_ == "SiPixelGainCalibrationForHLTRcd") {
       SiPixelGainCalibrationOffline::Range hltrange(theSiPixelGainCalibrationPerCol.begin(),
                                                     theSiPixelGainCalibrationPerCol.end());
       if (!theGainCalibrationDbInputForHLT_->put(detid, hltrange, ncols))
         edm::LogError("SiPixelGainCalibrationAnalysis")
             << "warning: detid already exists for HLT (gain per col, ped per col) calibration database" << std::endl;
     }
 
     if (DEBUG)
       edm::LogPrint("SiPixelGainCalibrationRejectNoisyAndDead") << "=>=>=>=> This detid is finished inserting" << endl;
 
   }  //end of loop over Detids
 
   edm::LogPrint("SiPixelGainCalibrationRejectNoisyAndDead") << " --- writing to DB!" << std::endl;
   edm::Service<cond::service::PoolDBOutputService> mydbservice;
   if (!mydbservice.isAvailable()) {
     edm::LogError("db service unavailable");
     return;
   } else {
     if (record_ == "SiPixelGainCalibrationOfflineRcd") {
       edm::LogPrint("SiPixelGainCalibrationRejectNoisyAndDead")
           << "now doing SiPixelGainCalibrationOfflineRcd payload..." << std::endl;
       if (mydbservice->isNewTagRequest("SiPixelGainCalibrationOfflineRcd")) {
         mydbservice->createOneIOV<SiPixelGainCalibrationOffline>(
             *theGainCalibrationDbInputOffline_, mydbservice->beginOfTime(), "SiPixelGainCalibrationOfflineRcd");
       } else {
         mydbservice->appendOneIOV<SiPixelGainCalibrationOffline>(
             *theGainCalibrationDbInputOffline_, mydbservice->currentTime(), "SiPixelGainCalibrationOfflineRcd");
       }
     }
     if (record_ == "SiPixelGainCalibrationForHLTRcd") {
       edm::LogPrint("SiPixelGainCalibrationRejectNoisyAndDead")
           << "now doing SiPixelGainCalibrationForHLTRcd payload..." << std::endl;
       if (mydbservice->isNewTagRequest("SiPixelGainCalibrationForHLTRcd")) {
         mydbservice->createOneIOV<SiPixelGainCalibrationForHLT>(
             *theGainCalibrationDbInputForHLT_, mydbservice->beginOfTime(), "SiPixelGainCalibrationForHLTRcd");
       } else {
         mydbservice->appendOneIOV<SiPixelGainCalibrationForHLT>(
             *theGainCalibrationDbInputForHLT_, mydbservice->currentTime(), "SiPixelGainCalibrationForHLTRcd");
       }
     }
   }
 
   edm::LogPrint("SiPixelGainCalibrationRejectNoisyAndDead") << " ---> SUMMARY :" << std::endl;
   edm::LogPrint("SiPixelGainCalibrationRejectNoisyAndDead")
       << " File had   " << nnoisyininput << " noisy pixels" << std::endl;
 
   edm::LogPrint("SiPixelGainCalibrationRejectNoisyAndDead") << " DB has now " << nnoisy << " noisy pixels" << std::endl;
   edm::LogPrint("SiPixelGainCalibrationRejectNoisyAndDead") << " DB has now " << ndead << " dead pixels" << std::endl;
 }

◆ fillDescriptions()

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

static

Definition at line 95 of file SiPixelGainCalibrationRejectNoisyAndDead.cc.

References edm::ConfigurationDescriptions::addWithDefaultLabel(), submitPVResolutionJobs::desc, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                                           {
   edm::ParameterSetDescription desc;
   desc.setComment("EDAnalyzer to create SiPixelGainCalibration payloads by rejecting noisy and dead ones");
   desc.addUntracked<bool>("debug", false);
   desc.addUntracked<int>("insertNoisyPixelsInDB", 1);
   desc.addUntracked<std::string>("record", "SiPixelGainCalibrationOfflineRcd");
   desc.addUntracked<std::string>("noisyPixelList", "noisypixel.txt");
   descriptions.addWithDefaultLabel(desc);
 }

◆ getNoisyPixels()

void SiPixelGainCalibrationRejectNoisyAndDead::getNoisyPixels ( )

private

Definition at line 473 of file SiPixelGainCalibrationRejectNoisyAndDead.cc.

References cuy::col, recoMuon::in, mps_splice::line, nnoisyininput, noisypixelkeeper, noisypixellist_, and edm_modernize_messagelogger::stat.

Referenced by analyze().

                                                               {
   nnoisyininput = 0;
 
   ifstream in;
   struct stat Stat;
   if (stat(noisypixellist_.c_str(), &Stat)) {
     edm::LogPrint("SiPixelGainCalibrationRejectNoisyAndDead") << "No file named " << noisypixellist_ << std::endl;
     edm::LogPrint("SiPixelGainCalibrationRejectNoisyAndDead")
         << "If you don't want to insert noisy pixel flag, disable it using tag insertNoisyPixelsInDB " << std::endl;
     return;
   }
 
   in.open(noisypixellist_.c_str());
   if (in.is_open()) {
     TString line;
     edm::LogPrint("SiPixelGainCalibrationRejectNoisyAndDead") << "opened" << endl;
     char linetmp[201];
     while (in.getline(linetmp, 200)) {
       line = linetmp;
       if (line.Contains("OFFLINE")) {
         line.Remove(0, line.First(",") + 9);
         TString detidstring = line;
         detidstring.Remove(line.First(" "), line.Sizeof());
 
         line.Remove(0, line.First(",") + 20);
         TString col = line;
         col.Remove(line.First(","), line.Sizeof());
         line.Remove(0, line.First(",") + 1);
         TString row = line;
         row.Remove(line.First(" "), line.Sizeof());
 
         edm::LogPrint("SiPixelGainCalibrationRejectNoisyAndDead")
             << "Found noisy pixel in DETID " << detidstring << " col,row " << col << "," << row << std::endl;
         nnoisyininput++;
 
         std::vector<std::pair<int, int> > tempvec;
         if (noisypixelkeeper.find(detidstring.Atoi()) != noisypixelkeeper.end())
           tempvec = (noisypixelkeeper.find(detidstring.Atoi()))->second;
 
         std::pair<int, int> temppair(col.Atoi(), row.Atoi());
         tempvec.push_back(temppair);
         noisypixelkeeper[detidstring.Atoi()] = tempvec;
       }
     }
   }
   /*
   for(std::map <int,std::vector<std::pair<int,int> > >::const_iterator it=noisypixelkeeper.begin();it!=noisypixelkeeper.end();it++) 
     for(int i=0;i<(it->second).size();i++)
       edm::LogPrint("SiPixelGainCalibrationRejectNoisyAndDead")<<it->first<<"  "<<(it->second.at(i)).first<<"  "<<(it->second.at(i)).second<<std::endl;
   */
 }