Inheritance diagram for SiPixelDigiMorphing:

Public Member Functions
void	produce (edm::Event &e, const edm::EventSetup &c) override

	SiPixelDigiMorphing (const edm::ParameterSet &conf)

	~SiPixelDigiMorphing () override=default

Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default

	EDProducer (const EDProducer &)=delete

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

const EDProducer &	operator= (const EDProducer &)=delete

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

Private Types
enum	MorphOption { kDilate, kErode }

Private Member Functions
void	morph (uint64_t const imap, uint64_t omap, uint64_t *const kernel, MorphOption op) const

Private Attributes
const uint32_t	fakeAdc_

const int32_t	iters_

std::vector< uint64_t >	kernel1_

std::vector< uint64_t >	kernel2_

int32_t	ksize_

uint64_t	mask_

const int32_t	ncols_

int32_t	ncols_r_

const int32_t	nrocs_

const int32_t	nrows_

edm::EDGetTokenT < edm::DetSetVector< PixelDigi > >	tPixelDigi_

edm::EDPutTokenT < edm::DetSetVector< PixelDigi > >	tPutPixelDigi_

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer<>
using	CacheTypes = CacheContexts< T...>

using	GlobalCache = typename CacheTypes::GlobalCache

using	HasAbility = AbilityChecker< T...>

using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache

using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache

using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >

using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache

using	RunCache = typename CacheTypes::RunCache

using	RunContext = RunContextT< RunCache, GlobalCache >

using	RunSummaryCache = typename CacheTypes::RunSummaryCache

Detailed Description

Definition at line 16 of file SiPixelDigiMorphing.cc.

Member Enumeration Documentation

enum SiPixelDigiMorphing::MorphOption

private

Enumerator
kDilate
kErode

Definition at line 41 of file SiPixelDigiMorphing.cc.

41 { kDilate, kErode };

SiPixelDigiMorphing::kDilate

Definition: SiPixelDigiMorphing.cc:41

SiPixelDigiMorphing::kErode

Definition: SiPixelDigiMorphing.cc:41

Constructor & Destructor Documentation

SiPixelDigiMorphing::SiPixelDigiMorphing ( const edm::ParameterSet & conf )

explicit

Definition at line 46 of file SiPixelDigiMorphing.cc.

References Exception, edm::ParameterSet::getParameter(), cuy::ii, iters_, dqmiolumiharvest::j, relval_steps::k2, kernel1_, kernel2_, ksize_, mask_, ncols_, ncols_r_, nrocs_, and w().

     : tPixelDigi_(consumes(conf.getParameter<edm::InputTag>("src"))),
       tPutPixelDigi_(produces<edm::DetSetVector<PixelDigi>>()),
       nrows_(conf.getParameter<int32_t>("nrows")),
       ncols_(conf.getParameter<int32_t>("ncols")),
       nrocs_(conf.getParameter<int32_t>("nrocs")),
       iters_(conf.getParameter<int32_t>("iters")),
       fakeAdc_(conf.getParameter<uint32_t>("fakeAdc")) {
   if (ncols_ % nrocs_ == 0) {
     ncols_r_ = ncols_ / nrocs_;
   } else {
     throw cms::Exception("Configuration") << "[SiPixelDigiMorphing]:"
                                           << " number of columns not divisible with"
                                           << " number of ROCs\n";
   }
 
   if (ncols_r_ + 2 * iters_ <= int(sizeof(uint64_t) * 8)) {
     ksize_ = 2 * iters_ + 1;
   } else {
     throw cms::Exception("Configuration") << "[SiPixelDigiMorphing]:"
                                           << " too many columns per ROC"
                                           << " or too many iterations set\n"
                                           << " Ncol/Nrocs+2*iters should not be"
                                           << " more than " << sizeof(uint64_t) * 8 << "\n";
   }
 
   std::vector<int32_t> k1(conf.getParameter<std::vector<int32_t>>("kernel1"));
   std::vector<int32_t> k2(conf.getParameter<std::vector<int32_t>>("kernel2"));
 
   kernel1_.resize(ksize_, 0);
   kernel2_.resize(ksize_, 0);
   mask_ = 0;
   int w = (ncols_r_ + 2 * iters_) / ksize_ + ((ncols_r_ + 2 * iters_) % ksize_ != 0);
   for (int j = 0; j < w; j++) {
     for (int ii = 0; ii < ksize_; ii++) {
       kernel1_[ii] <<= ksize_;
       kernel1_[ii] |= k1[ii];
       kernel2_[ii] <<= ksize_;
       kernel2_[ii] |= k2[ii];
     }
     mask_ <<= ksize_;
     mask_ |= 1;
   }
   mask_ <<= iters_;
 }

SiPixelDigiMorphing::~SiPixelDigiMorphing ( )

overridedefault

Member Function Documentation

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

static

Definition at line 92 of file SiPixelDigiMorphing.cc.

References edm::ParameterSetDescription::add(), edm::ConfigurationDescriptions::addWithDefaultLabel(), submitPVResolutionJobs::desc, and HLT_FULL_cff::InputTag.

                                                                                      {
   edm::ParameterSetDescription desc;
 
   desc.add<edm::InputTag>("src", edm::InputTag("siPixelDigis"));
   desc.add<int32_t>("nrows", 160);
   desc.add<int32_t>("ncols", 416);
   desc.add<int32_t>("nrocs", 8);
   desc.add<int32_t>("iters", 1);
   desc.add<std::vector<int32_t>>("kernel1", {7, 7, 7});
   desc.add<std::vector<int32_t>>("kernel2", {2, 7, 2});
   desc.add<uint32_t>("fakeAdc", 100);
 
   descriptions.addWithDefaultLabel(desc);
 }

void SiPixelDigiMorphing::morph	(	uint64_t *const	imap,
		uint64_t *	omap,
		uint64_t *const	kernel,
		MorphOption	op
	)		const

private

Definition at line 166 of file SiPixelDigiMorphing.cc.

References b, mps_fire::i, cuy::ii, iters_, findQualityFiles::jj, kErode, ksize_, visualization-live-secondInstance_cfg::m, mask_, nrocs_, nrows_, class-composition::o, PixelMapPlotter::roc, and findQualityFiles::v.

Referenced by produce().

                                                                                                                   {
   uint64_t* i[ksize_];          // i(nput)
   uint64_t* o = omap + iters_;  // o(output)
   unsigned char valid = 0;
   unsigned char const validMask = (1 << ksize_) - 1;
   uint64_t m[ksize_];  // m(ask)
 
   for (int ii = 0; ii < ksize_; ii++) {
     i[ii] = imap + ii;
     valid = (valid << 1) | (*i[ii] != 0);
     m[ii] = mask_ << ii;
   }
 
   for (int roc = 0; roc < nrocs_; roc++, o += 2 * iters_) {
     for (int row = 0; row < nrows_; row++, o++) {
       if ((valid & validMask) != 0) {
         for (int jj = 0; jj < ksize_; jj++) {
           for (int ii = 0; ii < ksize_; ii++) {
             uint64_t v = (*i[ii]) & (kernel[ii] << jj);  // v(ector)
             if (op == kErode)
               v ^= (kernel[ii] << jj);
             uint64_t vv = v;  // vv(vector bit - shifted and contracted)
             for (int b = 1; b < ksize_; b++)
               vv |= (v >> b);
             *o |= ((vv << iters_) & m[jj]);
           }
           if (op == kErode)
             *o ^= m[jj];
         }
       }
       for (int ii = 0; ii < ksize_; ii++)
         i[ii]++;
       valid = (valid << 1) | (*i[ksize_ - 1] != 0);
     }
     for (int ii = 0; ii < ksize_; ii++) {
       i[ii] += 2 * iters_;
       valid = (valid << 1) | (*i[ii] != 0);
     }
   }
 }

void SiPixelDigiMorphing::produce	(	edm::Event &	e,
		const edm::EventSetup &	c
	)

override

Definition at line 107 of file SiPixelDigiMorphing.cc.

References c, cuy::col, fakeAdc_, edm::Event::get(), mps_fire::i, iters_, kDilate, kernel1_, kernel2_, kErode, morph(), eostools::move(), ncols_r_, nrocs_, nrows_, class-composition::o, edm::Event::put(), alignCSCRings::r, PixelMapPlotter::roc, tPixelDigi_, and tPutPixelDigi_.

                                                                       {
   auto const& inputDigi = e.get(tPixelDigi_);
 
   auto outputDigis = std::make_unique<edm::DetSetVector<PixelDigi>>();
 
   const int rocSize = nrows_ + 2 * iters_;
   const int arrSize = nrocs_ * rocSize;
 
   uint64_t imap[arrSize];
   uint64_t map1[arrSize];
   uint64_t map2[arrSize];
 
   for (auto const& ds : inputDigi) {
     auto rawId = ds.detId();
     edm::DetSet<PixelDigi>* detDigis = nullptr;
     detDigis = &(outputDigis->find_or_insert(rawId));
 
     memset(imap, 0, arrSize * sizeof(uint64_t));
     for (auto const& di : ds) {
       int r = int(di.column()) / ncols_r_;
       int c = int(di.column()) % ncols_r_;
       imap[r * rocSize + di.row() + iters_] |= uint64_t(1) << (c + iters_);
       if (r > 0 && c < iters_) {
         imap[(r - 1) * rocSize + di.row() + iters_] |= uint64_t(1) << (c + ncols_r_ + iters_);
       } else if (++r < nrocs_ && c >= ncols_r_ - iters_) {
         imap[r * rocSize + di.row() + iters_] |= uint64_t(1) << (c - ncols_r_ + iters_);
       }
       (*detDigis).data.emplace_back(di.row(), di.column(), di.adc(), 0);
     }
 
     std::memcpy(map1, imap, arrSize * sizeof(uint64_t));
     memset(map2, 0, arrSize * sizeof(uint64_t));
 
     morph(map1, map2, kernel1_.data(), kDilate);
     morph(map2, map1, kernel2_.data(), kErode);
 
     uint64_t* i = imap + iters_;
     uint64_t* o = map1 + iters_;
     for (int roc = 0; roc < nrocs_; roc++, i += 2 * iters_, o += 2 * iters_) {
       for (int row = 0; row < nrows_; row++, i++, o++) {
         if (*o == 0)
           continue;
         *o >>= iters_;
         *i >>= iters_;
         for (int col = 0; col < ncols_r_; col++, (*i) >>= 1, (*o) >>= 1) {
           if (*o == 0)
             break;
           if (((*i) & uint64_t(1)) == 1)
             continue;
           if (((*o) & uint64_t(1)) == 1) {
             (*detDigis).data.emplace_back(row, roc * ncols_r_ + col, fakeAdc_, 1);
           }
         }
       }
     }
   }
   e.put(tPutPixelDigi_, std::move(outputDigis));
 }