#include <SiStripClusterizerConditionsGPU.h>

Classes
class	Data

class	DetToFed

Public Types
using	DetToFeds = std::vector< DetToFed >

Public Member Functions
const DetToFeds &	detToFeds () const

Data const &	getGPUProductAsync (cudaStream_t stream) const

	SiStripClusterizerConditionsGPU (const SiStripQuality &quality, const SiStripGain *gains, const SiStripNoises &noises)

	~SiStripClusterizerConditionsGPU ()=default

Static Public Attributes
static constexpr std::uint16_t	badBit = 1 << 15

Private Member Functions
void	setInvThickness (fedId_t fed, fedCh_t channel, float invthick)

void	setStrip (fedId_t fed, fedCh_t channel, stripId_t strip, std::uint16_t noise, float gain, bool bad)

Private Attributes
std::vector< detId_t, cms::cuda::HostAllocator< detId_t > >	detID_

DetToFeds	detToFeds_

std::vector< float, cms::cuda::HostAllocator< float > >	gain_

cms::cuda::ESProduct< Data >	gpuData_

std::vector< float, cms::cuda::HostAllocator< float > >	invthick_

std::vector< apvPair_t, cms::cuda::HostAllocator< apvPair_t > >	iPair_

std::vector< std::uint16_t, cms::cuda::HostAllocator< std::uint16_t > >	noise_

Detailed Description

Definition at line 31 of file SiStripClusterizerConditionsGPU.h.

Member Typedef Documentation

◆ DetToFeds

using stripgpu::SiStripClusterizerConditionsGPU::DetToFeds = std::vector<DetToFed>

Definition at line 48 of file SiStripClusterizerConditionsGPU.h.

Constructor & Destructor Documentation

◆ SiStripClusterizerConditionsGPU()

stripgpu::SiStripClusterizerConditionsGPU::SiStripClusterizerConditionsGPU	(	const SiStripQuality &	quality,
		const SiStripGain *	gains,
		const SiStripNoises &	noises
	)

Definition at line 13 of file SiStripClusterizerConditionsGPU.cc.

References a, b, officialStyle::chan, stripgpu::channelIndex(), getInfo::conn, detID_, detToFeds_, PedestalClient_cfi::gain, ecalph2::gains, SiStripNoises::getRawNoise(), SiStripGain::getStripGain(), iPair_, hgchebackDigitizer_cfi::noise, hgcalLayerClusters_cfi::noises, hltrates_dqm_sourceclient-live_cfg::offset, quality, siStripClusterTools::sensorThicknessInverse(), setInvThickness(), setStrip(), jetUpdater_cfi::sort, and digitizers_cfi::strip.

       : noise_(sistrip::NUMBER_OF_FEDS * sistrip::FEDCH_PER_FED * sistrip::STRIPS_PER_FEDCH),
         invthick_(sistrip::NUMBER_OF_FEDS * sistrip::FEDCH_PER_FED),
         detID_(sistrip::NUMBER_OF_FEDS * sistrip::FEDCH_PER_FED),
         iPair_(sistrip::NUMBER_OF_FEDS * sistrip::FEDCH_PER_FED),
         gain_(sistrip::NUMBER_OF_FEDS * sistrip::APVS_PER_FEDCH * sistrip::FEDCH_PER_FED) {
     // connected: map<DetID, std::vector<int>>
     // map of KEY=detid DATA=vector of apvs, maximum 6 APVs per detector module :
     const auto& connected = quality.cabling()->connected();
     // detCabling: map<DetID, std::vector<const FedChannelConnection *>
     // map of KEY=detid DATA=vector<FedChannelConnection>
     const auto& detCabling = quality.cabling()->getDetCabling();
 
     for (const auto& conn : connected) {
       const auto det = conn.first;
       if (!quality.IsModuleBad(det)) {
         const auto detConn_it = detCabling.find(det);
 
         if (detCabling.end() != detConn_it) {
           for (const auto& chan : (*detConn_it).second) {
             if (chan && chan->fedId() && chan->isConnected()) {
               const auto detID = chan->detId();
               const auto fedID = chan->fedId();
               const auto fedCh = chan->fedCh();
               const auto iPair = chan->apvPairNumber();
 
               detToFeds_.emplace_back(detID, iPair, fedID, fedCh);
 
               detID_[channelIndex(fedID, fedCh)] = detID;
               iPair_[channelIndex(fedID, fedCh)] = iPair;
               setInvThickness(fedID, fedCh, siStripClusterTools::sensorThicknessInverse(detID));
 
               auto offset = 256 * iPair;
 
               for (auto strip = 0; strip < 256; ++strip) {
                 const auto gainRange = gains->getRange(det);
 
                 const auto detstrip = strip + offset;
                 const std::uint16_t noise = SiStripNoises::getRawNoise(detstrip, noises.getRange(det));
                 const auto gain = SiStripGain::getStripGain(detstrip, gainRange);
                 const auto bad = quality.IsStripBad(quality.getRange(det), detstrip);
 
                 // gain is actually stored per-APV, not per-strip
                 setStrip(fedID, fedCh, detstrip, noise, gain, bad);
               }
             }
           }
         }
       }
     }
 
     std::sort(detToFeds_.begin(), detToFeds_.end(), [](const DetToFed& a, const DetToFed& b) {
       return a.detID() < b.detID() || (a.detID() == b.detID() && a.pair() < b.pair());
     });
   }

◆ ~SiStripClusterizerConditionsGPU()

stripgpu::SiStripClusterizerConditionsGPU::~SiStripClusterizerConditionsGPU ( )

default

Member Function Documentation

◆ detToFeds()

const DetToFeds& stripgpu::SiStripClusterizerConditionsGPU::detToFeds ( ) const

inline

Definition at line 108 of file SiStripClusterizerConditionsGPU.h.

References detToFeds_.

108 { return detToFeds_; }

stripgpu::SiStripClusterizerConditionsGPU::detToFeds_

DetToFeds detToFeds_

Definition: SiStripClusterizerConditionsGPU.h:133

◆ getGPUProductAsync()

SiStripClusterizerConditionsGPU::Data const & stripgpu::SiStripClusterizerConditionsGPU::getGPUProductAsync ( cudaStream_t stream ) const

Definition at line 72 of file SiStripClusterizerConditionsGPU.cc.

References cms::cuda::copyAsync(), data, detID_, gain_, gpuData_, invthick_, iPair_, noise_, and cms::cuda::stream.

                                  {
     auto const& data = gpuData_.dataForCurrentDeviceAsync(stream, [this](Data& data, cudaStream_t stream) {
       data.noise_ = cms::cuda::make_device_unique<std::uint16_t[]>(noise_.size(), stream);
       data.invthick_ = cms::cuda::make_device_unique<float[]>(invthick_.size(), stream);
       data.detID_ = cms::cuda::make_device_unique<detId_t[]>(detID_.size(), stream);
       data.iPair_ = cms::cuda::make_device_unique<apvPair_t[]>(iPair_.size(), stream);
       data.gain_ = cms::cuda::make_device_unique<float[]>(gain_.size(), stream);
 
       cms::cuda::copyAsync(data.noise_, noise_, stream);
       cms::cuda::copyAsync(data.invthick_, invthick_, stream);
       cms::cuda::copyAsync(data.detID_, detID_, stream);
       cms::cuda::copyAsync(data.iPair_, iPair_, stream);
       cms::cuda::copyAsync(data.gain_, gain_, stream);
 
       data.hostView_ = cms::cuda::make_host_unique<SiStripClusterizerConditionsGPU::Data::DeviceView>(stream);
       data.hostView_->noise_ = data.noise_.get();
       data.hostView_->invthick_ = data.invthick_.get();
       data.hostView_->detID_ = data.detID_.get();
       data.hostView_->iPair_ = data.iPair_.get();
       data.hostView_->gain_ = data.gain_.get();
 
       data.deviceView_ = cms::cuda::make_device_unique<SiStripClusterizerConditionsGPU::Data::DeviceView>(stream);
       cms::cuda::copyAsync(data.deviceView_, data.hostView_, stream);
     });
 
     return data;
   }

◆ setInvThickness()

void stripgpu::SiStripClusterizerConditionsGPU::setInvThickness	(	fedId_t	fed,
		fedCh_t	channel,
		float	invthick
	)

inlineprivate

Definition at line 119 of file SiStripClusterizerConditionsGPU.h.

References stripgpu::channelIndex(), and invthick_.

Referenced by SiStripClusterizerConditionsGPU().

                                                                        {
       invthick_[channelIndex(fed, channel)] = invthick;
     }

◆ setStrip()

void stripgpu::SiStripClusterizerConditionsGPU::setStrip	(	fedId_t	fed,
		fedCh_t	channel,
		stripId_t	strip,
		std::uint16_t	noise,
		float	gain,
		bool	bad
	)

inlineprivate

Definition at line 111 of file SiStripClusterizerConditionsGPU.h.

References stripgpu::apvIndex(), badBit, PedestalClient_cfi::gain, gain_, hgchebackDigitizer_cfi::noise, noise_, digitizers_cfi::strip, and stripgpu::stripIndex().

Referenced by SiStripClusterizerConditionsGPU().

                                                                                                           {
       gain_[apvIndex(fed, channel, strip)] = gain;
       noise_[stripIndex(fed, channel, strip)] = noise;
       if (bad) {
         noise_[stripIndex(fed, channel, strip)] |= badBit;
       }
     }