Inheritance diagram for SiPixelRawToClusterCUDAT< TrackerTraits >:

Public Types
using	GPUAlgo = pixelgpudetails::SiPixelRawToClusterGPUKernel< TrackerTraits >

Public Types inherited from edm::stream::EDProducer< edm::ExternalWork >
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

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

	~SiPixelRawToClusterCUDAT () override=default

Public Member Functions inherited from edm::stream::EDProducer< edm::ExternalWork >
	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 Member Functions
void	acquire (const edm::Event &iEvent, const edm::EventSetup &iSetup, edm::WaitingTaskWithArenaHolder waitingTaskHolder) override

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

Private Attributes
std::unique_ptr< SiPixelFedCablingTree >	cabling_

const SiPixelFedCablingMap *	cablingMap_ = nullptr

edm::ESGetToken< SiPixelFedCablingMap, SiPixelFedCablingMapRcd >	cablingMapToken_

edm::EDPutTokenT< cms::cuda::Product< SiPixelClustersCUDA > >	clusterPutToken_

const SiPixelClusterThresholds	clusterThresholds_

cms::cuda::ContextState	ctxState_

edm::EDPutTokenT< cms::cuda::Product< SiPixelDigiErrorsCUDA > >	digiErrorPutToken_

edm::EDPutTokenT< cms::cuda::Product< SiPixelDigisCUDA > >	digiPutToken_

PixelDataFormatter::Errors	errors_

std::vector< unsigned int >	fedIds_

edm::ESGetToken< SiPixelGainCalibrationForHLTGPU, SiPixelGainCalibrationForHLTGPURcd >	gainsToken_

GPUAlgo	gpuAlgo_

edm::ESGetToken< SiPixelROCsStatusAndMappingWrapper, CkfComponentsRecord >	gpuMapToken_

const bool	includeErrors_

uint32_t	nDigis_

edm::EDGetTokenT< FEDRawDataCollection >	rawGetToken_

edm::ESWatcher< SiPixelFedCablingMapRcd >	recordWatcher_

std::unique_ptr< PixelUnpackingRegions >	regions_

const bool	useQuality_

Detailed Description

template<typename TrackerTraits>
class SiPixelRawToClusterCUDAT< TrackerTraits >

Definition at line 46 of file SiPixelRawToClusterCUDA.cc.

Member Typedef Documentation

◆ GPUAlgo

template<typename TrackerTraits >

using SiPixelRawToClusterCUDAT< TrackerTraits >::GPUAlgo = pixelgpudetails::SiPixelRawToClusterGPUKernel<TrackerTraits>

Definition at line 52 of file SiPixelRawToClusterCUDA.cc.

Constructor & Destructor Documentation

◆ SiPixelRawToClusterCUDAT()

template<typename TrackerTraits >

SiPixelRawToClusterCUDAT< TrackerTraits >::SiPixelRawToClusterCUDAT ( const edm::ParameterSet & iConfig )

explicit

Definition at line 88 of file SiPixelRawToClusterCUDA.cc.

References edm::ParameterSet::getParameter().

     : rawGetToken_(consumes<FEDRawDataCollection>(iConfig.getParameter<edm::InputTag>("InputLabel"))),
       digiPutToken_(produces<cms::cuda::Product<SiPixelDigisCUDA>>()),
       clusterPutToken_(produces<cms::cuda::Product<SiPixelClustersCUDA>>()),
       gpuMapToken_(esConsumes<SiPixelROCsStatusAndMappingWrapper, CkfComponentsRecord>()),
       gainsToken_(esConsumes<SiPixelGainCalibrationForHLTGPU, SiPixelGainCalibrationForHLTGPURcd>()),
       cablingMapToken_(esConsumes<SiPixelFedCablingMap, SiPixelFedCablingMapRcd>(
           edm::ESInputTag("", iConfig.getParameter<std::string>("CablingMapLabel")))),
       includeErrors_(iConfig.getParameter<bool>("IncludeErrors")),
       useQuality_(iConfig.getParameter<bool>("UseQualityInfo")),
       clusterThresholds_{iConfig.getParameter<int32_t>("clusterThreshold_layer1"),
                          iConfig.getParameter<int32_t>("clusterThreshold_otherLayers"),
                          static_cast<float>(iConfig.getParameter<double>("VCaltoElectronGain")),
                          static_cast<float>(iConfig.getParameter<double>("VCaltoElectronGain_L1")),
                          static_cast<float>(iConfig.getParameter<double>("VCaltoElectronOffset")),
                          static_cast<float>(iConfig.getParameter<double>("VCaltoElectronOffset_L1"))} {
   if (includeErrors_) {
     digiErrorPutToken_ = produces<cms::cuda::Product<SiPixelDigiErrorsCUDA>>();
   }
 
   // regions
   if (!iConfig.getParameter<edm::ParameterSet>("Regions").getParameterNames().empty()) {
     regions_ = std::make_unique<PixelUnpackingRegions>(iConfig, consumesCollector());
   }
 }

◆ ~SiPixelRawToClusterCUDAT()

template<typename TrackerTraits >

SiPixelRawToClusterCUDAT< TrackerTraits >::~SiPixelRawToClusterCUDAT ( )

overridedefault

Member Function Documentation

◆ acquire()

template<typename TrackerTraits >

void SiPixelRawToClusterCUDAT< TrackerTraits >::acquire	(	const edm::Event &	iEvent,
		const edm::EventSetup &	iSetup,
		edm::WaitingTaskWithArenaHolder	waitingTaskHolder
	)

overrideprivate

Definition at line 145 of file SiPixelRawToClusterCUDA.cc.

References cms::cuda::assert(), Exception, l1tstage2_dqm_sourceclient-live_cfg::fedId, edm::EventSetup::getHandle(), edm::EventSetup::getTransientHandle(), RecoTauValidation_cfi::header, mps_fire::i, iEvent, pixelgpudetails::SiPixelRawToClusterGPUKernel< TrackerTraits >::WordFedAppender::initializeWordFed(), edm::MessageDrop::instance(), LogDebug, FEDNumbering::MINSiPixeluTCAFEDID, eostools::move(), l1ctLayer2EG_cff::nWords, l1tstage2_dqm_sourceclient-live_cfg::rawData, and isotrackNtupler::start.

                                                                                                        {
   cms::cuda::ScopedContextAcquire ctx{iEvent.streamID(), std::move(waitingTaskHolder), ctxState_};
 
   auto hgpuMap = iSetup.getHandle(gpuMapToken_);
   if (hgpuMap->hasQuality() != useQuality_) {
     throw cms::Exception("LogicError")
         << "UseQuality of the module (" << useQuality_
         << ") differs the one from SiPixelROCsStatusAndMappingWrapper. Please fix your configuration.";
   }
   // get the GPU product already here so that the async transfer can begin
   const auto* gpuMap = hgpuMap->getGPUProductAsync(ctx.stream());
 
   auto hgains = iSetup.getHandle(gainsToken_);
   // get the GPU product already here so that the async transfer can begin
   const auto* gpuGains = hgains->getGPUProductAsync(ctx.stream());
 
   cms::cuda::device::unique_ptr<unsigned char[]> modulesToUnpackRegional;
   const unsigned char* gpuModulesToUnpack;
 
   if (regions_) {
     regions_->run(iEvent, iSetup);
     LogDebug("SiPixelRawToCluster") << "region2unpack #feds: " << regions_->nFEDs();
     LogDebug("SiPixelRawToCluster") << "region2unpack #modules (BPIX,EPIX,total): " << regions_->nBarrelModules() << " "
                                     << regions_->nForwardModules() << " " << regions_->nModules();
     modulesToUnpackRegional = hgpuMap->getModToUnpRegionalAsync(*(regions_->modulesToUnpack()), ctx.stream());
     gpuModulesToUnpack = modulesToUnpackRegional.get();
   } else {
     gpuModulesToUnpack = hgpuMap->getModToUnpAllAsync(ctx.stream());
   }
 
   // initialize cabling map or update if necessary
   if (recordWatcher_.check(iSetup)) {
     // cabling map, which maps online address (fed->link->ROC->local pixel) to offline (DetId->global pixel)
     auto cablingMap = iSetup.getTransientHandle(cablingMapToken_);
     cablingMap_ = cablingMap.product();
     fedIds_ = cablingMap->fedIds();
     cabling_ = cablingMap->cablingTree();
     LogDebug("map version:") << cabling_->version();
   }
 
   const auto& buffers = iEvent.get(rawGetToken_);
 
   errors_.clear();
 
   // GPU specific: Data extraction for RawToDigi GPU
   unsigned int wordCounter = 0;
   unsigned int fedCounter = 0;
   bool errorsInEvent = false;
 
   std::vector<unsigned int> index(fedIds_.size(), 0);
   std::vector<cms_uint32_t const*> start(fedIds_.size(), nullptr);
   std::vector<ptrdiff_t> words(fedIds_.size(), 0);
 
   // In CPU algorithm this loop is part of PixelDataFormatter::interpretRawData()
   ErrorChecker errorcheck;
   for (uint32_t i = 0; i < fedIds_.size(); ++i) {
     const int fedId = fedIds_[i];
     if (regions_ && !regions_->mayUnpackFED(fedId))
       continue;
 
     // for GPU
     // first 150 index stores the fedId and next 150 will store the
     // start index of word in that fed
     assert(fedId >= FEDNumbering::MINSiPixeluTCAFEDID);
     fedCounter++;
 
     // get event data for this fed
     const FEDRawData& rawData = buffers.FEDData(fedId);
 
     // GPU specific
     int nWords = rawData.size() / sizeof(cms_uint64_t);
     if (nWords == 0) {
       continue;
     }
 
     // check CRC bit
     const cms_uint64_t* trailer = reinterpret_cast<const cms_uint64_t*>(rawData.data()) + (nWords - 1);
     if (not errorcheck.checkCRC(errorsInEvent, fedId, trailer, errors_)) {
       continue;
     }
 
     // check headers
     const cms_uint64_t* header = reinterpret_cast<const cms_uint64_t*>(rawData.data());
     header--;
     bool moreHeaders = true;
     while (moreHeaders) {
       header++;
       bool headerStatus = errorcheck.checkHeader(errorsInEvent, fedId, header, errors_);
       moreHeaders = headerStatus;
     }
 
     // check trailers
     bool moreTrailers = true;
     trailer++;
     while (moreTrailers) {
       trailer--;
       bool trailerStatus = errorcheck.checkTrailer(errorsInEvent, fedId, nWords, trailer, errors_);
       moreTrailers = trailerStatus;
     }
 
     const cms_uint32_t* bw = (const cms_uint32_t*)(header + 1);
     const cms_uint32_t* ew = (const cms_uint32_t*)(trailer);
 
     assert(0 == (ew - bw) % 2);
     index[i] = wordCounter;
     start[i] = bw;
     words[i] = (ew - bw);
     wordCounter += (ew - bw);
 
   }  // end of for loop
 
   nDigis_ = wordCounter;
 
   if (nDigis_ == 0)
     return;
 
   // copy the FED data to a single cpu buffer
   typename GPUAlgo::WordFedAppender wordFedAppender(nDigis_, ctx.stream());
   for (uint32_t i = 0; i < fedIds_.size(); ++i) {
     wordFedAppender.initializeWordFed(fedIds_[i], index[i], start[i], words[i]);
   }
 
   gpuAlgo_.makePhase1ClustersAsync(clusterThresholds_,
                                    gpuMap,
                                    gpuModulesToUnpack,
                                    gpuGains,
                                    wordFedAppender,
                                    std::move(errors_),
                                    wordCounter,
                                    fedCounter,
                                    useQuality_,
                                    includeErrors_,
                                    edm::MessageDrop::instance()->debugEnabled,
                                    ctx.stream());
 }

◆ fillDescriptions()

template<typename TrackerTraits >

void SiPixelRawToClusterCUDAT< TrackerTraits >::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

static

Definition at line 115 of file SiPixelRawToClusterCUDA.cc.

References edm::ParameterSetDescription::addOptional(), edm::ConfigurationDescriptions::addWithDefaultLabel(), gpuClustering::clusterThresholdLayerOne, gpuClustering::clusterThresholdOtherLayers, submitPVResolutionJobs::desc, ProducerED_cfi::InputTag, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                                          {
   edm::ParameterSetDescription desc;
   desc.add<bool>("IncludeErrors", true);
   desc.add<bool>("UseQualityInfo", false);
   // Note: this parameter is obsolete: it is ignored and will have no effect.
   // It is kept to avoid breaking older configurations, and will not be printed in the generated cfi.py file.
   desc.addOptionalNode(edm::ParameterDescription<uint32_t>("MaxFEDWords", 0, true), false)
       ->setComment("This parameter is obsolete and will be ignored.");
   //Clustering Thresholds
   desc.add<int32_t>("clusterThreshold_layer1", gpuClustering::clusterThresholdLayerOne);
   desc.add<int32_t>("clusterThreshold_otherLayers", gpuClustering::clusterThresholdOtherLayers);
   desc.add<double>("VCaltoElectronGain", 47.f);
   desc.add<double>("VCaltoElectronGain_L1", 50.f);
   desc.add<double>("VCaltoElectronOffset", -60.f);
   desc.add<double>("VCaltoElectronOffset_L1", -670.f);
   desc.add<edm::InputTag>("InputLabel", edm::InputTag("rawDataCollector"));
   {
     edm::ParameterSetDescription psd0;
     psd0.addOptional<std::vector<edm::InputTag>>("inputs");
     psd0.addOptional<std::vector<double>>("deltaPhi");
     psd0.addOptional<std::vector<double>>("maxZ");
     psd0.addOptional<edm::InputTag>("beamSpot");
     desc.add<edm::ParameterSetDescription>("Regions", psd0)
         ->setComment("## Empty Regions PSet means complete unpacking");
   }
   desc.add<std::string>("CablingMapLabel", "")->setComment("CablingMap label");  //Tav
   descriptions.addWithDefaultLabel(desc);
 }

◆ produce()

template<typename TrackerTraits >

void SiPixelRawToClusterCUDAT< TrackerTraits >::produce	(	edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

overrideprivate

Definition at line 284 of file SiPixelRawToClusterCUDA.cc.

References iEvent, eostools::move(), pixelTopology::Phase1::numberOfModules, and createJobs::tmp.

                                                                                                    {
   cms::cuda::ScopedContextProduce ctx{ctxState_};
 
   if (nDigis_ == 0) {
     // Cannot use the default constructor here, as it would not allocate memory.
     // In the case of no digis, clusters_d are not being instantiated, but are
     // still used downstream to initialize TrackingRecHitSoADevice. If there
     // are no valid pointers to clusters' Collection columns, instantiation
     // of TrackingRecHits fail. Example: workflow 11604.0
     SiPixelDigisCUDA digis_d = SiPixelDigisCUDA(nDigis_, ctx.stream());
     SiPixelClustersCUDA clusters_d = SiPixelClustersCUDA(pixelTopology::Phase1::numberOfModules, ctx.stream());
     ctx.emplace(iEvent, digiPutToken_, std::move(digis_d));
     ctx.emplace(iEvent, clusterPutToken_, std::move(clusters_d));
     if (includeErrors_) {
       ctx.emplace(iEvent, digiErrorPutToken_, SiPixelDigiErrorsCUDA{});
     }
     return;
   }
 
   auto tmp = gpuAlgo_.getResults();
   ctx.emplace(iEvent, digiPutToken_, std::move(tmp.first));
   ctx.emplace(iEvent, clusterPutToken_, std::move(tmp.second));
   if (includeErrors_) {
     ctx.emplace(iEvent, digiErrorPutToken_, gpuAlgo_.getErrors());
   }
 }

Member Data Documentation

◆ cabling_

template<typename TrackerTraits >

std::unique_ptr<SiPixelFedCablingTree> SiPixelRawToClusterCUDAT< TrackerTraits >::cabling_

private

Definition at line 73 of file SiPixelRawToClusterCUDA.cc.

◆ cablingMap_

template<typename TrackerTraits >

const SiPixelFedCablingMap* SiPixelRawToClusterCUDAT< TrackerTraits >::cablingMap_ = nullptr

private

Definition at line 75 of file SiPixelRawToClusterCUDA.cc.

◆ cablingMapToken_

template<typename TrackerTraits >

edm::ESGetToken<SiPixelFedCablingMap, SiPixelFedCablingMapRcd> SiPixelRawToClusterCUDAT< TrackerTraits >::cablingMapToken_

private

Definition at line 71 of file SiPixelRawToClusterCUDA.cc.

◆ clusterPutToken_

template<typename TrackerTraits >

edm::EDPutTokenT<cms::cuda::Product<SiPixelClustersCUDA> > SiPixelRawToClusterCUDAT< TrackerTraits >::clusterPutToken_

private

Definition at line 64 of file SiPixelRawToClusterCUDA.cc.

◆ clusterThresholds_

template<typename TrackerTraits >

const SiPixelClusterThresholds SiPixelRawToClusterCUDAT< TrackerTraits >::clusterThresholds_

private

Definition at line 84 of file SiPixelRawToClusterCUDA.cc.

◆ ctxState_

template<typename TrackerTraits >

cms::cuda::ContextState SiPixelRawToClusterCUDAT< TrackerTraits >::ctxState_

private

Definition at line 66 of file SiPixelRawToClusterCUDA.cc.

◆ digiErrorPutToken_

template<typename TrackerTraits >

edm::EDPutTokenT<cms::cuda::Product<SiPixelDigiErrorsCUDA> > SiPixelRawToClusterCUDAT< TrackerTraits >::digiErrorPutToken_

private

Definition at line 63 of file SiPixelRawToClusterCUDA.cc.

◆ digiPutToken_

template<typename TrackerTraits >

edm::EDPutTokenT<cms::cuda::Product<SiPixelDigisCUDA> > SiPixelRawToClusterCUDAT< TrackerTraits >::digiPutToken_

private

Definition at line 62 of file SiPixelRawToClusterCUDA.cc.

◆ errors_

template<typename TrackerTraits >

PixelDataFormatter::Errors SiPixelRawToClusterCUDAT< TrackerTraits >::errors_

private

Definition at line 79 of file SiPixelRawToClusterCUDA.cc.

◆ fedIds_

template<typename TrackerTraits >

std::vector<unsigned int> SiPixelRawToClusterCUDAT< TrackerTraits >::fedIds_

private

Definition at line 74 of file SiPixelRawToClusterCUDA.cc.

◆ gainsToken_

template<typename TrackerTraits >

edm::ESGetToken<SiPixelGainCalibrationForHLTGPU, SiPixelGainCalibrationForHLTGPURcd> SiPixelRawToClusterCUDAT< TrackerTraits >::gainsToken_

private

Definition at line 70 of file SiPixelRawToClusterCUDA.cc.

◆ gpuAlgo_

template<typename TrackerTraits >

GPUAlgo SiPixelRawToClusterCUDAT< TrackerTraits >::gpuAlgo_

private

Definition at line 78 of file SiPixelRawToClusterCUDA.cc.

◆ gpuMapToken_

template<typename TrackerTraits >

edm::ESGetToken<SiPixelROCsStatusAndMappingWrapper, CkfComponentsRecord> SiPixelRawToClusterCUDAT< TrackerTraits >::gpuMapToken_

private

Definition at line 69 of file SiPixelRawToClusterCUDA.cc.

◆ includeErrors_

template<typename TrackerTraits >

const bool SiPixelRawToClusterCUDAT< TrackerTraits >::includeErrors_

private

Definition at line 81 of file SiPixelRawToClusterCUDA.cc.

◆ nDigis_

template<typename TrackerTraits >

uint32_t SiPixelRawToClusterCUDAT< TrackerTraits >::nDigis_

private

Definition at line 83 of file SiPixelRawToClusterCUDA.cc.

◆ rawGetToken_

template<typename TrackerTraits >

edm::EDGetTokenT<FEDRawDataCollection> SiPixelRawToClusterCUDAT< TrackerTraits >::rawGetToken_

private

Definition at line 60 of file SiPixelRawToClusterCUDA.cc.

◆ recordWatcher_

template<typename TrackerTraits >

edm::ESWatcher<SiPixelFedCablingMapRcd> SiPixelRawToClusterCUDAT< TrackerTraits >::recordWatcher_

private

Definition at line 68 of file SiPixelRawToClusterCUDA.cc.

◆ regions_

template<typename TrackerTraits >

std::unique_ptr<PixelUnpackingRegions> SiPixelRawToClusterCUDAT< TrackerTraits >::regions_

private

Definition at line 76 of file SiPixelRawToClusterCUDA.cc.

◆ useQuality_

template<typename TrackerTraits >

const bool SiPixelRawToClusterCUDAT< TrackerTraits >::useQuality_

private

Definition at line 82 of file SiPixelRawToClusterCUDA.cc.

Public Types

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

template<typename TrackerTraits> class SiPixelRawToClusterCUDAT< TrackerTraits >

Member Typedef Documentation

◆ GPUAlgo

Constructor & Destructor Documentation

◆ SiPixelRawToClusterCUDAT()

◆ ~SiPixelRawToClusterCUDAT()

Member Function Documentation

◆ acquire()

◆ fillDescriptions()

◆ produce()

Member Data Documentation

◆ cabling_

◆ cablingMap_

◆ cablingMapToken_

◆ clusterPutToken_

◆ clusterThresholds_

◆ ctxState_

◆ digiErrorPutToken_

◆ digiPutToken_

◆ errors_

◆ fedIds_

◆ gainsToken_

◆ gpuAlgo_

◆ gpuMapToken_

◆ includeErrors_

◆ nDigis_

◆ rawGetToken_

◆ recordWatcher_

◆ regions_

◆ useQuality_

template<typename TrackerTraits>
class SiPixelRawToClusterCUDAT< TrackerTraits >