SiStripObjects/src/SiStripClusterizerConditionsGPU.cc

0001 #include "HeterogeneousCore/CUDAUtilities/interface/device_unique_ptr.h"
0002 #include "HeterogeneousCore/CUDAUtilities/interface/copyAsync.h"
0003
0004 #include "CondFormats/SiStripObjects/interface/SiStripNoises.h"
0005 #include "CalibFormats/SiStripObjects/interface/SiStripGain.h"
0006 #include "CalibFormats/SiStripObjects/interface/SiStripDetCabling.h"
0007 #include "CalibFormats/SiStripObjects/interface/SiStripQuality.h"
0008 #include "CalibFormats/SiStripObjects/interface/SiStripClusterizerConditionsGPU.h"
0009
0010 #include "DataFormats/SiStripCluster/interface/SiStripClusterTools.h"
0011
0012 namespace stripgpu {
0013   SiStripClusterizerConditionsGPU::SiStripClusterizerConditionsGPU(const SiStripQuality& quality,
0014                                                                    const SiStripGain* gains,
0015                                                                    const SiStripNoises& noises)
0016
0017       : noise_(sistrip::NUMBER_OF_FEDS * sistrip::FEDCH_PER_FED * sistrip::STRIPS_PER_FEDCH),
0018         invthick_(sistrip::NUMBER_OF_FEDS * sistrip::FEDCH_PER_FED),
0019         detID_(sistrip::NUMBER_OF_FEDS * sistrip::FEDCH_PER_FED),
0020         iPair_(sistrip::NUMBER_OF_FEDS * sistrip::FEDCH_PER_FED),
0021         gain_(sistrip::NUMBER_OF_FEDS * sistrip::APVS_PER_FEDCH * sistrip::FEDCH_PER_FED) {
0022     // connected: map<DetID, std::vector<int>>
0023     // map of KEY=detid DATA=vector of apvs, maximum 6 APVs per detector module :
0024     const auto& connected = quality.cabling()->connected();
0025     // detCabling: map<DetID, std::vector<const FedChannelConnection *>
0026     // map of KEY=detid DATA=vector<FedChannelConnection>
0027     const auto& detCabling = quality.cabling()->getDetCabling();
0028
0029     for (const auto& conn : connected) {
0030       const auto det = conn.first;
0031       if (!quality.IsModuleBad(det)) {
0032         const auto detConn_it = detCabling.find(det);
0033
0034         if (detCabling.end() != detConn_it) {
0035           for (const auto& chan : (*detConn_it).second) {
0036             if (chan && chan->fedId() && chan->isConnected()) {
0037               const auto detID = chan->detId();
0038               const auto fedID = chan->fedId();
0039               const auto fedCh = chan->fedCh();
0040               const auto iPair = chan->apvPairNumber();
0041
0042               detToFeds_.emplace_back(detID, iPair, fedID, fedCh);
0043
0044               detID_[channelIndex(fedID, fedCh)] = detID;
0045               iPair_[channelIndex(fedID, fedCh)] = iPair;
0046               setInvThickness(fedID, fedCh, siStripClusterTools::sensorThicknessInverse(detID));
0047
0048               auto offset = 256 * iPair;
0049
0050               for (auto strip = 0; strip < 256; ++strip) {
0051                 const auto gainRange = gains->getRange(det);
0052
0053                 const auto detstrip = strip + offset;
0054                 const std::uint16_t noise = SiStripNoises::getRawNoise(detstrip, noises.getRange(det));
0055                 const auto gain = SiStripGain::getStripGain(detstrip, gainRange);
0056                 const auto bad = quality.IsStripBad(quality.getRange(det), detstrip);
0057
0058                 // gain is actually stored per-APV, not per-strip
0059                 setStrip(fedID, fedCh, detstrip, noise, gain, bad);
0060               }
0061             }
0062           }
0063         }
0064       }
0065     }
0066
0067     std::sort(detToFeds_.begin(), detToFeds_.end(), [](const DetToFed& a, const DetToFed& b) {
0068       return a.detID() < b.detID() || (a.detID() == b.detID() && a.pair() < b.pair());
0069     });
0070   }
0071
0072   SiStripClusterizerConditionsGPU::Data const& SiStripClusterizerConditionsGPU::getGPUProductAsync(
0073       cudaStream_t stream) const {
0074     auto const& data = gpuData_.dataForCurrentDeviceAsync(stream, [this](Data& data, cudaStream_t stream) {
0075       data.noise_ = cms::cuda::make_device_unique<std::uint16_t[]>(noise_.size(), stream);
0076       data.invthick_ = cms::cuda::make_device_unique<float[]>(invthick_.size(), stream);
0077       data.detID_ = cms::cuda::make_device_unique<detId_t[]>(detID_.size(), stream);
0078       data.iPair_ = cms::cuda::make_device_unique<apvPair_t[]>(iPair_.size(), stream);
0079       data.gain_ = cms::cuda::make_device_unique<float[]>(gain_.size(), stream);
0080
0081       cms::cuda::copyAsync(data.noise_, noise_, stream);
0082       cms::cuda::copyAsync(data.invthick_, invthick_, stream);
0083       cms::cuda::copyAsync(data.detID_, detID_, stream);
0084       cms::cuda::copyAsync(data.iPair_, iPair_, stream);
0085       cms::cuda::copyAsync(data.gain_, gain_, stream);
0086
0087       data.hostView_ = cms::cuda::make_host_unique<SiStripClusterizerConditionsGPU::Data::DeviceView>(stream);
0088       data.hostView_->noise_ = data.noise_.get();
0089       data.hostView_->invthick_ = data.invthick_.get();
0090       data.hostView_->detID_ = data.detID_.get();
0091       data.hostView_->iPair_ = data.iPair_.get();
0092       data.hostView_->gain_ = data.gain_.get();
0093
0094       data.deviceView_ = cms::cuda::make_device_unique<SiStripClusterizerConditionsGPU::Data::DeviceView>(stream);
0095       cms::cuda::copyAsync(data.deviceView_, data.hostView_, stream);
0096     });
0097
0098     return data;
0099   }
0100 }  // namespace stripgpu