#include <CalibTracker/SiPixelGainCalibration/src/SiPixelCalibDigiProducer.cc>

Inheritance diagram for SiPixelCalibDigiProducer:

Public Member Functions
	SiPixelCalibDigiProducer (const edm::ParameterSet &iConfig)

	~SiPixelCalibDigiProducer () override

Public Member Functions inherited from edm::EDProducer
	EDProducer ()

SerialTaskQueue *	globalLuminosityBlocksQueue ()

SerialTaskQueue *	globalRunsQueue ()

ModuleDescription const &	moduleDescription () const

	~EDProducer () override

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

std::vector< edm::ProductResolverIndex > const &	indiciesForPutProducts (BranchType iBranchType) const

	ProducerBase ()

std::vector< edm::ProductResolverIndex > const &	putTokenIndexToProductResolverIndex () const

std::vector< bool > const &	recordProvenanceList () const

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...

void	resolvePutIndicies (BranchType iBranchType, ModuleToResolverIndicies const &iIndicies, std::string const &moduleLabel)

TypeLabelList const &	typeLabelList () const
	used by the fwk to register the list of products of this module More...

	~ProducerBase () noexcept(false) 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 &&)=default

	EDConsumerBase (EDConsumerBase const &)=delete

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 &	operator= (EDConsumerBase &&)=default

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

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

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

void	updateLookup (eventsetup::ESRecordsToProxyIndices const &)

virtual	~EDConsumerBase () noexcept(false)

Private Types
typedef std::pair< uint32_t, std::pair< short, short > >	pixelstruct

Private Member Functions
virtual bool	checkFED (uint32_t detid)

virtual bool	checkPixel (uint32_t detid, short row, short col)

virtual void	clear ()

virtual void	fill (edm::Event &iEvent, const edm::EventSetup &iSetup)

virtual void	fillPixel (uint32_t detid, short row, short col, short ipoint, short adc)

void	produce (edm::Event &iEvent, const edm::EventSetup &iSetup) override

virtual void	setPattern ()

virtual bool	store ()

Private Attributes
edm::ESGetToken< SiPixelFedCablingMap, SiPixelFedCablingMapRcd >	cablingMapToken_

edm::ESHandle< SiPixelCalibConfiguration >	calib_

edm::ESGetToken< SiPixelCalibConfiguration, SiPixelCalibConfigurationRcd >	calibToken_

edm::ParameterSet	conf_

bool	control_pattern_size_

std::pair< short, short >	currentpair_

std::vector< std::pair< short, short > >	currentpattern_

std::map< uint32_t, uint32_t >	detid_to_fedid_

std::vector< pixelstruct >	detPixelMap_

std::map< pixelstruct, SiPixelCalibDigiError >	error_data_

int	errorType

uint32_t	iEventCounter_

bool	ignore_non_pattern_

bool	includeErrors_

std::string	instance_

std::map< pixelstruct, SiPixelCalibDigi >	intermediate_data_

std::string	label_

uint32_t	number_of_pixels_per_pattern_

uint32_t	pattern_repeat_

edm::InputTag	src_

edm::ESHandle< SiPixelFedCablingMap >	theCablingMap_

edm::ESHandle< TrackerGeometry >	theGeometry_

edm::EDGetTokenT< edm::DetSetVector< PixelDigi > >	tPixelDigi

edm::ESGetToken< TrackerGeometry, TrackerDigiGeometryRecord >	trackerGeomToken_

bool	use_realeventnumber_

Additional Inherited Members
Public Types inherited from edm::EDProducer
typedef EDProducer	ModuleType

Public Types inherited from edm::ProducerBase
using	ModuleToResolverIndicies = std::unordered_multimap< std::string, std::tuple< edm::TypeID const , const char , edm::ProductResolverIndex > >

typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

static bool	wantsGlobalLuminosityBlocks ()

static bool	wantsGlobalRuns ()

static bool	wantsInputProcessBlocks ()

static bool	wantsProcessBlocks ()

static bool	wantsStreamLuminosityBlocks ()

static bool	wantsStreamRuns ()

Protected Member Functions inherited from edm::ProducerBase
template<class ProductType >
BranchAliasSetterT< ProductType >	produces ()
	declare what type of product will make and with which optional label More...

template<typename ProductType , BranchType B>
BranchAliasSetterT< ProductType >	produces ()

template<typename ProductType , Transition B>
BranchAliasSetterT< ProductType >	produces ()

BranchAliasSetter	produces (const TypeID &id, std::string instanceName=std::string(), bool recordProvenance=true)

template<BranchType B>
BranchAliasSetter	produces (const TypeID &id, std::string instanceName=std::string(), bool recordProvenance=true)

template<Transition B>
BranchAliasSetter	produces (const TypeID &id, std::string instanceName=std::string(), bool recordProvenance=true)

template<typename ProductType , Transition B>
BranchAliasSetterT< ProductType >	produces (std::string instanceName)

template<class ProductType >
BranchAliasSetterT< ProductType >	produces (std::string instanceName)

template<typename ProductType , BranchType B>
BranchAliasSetterT< ProductType >	produces (std::string instanceName)

ProducesCollector	producesCollector ()

Protected Member Functions inherited from edm::EDConsumerBase
EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

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

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

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<Transition Tr = Transition::Event>
constexpr auto	esConsumes () noexcept

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

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

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

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

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

Detailed Description

Description: <one line="" class="" summary>="">

Implementation: <Notes on="" implementation>="">

Definition at line 55 of file SiPixelCalibDigiProducer.h.

Member Typedef Documentation

◆ pixelstruct

typedef std::pair<uint32_t, std::pair<short, short> > SiPixelCalibDigiProducer::pixelstruct

private

Definition at line 69 of file SiPixelCalibDigiProducer.h.

Constructor & Destructor Documentation

◆ SiPixelCalibDigiProducer()

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

explicit

Definition at line 47 of file SiPixelCalibDigiProducer.cc.

     : src_(iConfig.getParameter<edm::InputTag>("src")),
       iEventCounter_(0),
       ignore_non_pattern_(iConfig.getParameter<bool>("ignoreNonPattern")),
       control_pattern_size_(iConfig.getParameter<bool>("checkPatternEachEvent")),
       includeErrors_(iConfig.getUntrackedParameter<bool>("includeErrors", false)),
       errorType(iConfig.getUntrackedParameter<int>("errorTypeNumber", 1)),
       conf_(iConfig),
       number_of_pixels_per_pattern_(0),
       use_realeventnumber_(iConfig.getParameter<bool>("useRealEventNumber"))
  
 {
   tPixelDigi = consumes<edm::DetSetVector<PixelDigi>>(src_);
   //register your products
   produces<edm::DetSetVector<SiPixelCalibDigi>>();
   if (includeErrors_)
     produces<edm::DetSetVector<SiPixelCalibDigiError>>();
  
   calibToken_ = esConsumes<SiPixelCalibConfiguration, SiPixelCalibConfigurationRcd>();
   trackerGeomToken_ = esConsumes<TrackerGeometry, TrackerDigiGeometryRecord>();
   cablingMapToken_ = esConsumes<SiPixelFedCablingMap, SiPixelFedCablingMapRcd>();
 }

References cablingMapToken_, calibToken_, includeErrors_, src_, tPixelDigi, and trackerGeomToken_.

◆ ~SiPixelCalibDigiProducer()

SiPixelCalibDigiProducer::~SiPixelCalibDigiProducer ( )

override

Definition at line 70 of file SiPixelCalibDigiProducer.cc.

                                                     {
   // do anything here that needs to be done at desctruction time
   // (e.g. close files, deallocate resources etc.)
 }

Member Function Documentation

◆ checkFED()

bool SiPixelCalibDigiProducer::checkFED ( uint32_t detid )

privatevirtual

Definition at line 120 of file SiPixelCalibDigiProducer.cc.

                                                       {
   //  edm::LogInfo("SiPixelCalibProducer") << "in checkFED" << std::endl;
  
   if (detid_to_fedid_[detid])
     return true;
   for (int fedid = 0; fedid <= 40; ++fedid) {
     //    edm::LogInfo("SiPixelCalibProducer") << " looking at fedid " << fedid << std::endl;
     SiPixelFrameConverter converter(theCablingMap_.product(), fedid);
     if (converter.hasDetUnit(detid)) {
       detid_to_fedid_[detid] = fedid;
       edm::LogInfo("SiPixelCalibDigiProducer")
           << "matched detid " << detid << " to fed " << detid_to_fedid_[detid] << std::endl;
       return true;
     }
   }
   return false;
 }

References detid_to_fedid_, PixelSLinkDataInputSource_cfi::fedid, edm::ESHandle< T >::product(), and theCablingMap_.

Referenced by fillPixel().

◆ checkPixel()

bool SiPixelCalibDigiProducer::checkPixel	(	uint32_t	detid,
		short	row,
		short	col
	)

privatevirtual

Definition at line 309 of file SiPixelCalibDigiProducer.cc.

                                                                               {
   if (!control_pattern_size_ && !store())
     return true;
  
   if (!ignore_non_pattern_)
     return true;
  
   edm::LogInfo("SiPixelCalibDigiProducer") << "Event" << iEventCounter_ << ",now in checkpixel() " << std::endl;
   if (currentpattern_.empty())
     setPattern();
   //  uint32_t iroc;
   uint32_t fedid = detid_to_fedid_[detid];
  
   SiPixelFrameConverter formatter(theCablingMap_.product(), fedid);
   sipixelobjects::DetectorIndex detector = {detid, row, col};
   sipixelobjects::ElectronicIndex cabling;
  
   formatter.toCabling(cabling, detector);
   // cabling should now contain cabling.roc and cabling.dcol  and cabling.pxid
  
   // however, the coordinates now need to be converted from dcl, pxid to the row,col coordinates used in the calibration info
   sipixelobjects::LocalPixel::DcolPxid loc;
   loc.dcol = cabling.dcol;
   loc.pxid = cabling.pxid;
   sipixelobjects::LocalPixel locpixel(loc);
   currentpair_.first = locpixel.rocRow();
   currentpair_.second = locpixel.rocCol();
  
   for (uint32_t i = 0; i < currentpattern_.size(); ++i) {
     //    edm::LogInfo("SiPixelCalibDigiProducer") << "found pair " << currentpair_.first << "," << currentpair_.second << " calib " << currentpattern_[i].first << ","<< currentpattern_[i].second << " input " << row << "," << col << std::endl;
     if (currentpair_ == currentpattern_[i]) {
       return true;
     }
   }
   std::ostringstream errorlog;
   errorlog << "DETID " << detid << ", row, col (offline)=" << row << "," << col
            << " row, col (ROC) =" << currentpair_.first << "," << currentpair_.second
            << " found no match in list of patterns: ";
   for (uint32_t i = 0; i < currentpattern_.size(); ++i) {
     if (i != 0 && i != currentpattern_.size() - 1)
       errorlog << " ";
     errorlog << "(";
     errorlog << currentpattern_[i].first;
     errorlog << ",";
     errorlog << currentpattern_[i].second;
     errorlog << ")";
   }
   edm::LogError("ERROR") << errorlog.str() << std::endl;
   if (includeErrors_) {  // book the error
  
     pixelstruct temppixelworker;
     temppixelworker.first = detid;
     temppixelworker.second.first = row;
     temppixelworker.second.second = col;
     std::map<pixelstruct, SiPixelCalibDigiError>::const_iterator ierr = error_data_.find(temppixelworker);
     if (ierr == error_data_.end()) {
       SiPixelCalibDigiError temperr(row, col, 1);
       error_data_[temppixelworker] = temperr;
     }
   }
  
   return false;
 }

References cuy::col, control_pattern_size_, currentpair_, currentpattern_, sipixelobjects::ElectronicIndex::dcol, sipixelobjects::LocalPixel::DcolPxid::dcol, hgcalTestNeighbor_cfi::detector, detid_to_fedid_, error_data_, PixelSLinkDataInputSource_cfi::fedid, mps_fire::i, iEventCounter_, ignore_non_pattern_, includeErrors_, edm::ESHandle< T >::product(), sipixelobjects::ElectronicIndex::pxid, sipixelobjects::LocalPixel::DcolPxid::pxid, sipixelobjects::LocalPixel::rocCol(), sipixelobjects::LocalPixel::rocRow(), setPattern(), store(), and theCablingMap_.

Referenced by fillPixel(), and produce().

◆ clear()

void SiPixelCalibDigiProducer::clear ( void )

privatevirtual

Definition at line 172 of file SiPixelCalibDigiProducer.cc.

                                      {
   //  edm::LogInfo("SiPixelCalibProducer") << "in clear() " << std::endl;
   // this is where we empty the containers so they can be re-filled
   // the idea: the detPixelMap_ container shrinks/expands as a function
   // of the number of pixels looked at at one particular time...
   // unlike the intermediate_data_ container which only expands when
   // detPixelMap_ becomes bigger than intermedate_data_
  
   // shrink the detPixelMap_
   uint32_t tempsize = intermediate_data_.size();
   if (tempsize > number_of_pixels_per_pattern_) {
     edm::LogError("SiPixelCalibDigiProducer") << "Number of pixels in pattern is now: " << tempsize << ", size is was "
                                               << number_of_pixels_per_pattern_ << std::endl;
     number_of_pixels_per_pattern_ = tempsize;
   }
  
   intermediate_data_.erase(intermediate_data_.begin(), intermediate_data_.end());
   intermediate_data_.clear();
  
   // and erase the error bits
   error_data_.erase(error_data_.begin(), error_data_.end());
   error_data_.clear();
 }

References error_data_, intermediate_data_, and number_of_pixels_per_pattern_.

Referenced by produce(), and BeautifulSoup.Tag::setString().

◆ fill()

void SiPixelCalibDigiProducer::fill	(	edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

privatevirtual

Definition at line 96 of file SiPixelCalibDigiProducer.cc.

                                                                                  {
   // figure out which calibration point we're on now..
   short icalibpoint = calib_->vcalIndexForEvent(iEventCounter_);
   edm::Handle<edm::DetSetVector<PixelDigi>> pixelDigis;
   iEvent.getByToken(tPixelDigi, pixelDigis);
  
   edm::LogInfo("SiPixelCalibProducer") << "in fill(), calibpoint " << icalibpoint << " ndigis " << pixelDigis->size()
                                        << std::endl;
   // loop over the data and store things
   edm::DetSetVector<PixelDigi>::const_iterator digiIter;
   for (digiIter = pixelDigis->begin(); digiIter != pixelDigis->end(); ++digiIter) {  // ITERATOR OVER DET IDs
     uint32_t detid = digiIter->id;
     edm::DetSet<PixelDigi>::const_iterator ipix;  // ITERATOR OVER DIGI DATA
  
     for (ipix = digiIter->data.begin(); ipix != digiIter->end(); ++ipix) {
       // fill in the appropriate location of the temporary data container
       fillPixel(detid, ipix->row(), ipix->column(), icalibpoint, ipix->adc());
     }
   }
 }

References edm::DetSetVector< T >::begin(), calib_, edm::DetSetVector< T >::end(), fillPixel(), iEvent, iEventCounter_, tPixelDigi, and SiPixelCalibConfiguration::vcalIndexForEvent().

Referenced by produce().

◆ fillPixel()

void SiPixelCalibDigiProducer::fillPixel	(	uint32_t	detid,
		short	row,
		short	col,
		short	ipoint,
		short	adc
	)

privatevirtual

Definition at line 141 of file SiPixelCalibDigiProducer.cc.

                                                                                                       {
   //  edm::LogInfo("SiPixelCalibProducer") << " in fillpixel()" << std::endl;
  
   //  edm::LogInfo("SiPixelCalibProducer") << "in fillPixel " << detid << " " << row << " " << col << " " << ipoint << " " << adc << std::endl;
   if (!checkFED(detid)) {
     edm::LogError("SiPixelCalibDigiProducer") << " was unable to match detid " << detid << " to a FED!" << std::endl;
     return;
   }
   if (!checkPixel(detid, row, col)) {
     return;
   }
   // now the check if the pixel exists and fill
   //
   pixelstruct temppixelworker;
   temppixelworker.first = detid;
   temppixelworker.second.first = row;
   temppixelworker.second.second = col;
   std::map<pixelstruct, SiPixelCalibDigi>::const_iterator ipix = intermediate_data_.find(temppixelworker);
  
   if (ipix == intermediate_data_.end()) {
     SiPixelCalibDigi tempdigi(calib_->nVCal());
     tempdigi.setrowcol(row, col);
     intermediate_data_[temppixelworker] = tempdigi;
   }
  
   intermediate_data_[temppixelworker].fill(ipoint, adc);
   return;
 }

References gpuClustering::adc, calib_, checkFED(), checkPixel(), cuy::col, intermediate_data_, plotBeamSpotDB::ipoint, SiPixelCalibConfiguration::nVCal(), and SiPixelCalibDigi::setrowcol().

Referenced by fill().

◆ produce()

void SiPixelCalibDigiProducer::produce	(	edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

overrideprivatevirtual

Implements edm::EDProducer.

Definition at line 253 of file SiPixelCalibDigiProducer.cc.

                                                                                     {
   //  edm::LogInfo("SiPixelCalibDigiProducer") <<"in produce() " << std::endl;
   using namespace edm;
   calib_ = iSetup.getHandle(calibToken_);
   theGeometry_ = iSetup.getHandle(trackerGeomToken_);
   theCablingMap_ = iSetup.getHandle(cablingMapToken_);
   pattern_repeat_ = calib_->getNTriggers() * calib_->nVCal();
   if (use_realeventnumber_) {
     iEventCounter_ = iEvent.id().event() - 1;
   } else
     iEventCounter_++;
   if (iEventCounter_ % pattern_repeat_ == 1)
     setPattern();
  
   //  edm::LogInfo("SiPixelCalibDigiProducer") << "now starting fill..." << std::endl;
   fill(iEvent, iSetup);  // fill method where the actual looping over the digis is done.
   //  edm::LogInfo("SiPixelCalibDigiProducer") << "done filling..." << std::endl;
   auto pOut = std::make_unique<edm::DetSetVector<SiPixelCalibDigi>>();
   auto pErr = std::make_unique<edm::DetSetVector<SiPixelCalibDigiError>>();
  
   // copy things over into pOut if necessary (this is only once per pattern)
   if (store()) {
     //    edm::LogInfo("SiPixelCalibDigiProducer") << "in loop" << std::endl;
     for (std::map<pixelstruct, SiPixelCalibDigi>::const_iterator idet = intermediate_data_.begin();
          idet != intermediate_data_.end();
          ++idet) {
       uint32_t detid = idet->first.first;
       if (!control_pattern_size_) {
         if (!checkPixel(idet->first.first, idet->first.second.first, idet->first.second.second))
           continue;
       }
  
       SiPixelCalibDigi tempdigi = idet->second;
       edm::DetSet<SiPixelCalibDigi>& detSet = pOut->find_or_insert(detid);
       detSet.data.push_back(tempdigi);
     }
     if (includeErrors_) {
       for (std::map<pixelstruct, SiPixelCalibDigiError>::const_iterator ierr = error_data_.begin();
            ierr != error_data_.end();
            ++ierr) {
         uint32_t detid = ierr->first.first;
         SiPixelCalibDigiError temperror = ierr->second;
         edm::DetSet<SiPixelCalibDigiError>& errSet = pErr->find_or_insert(detid);
         errSet.data.push_back(temperror);
       }
     }
     edm::LogInfo("INFO") << "now filling event " << iEventCounter_ << " as pixel pattern changes every "
                          << pattern_repeat_ << " events..." << std::endl;
     clear();
   }
   iEvent.put(std::move(pOut));
   if (includeErrors_)
     iEvent.put(std::move(pErr));
 }

References cablingMapToken_, calib_, calibToken_, checkPixel(), clear(), control_pattern_size_, edm::DetSet< T >::data, error_data_, fill(), edm::EventSetup::getHandle(), SiPixelCalibConfiguration::getNTriggers(), iEvent, iEventCounter_, includeErrors_, intermediate_data_, eostools::move(), SiPixelCalibConfiguration::nVCal(), pattern_repeat_, setPattern(), store(), theCablingMap_, theGeometry_, trackerGeomToken_, and use_realeventnumber_.

◆ setPattern()

void SiPixelCalibDigiProducer::setPattern ( )

privatevirtual

Definition at line 199 of file SiPixelCalibDigiProducer.cc.

                                           {
   //  edm::LogInfo("SiPixelCalibProducer") << "in setPattern()" << std::endl;
   uint32_t patternnumber = (iEventCounter_ - 1) / pattern_repeat_;
   uint32_t rowpatternnumber = patternnumber / calib_->nColumnPatterns();
   uint32_t colpatternnumber = patternnumber % calib_->nColumnPatterns();
   edm::LogInfo("SiPixelCalibDigiProducer")
       << " rowpatternnumbers = " << rowpatternnumber << " " << colpatternnumber << " " << patternnumber << std::endl;
   // update currentpattern_
   std::vector<short> calibcols = calib_->getColumnPattern();
   std::vector<short> calibrows = calib_->getRowPattern();
   std::vector<short> temprowvals(0);
   std::vector<short> tempcolvals(0);
   uint32_t nminuscol = 0;
   uint32_t nminusrow = 0;
   uint32_t npatterns = 0;
   for (uint32_t icol = 0; icol < calibcols.size(); icol++) {
     if (calibcols[icol] == -1) {
       nminuscol++;
     } else if (nminuscol == colpatternnumber) {
       //edm::LogInfo("SiPixelCalibProducer") << "col " << calibcols[icol] << std::endl;
       short val = calibcols[icol];
       tempcolvals.push_back(val);
     } else if (nminuscol > colpatternnumber)
       break;
   }
   for (uint32_t irow = 0; irow < calibrows.size(); irow++) {
     // edm::LogInfo("SiPixelCalibProducer") << "row " << irow <<" "<< nminusrow<<" "  << calibrows[irow] << std::endl;
     if (calibrows[irow] == -1)
       nminusrow++;
     else if (nminusrow == rowpatternnumber) {
       short val = calibrows[irow];
       temprowvals.push_back(val);
     } else if (nminusrow > rowpatternnumber)
       break;
   }
   //now clean up the currentpattern_;
   while (currentpattern_.size() > temprowvals.size() * tempcolvals.size()) {
     currentpattern_.erase(currentpattern_.end());
   }
   for (uint32_t irow = 0; irow < temprowvals.size(); irow++) {
     for (uint32_t icol = 0; icol < tempcolvals.size(); icol++) {
       std::pair<short, short> pattern(temprowvals[irow], tempcolvals[icol]);
       npatterns++;
       if (npatterns > currentpattern_.size())
         currentpattern_.push_back(pattern);
       else
         currentpattern_[npatterns - 1] = pattern;
     }
   }
 }

References calib_, currentpattern_, SiPixelCalibConfiguration::getColumnPattern(), SiPixelCalibConfiguration::getRowPattern(), iEventCounter_, SiPixelCalibConfiguration::nColumnPatterns(), topSingleLeptonDQM_PU_cfi::pattern, pattern_repeat_, and heppy_batch::val.

Referenced by checkPixel(), and produce().

◆ store()

bool SiPixelCalibDigiProducer::store ( )

privatevirtual

Definition at line 82 of file SiPixelCalibDigiProducer.cc.

                                      {
   //  std::cout << "in store() " << std::endl;
   if (iEventCounter_ % pattern_repeat_ == 0) {
     //    std::cout << "now at event " << iEventCounter_ <<" where we save the calibration information into the CMSSW digi";
     return true;
   } else if (iEventCounter_ == calib_->expectedTotalEvents())
     return true;
   else
     return false;
   return true;
 }