File indexing completed on 2023-10-25 09:59:58
0001 #ifndef RecoLocalCalo_EcalRecProducers_plugins_DeclsForKernels_h
0002 #define RecoLocalCalo_EcalRecProducers_plugins_DeclsForKernels_h
0003
0004 #include <vector>
0005
0006 #include <cuda.h>
0007 #include <cuda_runtime.h>
0008
0009 #include "CUDADataFormats/EcalDigi/interface/DigisCollection.h"
0010 #include "CUDADataFormats/EcalRecHitSoA/interface/EcalRecHit.h"
0011 #include "CUDADataFormats/EcalRecHitSoA/interface/EcalUncalibratedRecHit.h"
0012 #include "CUDADataFormats/EcalRecHitSoA/interface/RecoTypes.h"
0013 #include "CondFormats/EcalObjects/interface/EcalChannelStatus.h"
0014 #include "CondFormats/EcalObjects/interface/EcalChannelStatusCode.h"
0015 #include "CondFormats/EcalObjects/interface/EcalGainRatios.h"
0016 #include "CondFormats/EcalObjects/interface/EcalGainRatiosGPU.h"
0017 #include "CondFormats/EcalObjects/interface/EcalIntercalibConstantsGPU.h"
0018 #include "CondFormats/EcalObjects/interface/EcalLaserAPDPNRatiosGPU.h"
0019 #include "CondFormats/EcalObjects/interface/EcalLaserAPDPNRatiosRefGPU.h"
0020 #include "CondFormats/EcalObjects/interface/EcalLaserAlphasGPU.h"
0021 #include "CondFormats/EcalObjects/interface/EcalLinearCorrectionsGPU.h"
0022 #include "CondFormats/EcalObjects/interface/EcalMultifitParametersGPU.h"
0023 #include "CondFormats/EcalObjects/interface/EcalPedestals.h"
0024 #include "CondFormats/EcalObjects/interface/EcalPedestalsGPU.h"
0025 #include "CondFormats/EcalObjects/interface/EcalPulseCovariancesGPU.h"
0026 #include "CondFormats/EcalObjects/interface/EcalPulseShapesGPU.h"
0027 #include "CondFormats/EcalObjects/interface/EcalRechitADCToGeVConstantGPU.h"
0028 #include "CondFormats/EcalObjects/interface/EcalRechitChannelStatusGPU.h"
0029 #include "CondFormats/EcalObjects/interface/EcalSamplesCorrelationGPU.h"
0030 #include "CondFormats/EcalObjects/interface/EcalTimeBiasCorrections.h"
0031 #include "CondFormats/EcalObjects/interface/EcalTimeBiasCorrectionsGPU.h"
0032 #include "CondFormats/EcalObjects/interface/EcalTimeCalibConstantsGPU.h"
0033 #include "CondFormats/EcalObjects/interface/EcalTimeOffsetConstant.h"
0034 #include "CondFormats/EcalObjects/interface/EcalWeightSet.h"
0035 #include "HeterogeneousCore/CUDAUtilities/interface/cudaCheck.h"
0036
0037 #include "EigenMatrixTypes_gpu.h"
0038
0039 struct EcalPulseShape;
0040 class EcalSampleMask;
0041 class EcalTimeBiasCorrections;
0042 struct EcalPulseCovariance;
0043 class EcalDigiCollection;
0044 class EcalXtalGroupId;
0045 class EcalSamplesCorrelation;
0046 class EBDigiCollection;
0047 class EEDigiCollection;
0048
0049 namespace ecal {
0050 namespace multifit {
0051
0052 enum class TimeComputationState : char { NotFinished = 0, Finished = 1 };
0053 enum class MinimizationState : char {
0054 NotFinished = 0,
0055 Finished = 1,
0056 Precomputed = 2,
0057 };
0058
0059
0060 struct EventInputDataGPU {
0061 ecal::DigisCollection<calo::common::DevStoragePolicy> const& ebDigis;
0062 ecal::DigisCollection<calo::common::DevStoragePolicy> const& eeDigis;
0063 };
0064
0065
0066
0067 struct ConfigurationParameters {
0068 using type = double;
0069
0070 const type *amplitudeFitParametersEB = nullptr, *amplitudeFitParametersEE = nullptr;
0071
0072 uint32_t timeFitParametersSizeEB, timeFitParametersSizeEE;
0073
0074 const type *timeFitParametersEB = nullptr, *timeFitParametersEE = nullptr;
0075
0076 type timeFitLimitsFirstEB, timeFitLimitsFirstEE;
0077 type timeFitLimitsSecondEB, timeFitLimitsSecondEE;
0078
0079 type timeConstantTermEB, timeConstantTermEE;
0080
0081 type timeNconstEB, timeNconstEE;
0082
0083 type amplitudeThreshEE, amplitudeThreshEB;
0084
0085 type outOfTimeThreshG12pEB, outOfTimeThreshG12mEB;
0086 type outOfTimeThreshG12pEE, outOfTimeThreshG12mEE;
0087 type outOfTimeThreshG61pEE, outOfTimeThreshG61mEE;
0088 type outOfTimeThreshG61pEB, outOfTimeThreshG61mEB;
0089
0090 std::array<uint32_t, 3> kernelMinimizeThreads;
0091
0092 bool shouldRunTimingComputation;
0093 };
0094
0095 struct EventOutputDataGPU {
0096 UncalibratedRecHit<::calo::common::DevStoragePolicy> recHitsEB, recHitsEE;
0097
0098 void allocate(ConfigurationParameters const& configParameters,
0099 uint32_t sizeEB,
0100 uint32_t sizeEE,
0101 cudaStream_t cudaStream) {
0102 recHitsEB.amplitudesAll = cms::cuda::make_device_unique<reco::ComputationScalarType[]>(
0103 sizeEB * EcalDataFrame::MAXSAMPLES, cudaStream);
0104 recHitsEB.amplitude = cms::cuda::make_device_unique<reco::StorageScalarType[]>(sizeEB, cudaStream);
0105 recHitsEB.chi2 = cms::cuda::make_device_unique<reco::StorageScalarType[]>(sizeEB, cudaStream);
0106 recHitsEB.pedestal = cms::cuda::make_device_unique<reco::StorageScalarType[]>(sizeEB, cudaStream);
0107
0108 if (configParameters.shouldRunTimingComputation) {
0109 recHitsEB.jitter = cms::cuda::make_device_unique<reco::StorageScalarType[]>(sizeEB, cudaStream);
0110 recHitsEB.jitterError = cms::cuda::make_device_unique<reco::StorageScalarType[]>(sizeEB, cudaStream);
0111 }
0112
0113 recHitsEB.did = cms::cuda::make_device_unique<uint32_t[]>(sizeEB, cudaStream);
0114 recHitsEB.flags = cms::cuda::make_device_unique<uint32_t[]>(sizeEB, cudaStream);
0115
0116 recHitsEE.amplitudesAll = cms::cuda::make_device_unique<reco::ComputationScalarType[]>(
0117 sizeEE * EcalDataFrame::MAXSAMPLES, cudaStream);
0118 recHitsEE.amplitude = cms::cuda::make_device_unique<reco::StorageScalarType[]>(sizeEE, cudaStream);
0119 recHitsEE.chi2 = cms::cuda::make_device_unique<reco::StorageScalarType[]>(sizeEE, cudaStream);
0120 recHitsEE.pedestal = cms::cuda::make_device_unique<reco::StorageScalarType[]>(sizeEE, cudaStream);
0121
0122 if (configParameters.shouldRunTimingComputation) {
0123 recHitsEE.jitter = cms::cuda::make_device_unique<reco::StorageScalarType[]>(sizeEE, cudaStream);
0124 recHitsEE.jitterError = cms::cuda::make_device_unique<reco::StorageScalarType[]>(sizeEE, cudaStream);
0125 }
0126
0127 recHitsEE.did = cms::cuda::make_device_unique<uint32_t[]>(sizeEE, cudaStream);
0128 recHitsEE.flags = cms::cuda::make_device_unique<uint32_t[]>(sizeEE, cudaStream);
0129 }
0130 };
0131
0132 template <typename EigenM>
0133 constexpr auto getLength() -> uint32_t {
0134 return EigenM::RowsAtCompileTime * EigenM::ColsAtCompileTime;
0135 }
0136
0137 struct EventDataForScratchGPU {
0138 using SVT = SampleVector::Scalar;
0139 using SGVT = SampleGainVector::Scalar;
0140 using SMT = SampleMatrix::Scalar;
0141 using PMT = PulseMatrixType::Scalar;
0142 using BXVT = BXVectorType::Scalar;
0143
0144 cms::cuda::device::unique_ptr<SVT[]> samples;
0145 cms::cuda::device::unique_ptr<SGVT[]> gainsNoise;
0146
0147 cms::cuda::device::unique_ptr<SMT[]> noisecov;
0148 cms::cuda::device::unique_ptr<PMT[]> pulse_matrix;
0149 cms::cuda::device::unique_ptr<BXVT[]> activeBXs;
0150 cms::cuda::device::unique_ptr<char[]> acState;
0151
0152 cms::cuda::device::unique_ptr<bool[]> hasSwitchToGain6, hasSwitchToGain1, isSaturated;
0153
0154 cms::cuda::device::unique_ptr<SVT[]> sample_values, sample_value_errors;
0155 cms::cuda::device::unique_ptr<bool[]> useless_sample_values;
0156 cms::cuda::device::unique_ptr<SVT[]> chi2sNullHypot;
0157 cms::cuda::device::unique_ptr<SVT[]> sum0sNullHypot;
0158 cms::cuda::device::unique_ptr<SVT[]> sumAAsNullHypot;
0159 cms::cuda::device::unique_ptr<char[]> pedestal_nums;
0160 cms::cuda::device::unique_ptr<SVT[]> tMaxAlphaBetas, tMaxErrorAlphaBetas;
0161 cms::cuda::device::unique_ptr<SVT[]> accTimeMax, accTimeWgt;
0162 cms::cuda::device::unique_ptr<SVT[]> ampMaxAlphaBeta, ampMaxError;
0163 cms::cuda::device::unique_ptr<SVT[]> timeMax, timeError;
0164 cms::cuda::device::unique_ptr<TimeComputationState[]> tcState;
0165
0166 void allocate(ConfigurationParameters const& configParameters,
0167 uint32_t sizeEB,
0168 uint32_t sizeEE,
0169 cudaStream_t cudaStream) {
0170 constexpr auto svlength = getLength<SampleVector>();
0171 constexpr auto sgvlength = getLength<SampleGainVector>();
0172 constexpr auto smlength = getLength<SampleMatrix>();
0173 constexpr auto pmlength = getLength<PulseMatrixType>();
0174 constexpr auto bxvlength = getLength<BXVectorType>();
0175 auto const size = sizeEB + sizeEE;
0176
0177 auto alloc = [cudaStream](auto& var, uint32_t size) {
0178 using element_type = typename std::remove_reference_t<decltype(var)>::element_type;
0179 var = cms::cuda::make_device_unique<element_type[]>(size, cudaStream);
0180 };
0181
0182 alloc(samples, size * svlength);
0183 alloc(gainsNoise, size * sgvlength);
0184
0185 alloc(noisecov, size * smlength);
0186 alloc(pulse_matrix, size * pmlength);
0187 alloc(activeBXs, size * bxvlength);
0188 alloc(acState, size);
0189
0190 alloc(hasSwitchToGain6, size);
0191 alloc(hasSwitchToGain1, size);
0192 alloc(isSaturated, size);
0193
0194 if (configParameters.shouldRunTimingComputation) {
0195 alloc(sample_values, size * svlength);
0196 alloc(sample_value_errors, size * svlength);
0197 alloc(useless_sample_values, size * EcalDataFrame::MAXSAMPLES);
0198 alloc(chi2sNullHypot, size);
0199 alloc(sum0sNullHypot, size);
0200 alloc(sumAAsNullHypot, size);
0201 alloc(pedestal_nums, size);
0202
0203 alloc(tMaxAlphaBetas, size);
0204 alloc(tMaxErrorAlphaBetas, size);
0205 alloc(accTimeMax, size);
0206 alloc(accTimeWgt, size);
0207 alloc(ampMaxAlphaBeta, size);
0208 alloc(ampMaxError, size);
0209 alloc(timeMax, size);
0210 alloc(timeError, size);
0211 alloc(tcState, size);
0212 }
0213 }
0214 };
0215
0216
0217 struct ConditionsProducts {
0218 EcalPedestalsGPU::Product const& pedestals;
0219 EcalGainRatiosGPU::Product const& gainRatios;
0220 EcalPulseShapesGPU::Product const& pulseShapes;
0221 EcalPulseCovariancesGPU::Product const& pulseCovariances;
0222 EcalSamplesCorrelationGPU::Product const& samplesCorrelation;
0223 EcalTimeBiasCorrectionsGPU::Product const& timeBiasCorrections;
0224 EcalTimeCalibConstantsGPU::Product const& timeCalibConstants;
0225 EcalSampleMask const& sampleMask;
0226 EcalTimeOffsetConstant const& timeOffsetConstant;
0227 uint32_t offsetForHashes;
0228 EcalMultifitParametersGPU::Product const& multifitParameters;
0229 };
0230
0231 struct xyz {
0232 int x, y, z;
0233 };
0234
0235 struct conf_data {
0236 xyz threads;
0237 bool runV1;
0238 cudaStream_t cuStream;
0239 };
0240
0241 }
0242 }
0243
0244
0245
0246
0247
0248 namespace ecal {
0249 namespace rechit {
0250
0251
0252 struct ConfigurationParameters {
0253
0254 const int* ChannelStatusToBeExcluded = nullptr;
0255 uint32_t ChannelStatusToBeExcludedSize;
0256
0257 bool killDeadChannels;
0258
0259 bool recoverEBIsolatedChannels;
0260 bool recoverEEIsolatedChannels;
0261 bool recoverEBVFE;
0262 bool recoverEEVFE;
0263 bool recoverEBFE;
0264 bool recoverEEFE;
0265
0266 float EBLaserMIN;
0267 float EELaserMIN;
0268 float EBLaserMAX;
0269 float EELaserMAX;
0270
0271 const int* expanded_v_DB_reco_flags;
0272 const uint32_t* expanded_Sizes_v_DB_reco_flags;
0273 const uint32_t* expanded_flagbit_v_DB_reco_flags;
0274 uint32_t expanded_v_DB_reco_flagsSize;
0275
0276 uint32_t flagmask;
0277 };
0278
0279 struct EventOutputDataGPU {
0280 RecHit<::calo::common::DevStoragePolicy> recHitsEB, recHitsEE;
0281
0282 void allocate(ConfigurationParameters const& configParameters,
0283 uint32_t sizeEB,
0284 uint32_t sizeEE,
0285 cudaStream_t cudaStream) {
0286
0287 recHitsEB.energy = cms::cuda::make_device_unique<::ecal::reco::StorageScalarType[]>(sizeEB, cudaStream);
0288 recHitsEB.time = cms::cuda::make_device_unique<::ecal::reco::StorageScalarType[]>(sizeEB, cudaStream);
0289 recHitsEB.chi2 = cms::cuda::make_device_unique<::ecal::reco::StorageScalarType[]>(sizeEB, cudaStream);
0290 recHitsEB.flagBits = cms::cuda::make_device_unique<uint32_t[]>(sizeEB, cudaStream);
0291 recHitsEB.extra = cms::cuda::make_device_unique<uint32_t[]>(sizeEB, cudaStream);
0292 recHitsEB.did = cms::cuda::make_device_unique<uint32_t[]>(sizeEB, cudaStream);
0293
0294 recHitsEE.energy = cms::cuda::make_device_unique<::ecal::reco::StorageScalarType[]>(sizeEE, cudaStream);
0295 recHitsEE.time = cms::cuda::make_device_unique<::ecal::reco::StorageScalarType[]>(sizeEE, cudaStream);
0296 recHitsEE.chi2 = cms::cuda::make_device_unique<::ecal::reco::StorageScalarType[]>(sizeEE, cudaStream);
0297 recHitsEE.flagBits = cms::cuda::make_device_unique<uint32_t[]>(sizeEE, cudaStream);
0298 recHitsEE.extra = cms::cuda::make_device_unique<uint32_t[]>(sizeEE, cudaStream);
0299 recHitsEE.did = cms::cuda::make_device_unique<uint32_t[]>(sizeEE, cudaStream);
0300 }
0301 };
0302
0303 struct EventInputDataGPU {
0304 ecal::UncalibratedRecHit<calo::common::DevStoragePolicy> const& ebUncalibRecHits;
0305 ecal::UncalibratedRecHit<calo::common::DevStoragePolicy> const& eeUncalibRecHits;
0306 };
0307
0308
0309 struct ConditionsProducts {
0310 EcalRechitADCToGeVConstantGPU::Product const& ADCToGeV;
0311 EcalIntercalibConstantsGPU::Product const& Intercalib;
0312 EcalRechitChannelStatusGPU::Product const& ChannelStatus;
0313
0314 EcalLaserAPDPNRatiosGPU::Product const& LaserAPDPNRatios;
0315 EcalLaserAPDPNRatiosRefGPU::Product const& LaserAPDPNRatiosRef;
0316 EcalLaserAlphasGPU::Product const& LaserAlphas;
0317 EcalLinearCorrectionsGPU::Product const& LinearCorrections;
0318
0319 uint32_t offsetForHashes;
0320 };
0321
0322 }
0323 }
0324
0325 #endif