HcalPedestalWidthsGPU Class Reference

#include <HcalPedestalWidthsGPU.h>

Classes
struct	Product

Public Member Functions
Product const &	getProduct (cudaStream_t) const
	HcalPedestalWidthsGPU (HcalPedestalWidths const &)
bool	unitIsADC () const
	~HcalPedestalWidthsGPU ()=default

Private Attributes
cms::cuda::ESProduct< Product >	product_
std::vector< float, cms::cuda::HostAllocator < float > >	sigma00_
std::vector< float, cms::cuda::HostAllocator < float > >	sigma01_
std::vector< float, cms::cuda::HostAllocator < float > >	sigma02_
std::vector< float, cms::cuda::HostAllocator < float > >	sigma03_
std::vector< float, cms::cuda::HostAllocator < float > >	sigma10_
std::vector< float, cms::cuda::HostAllocator < float > >	sigma11_
std::vector< float, cms::cuda::HostAllocator < float > >	sigma12_
std::vector< float, cms::cuda::HostAllocator < float > >	sigma13_
std::vector< float, cms::cuda::HostAllocator < float > >	sigma20_
std::vector< float, cms::cuda::HostAllocator < float > >	sigma21_
std::vector< float, cms::cuda::HostAllocator < float > >	sigma22_
std::vector< float, cms::cuda::HostAllocator < float > >	sigma23_
std::vector< float, cms::cuda::HostAllocator < float > >	sigma30_
std::vector< float, cms::cuda::HostAllocator < float > >	sigma31_
std::vector< float, cms::cuda::HostAllocator < float > >	sigma32_
std::vector< float, cms::cuda::HostAllocator < float > >	sigma33_
uint64_t	totalChannels_
bool	unitIsADC_

Detailed Description

Definition at line 13 of file HcalPedestalWidthsGPU.h.

Constructor & Destructor Documentation

HcalPedestalWidthsGPU::HcalPedestalWidthsGPU

(

HcalPedestalWidths const &

pedestals

)

Definition at line 7 of file HcalPedestalWidthsGPU.cc.

References HcalPedestalWidths::isADC().

    : unitIsADC_{pedestals.isADC()},
      totalChannels_{pedestals.getAllContainers()[0].second.size() + pedestals.getAllContainers()[1].second.size()},
      sigma00_(totalChannels_),
      sigma01_(totalChannels_),
      sigma02_(totalChannels_),
      sigma03_(totalChannels_),
      sigma10_(totalChannels_),
      sigma11_(totalChannels_),
      sigma12_(totalChannels_),
      sigma13_(totalChannels_),
      sigma20_(totalChannels_),
      sigma21_(totalChannels_),
      sigma22_(totalChannels_),
      sigma23_(totalChannels_),
      sigma30_(totalChannels_),
      sigma31_(totalChannels_),
      sigma32_(totalChannels_),
      sigma33_(totalChannels_) {
  auto const containers = pedestals.getAllContainers();

  // fill in hb
  auto const& barrelValues = containers[0].second;
  for (uint64_t i = 0; i < barrelValues.size(); ++i) {
    sigma00_[i] = *(barrelValues[i].getValues() /* + 0 */);
    sigma01_[i] = *(barrelValues[i].getValues() + 1);
    sigma02_[i] = *(barrelValues[i].getValues() + 2);
    sigma03_[i] = *(barrelValues[i].getValues() + 3);
    sigma10_[i] = *(barrelValues[i].getValues() + 3);
    sigma11_[i] = *(barrelValues[i].getValues() + 5);
    sigma12_[i] = *(barrelValues[i].getValues() + 6);
    sigma13_[i] = *(barrelValues[i].getValues() + 7);
    sigma20_[i] = *(barrelValues[i].getValues() + 8);
    sigma21_[i] = *(barrelValues[i].getValues() + 9);
    sigma22_[i] = *(barrelValues[i].getValues() + 10);
    sigma23_[i] = *(barrelValues[i].getValues() + 11);
    sigma30_[i] = *(barrelValues[i].getValues() + 12);
    sigma31_[i] = *(barrelValues[i].getValues() + 13);
    sigma32_[i] = *(barrelValues[i].getValues() + 14);
    sigma33_[i] = *(barrelValues[i].getValues() + 15);
  }

  // fill in he
  auto const& endcapValues = containers[1].second;
  auto const offset = barrelValues.size();
  for (uint64_t i = 0; i < endcapValues.size(); ++i) {
    sigma00_[i + offset] = *(endcapValues[i].getValues() /* + 0 */);
    sigma01_[i + offset] = *(endcapValues[i].getValues() + 1);
    sigma02_[i + offset] = *(endcapValues[i].getValues() + 2);
    sigma03_[i + offset] = *(endcapValues[i].getValues() + 3);
    sigma10_[i + offset] = *(endcapValues[i].getValues() + 3);
    sigma11_[i + offset] = *(endcapValues[i].getValues() + 5);
    sigma12_[i + offset] = *(endcapValues[i].getValues() + 6);
    sigma13_[i + offset] = *(endcapValues[i].getValues() + 7);
    sigma20_[i + offset] = *(endcapValues[i].getValues() + 8);
    sigma21_[i + offset] = *(endcapValues[i].getValues() + 9);
    sigma22_[i + offset] = *(endcapValues[i].getValues() + 10);
    sigma23_[i + offset] = *(endcapValues[i].getValues() + 11);
    sigma30_[i + offset] = *(endcapValues[i].getValues() + 12);
    sigma31_[i + offset] = *(endcapValues[i].getValues() + 13);
    sigma32_[i + offset] = *(endcapValues[i].getValues() + 14);
    sigma33_[i + offset] = *(endcapValues[i].getValues() + 15);
  }
}

HcalPedestalWidthsGPU::~HcalPedestalWidthsGPU ( )

default

Member Function Documentation

HcalPedestalWidthsGPU::Product const & HcalPedestalWidthsGPU::getProduct

(

cudaStream_t

stream

)

const

Definition at line 72 of file HcalPedestalWidthsGPU.cc.

References cms::cuda::copyAsync(), product_, HcalPedestalWidthsGPU::Product::sigma00, sigma00_, HcalPedestalWidthsGPU::Product::sigma01, sigma01_, HcalPedestalWidthsGPU::Product::sigma02, sigma02_, HcalPedestalWidthsGPU::Product::sigma03, sigma03_, HcalPedestalWidthsGPU::Product::sigma10, sigma10_, HcalPedestalWidthsGPU::Product::sigma11, sigma11_, HcalPedestalWidthsGPU::Product::sigma12, sigma12_, HcalPedestalWidthsGPU::Product::sigma13, sigma13_, HcalPedestalWidthsGPU::Product::sigma20, sigma20_, HcalPedestalWidthsGPU::Product::sigma21, sigma21_, HcalPedestalWidthsGPU::Product::sigma22, sigma22_, HcalPedestalWidthsGPU::Product::sigma23, sigma23_, HcalPedestalWidthsGPU::Product::sigma30, sigma30_, HcalPedestalWidthsGPU::Product::sigma31, sigma31_, HcalPedestalWidthsGPU::Product::sigma32, sigma32_, HcalPedestalWidthsGPU::Product::sigma33, sigma33_, and cms::cuda::stream.

                                                                                               {
  auto const& product =
      product_.dataForCurrentDeviceAsync(stream, [this](HcalPedestalWidthsGPU::Product& product, cudaStream_t stream) {
        // allocate
        product.sigma00 = cms::cuda::make_device_unique<float[]>(sigma00_.size(), stream);
        product.sigma01 = cms::cuda::make_device_unique<float[]>(sigma01_.size(), stream);
        product.sigma02 = cms::cuda::make_device_unique<float[]>(sigma02_.size(), stream);
        product.sigma03 = cms::cuda::make_device_unique<float[]>(sigma03_.size(), stream);

        product.sigma10 = cms::cuda::make_device_unique<float[]>(sigma10_.size(), stream);
        product.sigma11 = cms::cuda::make_device_unique<float[]>(sigma11_.size(), stream);
        product.sigma12 = cms::cuda::make_device_unique<float[]>(sigma12_.size(), stream);
        product.sigma13 = cms::cuda::make_device_unique<float[]>(sigma13_.size(), stream);

        product.sigma20 = cms::cuda::make_device_unique<float[]>(sigma20_.size(), stream);
        product.sigma21 = cms::cuda::make_device_unique<float[]>(sigma21_.size(), stream);
        product.sigma22 = cms::cuda::make_device_unique<float[]>(sigma22_.size(), stream);
        product.sigma23 = cms::cuda::make_device_unique<float[]>(sigma23_.size(), stream);

        product.sigma30 = cms::cuda::make_device_unique<float[]>(sigma30_.size(), stream);
        product.sigma31 = cms::cuda::make_device_unique<float[]>(sigma31_.size(), stream);
        product.sigma32 = cms::cuda::make_device_unique<float[]>(sigma32_.size(), stream);
        product.sigma33 = cms::cuda::make_device_unique<float[]>(sigma33_.size(), stream);

        // transfer
        cms::cuda::copyAsync(product.sigma00, sigma00_, stream);
        cms::cuda::copyAsync(product.sigma01, sigma01_, stream);
        cms::cuda::copyAsync(product.sigma02, sigma02_, stream);
        cms::cuda::copyAsync(product.sigma03, sigma03_, stream);

        cms::cuda::copyAsync(product.sigma10, sigma10_, stream);
        cms::cuda::copyAsync(product.sigma11, sigma11_, stream);
        cms::cuda::copyAsync(product.sigma12, sigma12_, stream);
        cms::cuda::copyAsync(product.sigma13, sigma13_, stream);

        cms::cuda::copyAsync(product.sigma20, sigma20_, stream);
        cms::cuda::copyAsync(product.sigma21, sigma21_, stream);
        cms::cuda::copyAsync(product.sigma22, sigma22_, stream);
        cms::cuda::copyAsync(product.sigma23, sigma23_, stream);

        cms::cuda::copyAsync(product.sigma30, sigma30_, stream);
        cms::cuda::copyAsync(product.sigma31, sigma31_, stream);
        cms::cuda::copyAsync(product.sigma32, sigma32_, stream);
        cms::cuda::copyAsync(product.sigma33, sigma33_, stream);
      });

  return product;
}

bool HcalPedestalWidthsGPU::unitIsADC ( ) const

inline

Definition at line 45 of file HcalPedestalWidthsGPU.h.

References unitIsADC_.

{ return unitIsADC_; }

Member Data Documentation

cms::cuda::ESProduct<Product> HcalPedestalWidthsGPU::product_

private

Definition at line 67 of file HcalPedestalWidthsGPU.h.

Referenced by getProduct().

std::vector<float, cms::cuda::HostAllocator<float> > HcalPedestalWidthsGPU::sigma00_

private

Definition at line 50 of file HcalPedestalWidthsGPU.h.

Referenced by getProduct().

std::vector<float, cms::cuda::HostAllocator<float> > HcalPedestalWidthsGPU::sigma01_

private

Definition at line 51 of file HcalPedestalWidthsGPU.h.

Referenced by getProduct().

std::vector<float, cms::cuda::HostAllocator<float> > HcalPedestalWidthsGPU::sigma02_

private

Definition at line 52 of file HcalPedestalWidthsGPU.h.

Referenced by getProduct().

std::vector<float, cms::cuda::HostAllocator<float> > HcalPedestalWidthsGPU::sigma03_

private

Definition at line 53 of file HcalPedestalWidthsGPU.h.

Referenced by getProduct().

std::vector<float, cms::cuda::HostAllocator<float> > HcalPedestalWidthsGPU::sigma10_

private

Definition at line 54 of file HcalPedestalWidthsGPU.h.

Referenced by getProduct().

std::vector<float, cms::cuda::HostAllocator<float> > HcalPedestalWidthsGPU::sigma11_

private

Definition at line 55 of file HcalPedestalWidthsGPU.h.

Referenced by getProduct().

std::vector<float, cms::cuda::HostAllocator<float> > HcalPedestalWidthsGPU::sigma12_

private

Definition at line 56 of file HcalPedestalWidthsGPU.h.

Referenced by getProduct().

std::vector<float, cms::cuda::HostAllocator<float> > HcalPedestalWidthsGPU::sigma13_

private

Definition at line 57 of file HcalPedestalWidthsGPU.h.

Referenced by getProduct().

std::vector<float, cms::cuda::HostAllocator<float> > HcalPedestalWidthsGPU::sigma20_

private

Definition at line 58 of file HcalPedestalWidthsGPU.h.

Referenced by getProduct().

std::vector<float, cms::cuda::HostAllocator<float> > HcalPedestalWidthsGPU::sigma21_

private

Definition at line 59 of file HcalPedestalWidthsGPU.h.

Referenced by getProduct().

std::vector<float, cms::cuda::HostAllocator<float> > HcalPedestalWidthsGPU::sigma22_

private

Definition at line 60 of file HcalPedestalWidthsGPU.h.

Referenced by getProduct().

std::vector<float, cms::cuda::HostAllocator<float> > HcalPedestalWidthsGPU::sigma23_

private

Definition at line 61 of file HcalPedestalWidthsGPU.h.

Referenced by getProduct().

std::vector<float, cms::cuda::HostAllocator<float> > HcalPedestalWidthsGPU::sigma30_

private

Definition at line 62 of file HcalPedestalWidthsGPU.h.

Referenced by getProduct().

std::vector<float, cms::cuda::HostAllocator<float> > HcalPedestalWidthsGPU::sigma31_

private

Definition at line 63 of file HcalPedestalWidthsGPU.h.

Referenced by getProduct().

std::vector<float, cms::cuda::HostAllocator<float> > HcalPedestalWidthsGPU::sigma32_

private

Definition at line 64 of file HcalPedestalWidthsGPU.h.

Referenced by getProduct().

std::vector<float, cms::cuda::HostAllocator<float> > HcalPedestalWidthsGPU::sigma33_

private

Definition at line 65 of file HcalPedestalWidthsGPU.h.

Referenced by getProduct().

uint64_t HcalPedestalWidthsGPU::totalChannels_

private

Definition at line 49 of file HcalPedestalWidthsGPU.h.

bool HcalPedestalWidthsGPU::unitIsADC_

private

Definition at line 48 of file HcalPedestalWidthsGPU.h.

Referenced by unitIsADC().