#include <HelixFitOnGPU.h>

Public Types
using	HitsView = TrackingRecHit2DSOAView

using	OutputSoA = pixelTrack::TrackSoA

using	TupleMultiplicity = caConstants::TupleMultiplicity

using	Tuples = pixelTrack::HitContainer

Public Member Functions
void	allocateOnGPU (Tuples const tuples, TupleMultiplicity const tupleMultiplicity, OutputSoA *outputSoA)

void	deallocateOnGPU ()

	HelixFitOnGPU (float bf, bool fit5as4)

void	launchBrokenLineKernels (HitsView const *hv, uint32_t nhits, uint32_t maxNumberOfTuples, cudaStream_t cudaStream)

void	launchBrokenLineKernelsOnCPU (HitsView const *hv, uint32_t nhits, uint32_t maxNumberOfTuples)

void	launchRiemannKernels (HitsView const *hv, uint32_t nhits, uint32_t maxNumberOfTuples, cudaStream_t cudaStream)

void	launchRiemannKernelsOnCPU (HitsView const *hv, uint32_t nhits, uint32_t maxNumberOfTuples)

void	setBField (double bField)

	~HelixFitOnGPU ()

Private Attributes
float	bField_

const bool	fit5as4_

OutputSoA *	outputSoa_

const TupleMultiplicity *	tupleMultiplicity_ = nullptr

const Tuples *	tuples_ = nullptr

Static Private Attributes
static constexpr uint32_t	maxNumberOfConcurrentFits_ = riemannFit::maxNumberOfConcurrentFits

Detailed Description

Definition at line 34 of file HelixFitOnGPU.h.

Member Typedef Documentation

◆ HitsView

using HelixFitOnGPU::HitsView = TrackingRecHit2DSOAView

Definition at line 36 of file HelixFitOnGPU.h.

◆ OutputSoA

using HelixFitOnGPU::OutputSoA = pixelTrack::TrackSoA

Definition at line 39 of file HelixFitOnGPU.h.

◆ TupleMultiplicity

using HelixFitOnGPU::TupleMultiplicity = caConstants::TupleMultiplicity

Definition at line 41 of file HelixFitOnGPU.h.

◆ Tuples

using HelixFitOnGPU::Tuples = pixelTrack::HitContainer

Definition at line 38 of file HelixFitOnGPU.h.

Constructor & Destructor Documentation

◆ HelixFitOnGPU()

HelixFitOnGPU::HelixFitOnGPU	(	float	bf,
		bool	fit5as4
	)

inlineexplicit

Definition at line 43 of file HelixFitOnGPU.h.

43 : bField_(bf), fit5as4_(fit5as4) {}

◆ ~HelixFitOnGPU()

HelixFitOnGPU::~HelixFitOnGPU ( )

inline

Definition at line 44 of file HelixFitOnGPU.h.

44 { deallocateOnGPU(); }

References deallocateOnGPU().

Member Function Documentation

◆ allocateOnGPU()

void HelixFitOnGPU::allocateOnGPU	(	Tuples const *	tuples,
		TupleMultiplicity const *	tupleMultiplicity,
		OutputSoA *	outputSoA
	)

Definition at line 4 of file HelixFitOnGPU.cc.

                                                                 {
   tuples_ = tuples;
   tupleMultiplicity_ = tupleMultiplicity;
   outputSoa_ = helix_fit_results;
  
   assert(tuples_);
   assert(tupleMultiplicity_);
   assert(outputSoa_);
 }

References cms::cuda::assert(), outputSoa_, tupleMultiplicity, tupleMultiplicity_, and tuples_.

Referenced by CAHitNtupletGeneratorOnGPU::makeTuples(), and CAHitNtupletGeneratorOnGPU::makeTuplesAsync().

◆ deallocateOnGPU()

void HelixFitOnGPU::deallocateOnGPU ( )

Definition at line 16 of file HelixFitOnGPU.cc.

16 {}

Referenced by ~HelixFitOnGPU().

◆ launchBrokenLineKernels()

void HelixFitOnGPU::launchBrokenLineKernels	(	HitsView const *	hv,
		uint32_t	nhits,
		uint32_t	maxNumberOfTuples,
		cudaStream_t	cudaStream
	)

Referenced by CAHitNtupletGeneratorOnGPU::makeTuplesAsync().

◆ launchBrokenLineKernelsOnCPU()

void HelixFitOnGPU::launchBrokenLineKernelsOnCPU	(	HitsView const *	hv,
		uint32_t	nhits,
		uint32_t	maxNumberOfTuples
	)

Definition at line 3 of file BrokenLineFitOnGPU.cc.

                                                                                                                    {
   assert(tuples_);
  
   //  Fit internals
   auto hitsGPU_ =
       std::make_unique<double[]>(maxNumberOfConcurrentFits_ * sizeof(riemannFit::Matrix3xNd<4>) / sizeof(double));
   auto hits_geGPU_ =
       std::make_unique<float[]>(maxNumberOfConcurrentFits_ * sizeof(riemannFit::Matrix6x4f) / sizeof(float));
   auto fast_fit_resultsGPU_ =
       std::make_unique<double[]>(maxNumberOfConcurrentFits_ * sizeof(riemannFit::Vector4d) / sizeof(double));
  
   for (uint32_t offset = 0; offset < maxNumberOfTuples; offset += maxNumberOfConcurrentFits_) {
     // fit triplets
     kernel_BLFastFit<3>(
         tuples_, tupleMultiplicity_, hv, hitsGPU_.get(), hits_geGPU_.get(), fast_fit_resultsGPU_.get(), 3, offset);
  
     kernel_BLFit<3>(tupleMultiplicity_,
                     bField_,
                     outputSoa_,
                     hitsGPU_.get(),
                     hits_geGPU_.get(),
                     fast_fit_resultsGPU_.get(),
                     3,
                     offset);
  
     // fit quads
     kernel_BLFastFit<4>(
         tuples_, tupleMultiplicity_, hv, hitsGPU_.get(), hits_geGPU_.get(), fast_fit_resultsGPU_.get(), 4, offset);
  
     kernel_BLFit<4>(tupleMultiplicity_,
                     bField_,
                     outputSoa_,
                     hitsGPU_.get(),
                     hits_geGPU_.get(),
                     fast_fit_resultsGPU_.get(),
                     4,
                     offset);
  
     if (fit5as4_) {
       // fit penta (only first 4)
       kernel_BLFastFit<4>(
           tuples_, tupleMultiplicity_, hv, hitsGPU_.get(), hits_geGPU_.get(), fast_fit_resultsGPU_.get(), 5, offset);
  
       kernel_BLFit<4>(tupleMultiplicity_,
                       bField_,
                       outputSoa_,
                       hitsGPU_.get(),
                       hits_geGPU_.get(),
                       fast_fit_resultsGPU_.get(),
                       5,
                       offset);
     } else {
       // fit penta (all 5)
       kernel_BLFastFit<5>(
           tuples_, tupleMultiplicity_, hv, hitsGPU_.get(), hits_geGPU_.get(), fast_fit_resultsGPU_.get(), 5, offset);
  
       kernel_BLFit<5>(tupleMultiplicity_,
                       bField_,
                       outputSoa_,
                       hitsGPU_.get(),
                       hits_geGPU_.get(),
                       fast_fit_resultsGPU_.get(),
                       5,
                       offset);
     }
  
   }  // loop on concurrent fits
 }

References cms::cuda::assert(), bField_, fit5as4_, maxNumberOfConcurrentFits_, caConstants::maxNumberOfTuples, hltrates_dqm_sourceclient-live_cfg::offset, outputSoa_, tupleMultiplicity_, and tuples_.

Referenced by CAHitNtupletGeneratorOnGPU::makeTuples().

◆ launchRiemannKernels()

void HelixFitOnGPU::launchRiemannKernels	(	HitsView const *	hv,
		uint32_t	nhits,
		uint32_t	maxNumberOfTuples,
		cudaStream_t	cudaStream
	)

Referenced by CAHitNtupletGeneratorOnGPU::makeTuplesAsync().

◆ launchRiemannKernelsOnCPU()

void HelixFitOnGPU::launchRiemannKernelsOnCPU	(	HitsView const *	hv,
		uint32_t	nhits,
		uint32_t	maxNumberOfTuples
	)

Definition at line 3 of file RiemannFitOnGPU.cc.

                                                                                                             {
   assert(tuples_);
  
   //  Fit internals
   auto hitsGPU =
       std::make_unique<double[]>(maxNumberOfConcurrentFits_ * sizeof(riemannFit::Matrix3xNd<4>) / sizeof(double));
   auto hits_geGPU =
       std::make_unique<float[]>(maxNumberOfConcurrentFits_ * sizeof(riemannFit::Matrix6x4f) / sizeof(float));
   auto fast_fit_resultsGPU =
       std::make_unique<double[]>(maxNumberOfConcurrentFits_ * sizeof(riemannFit::Vector4d) / sizeof(double));
   auto circle_fit_resultsGPU_holder =
       std::make_unique<char[]>(maxNumberOfConcurrentFits_ * sizeof(riemannFit::CircleFit));
   riemannFit::CircleFit *circle_fit_resultsGPU = (riemannFit::CircleFit *)(circle_fit_resultsGPU_holder.get());
  
   for (uint32_t offset = 0; offset < maxNumberOfTuples; offset += maxNumberOfConcurrentFits_) {
     // triplets
     kernel_FastFit<3>(
         tuples_, tupleMultiplicity_, 3, hv, hitsGPU.get(), hits_geGPU.get(), fast_fit_resultsGPU.get(), offset);
  
     kernel_CircleFit<3>(tupleMultiplicity_,
                         3,
                         bField_,
                         hitsGPU.get(),
                         hits_geGPU.get(),
                         fast_fit_resultsGPU.get(),
                         circle_fit_resultsGPU,
                         offset);
  
     kernel_LineFit<3>(tupleMultiplicity_,
                       3,
                       bField_,
                       outputSoa_,
                       hitsGPU.get(),
                       hits_geGPU.get(),
                       fast_fit_resultsGPU.get(),
                       circle_fit_resultsGPU,
                       offset);
  
     // quads
     kernel_FastFit<4>(
         tuples_, tupleMultiplicity_, 4, hv, hitsGPU.get(), hits_geGPU.get(), fast_fit_resultsGPU.get(), offset);
  
     kernel_CircleFit<4>(tupleMultiplicity_,
                         4,
                         bField_,
                         hitsGPU.get(),
                         hits_geGPU.get(),
                         fast_fit_resultsGPU.get(),
                         circle_fit_resultsGPU,
                         offset);
  
     kernel_LineFit<4>(tupleMultiplicity_,
                       4,
                       bField_,
                       outputSoa_,
                       hitsGPU.get(),
                       hits_geGPU.get(),
                       fast_fit_resultsGPU.get(),
                       circle_fit_resultsGPU,
                       offset);
  
     if (fit5as4_) {
       // penta
       kernel_FastFit<4>(
           tuples_, tupleMultiplicity_, 5, hv, hitsGPU.get(), hits_geGPU.get(), fast_fit_resultsGPU.get(), offset);
  
       kernel_CircleFit<4>(tupleMultiplicity_,
                           5,
                           bField_,
                           hitsGPU.get(),
                           hits_geGPU.get(),
                           fast_fit_resultsGPU.get(),
                           circle_fit_resultsGPU,
                           offset);
  
       kernel_LineFit<4>(tupleMultiplicity_,
                         5,
                         bField_,
                         outputSoa_,
                         hitsGPU.get(),
                         hits_geGPU.get(),
                         fast_fit_resultsGPU.get(),
                         circle_fit_resultsGPU,
                         offset);
  
     } else {
       // penta all 5
       kernel_FastFit<5>(
           tuples_, tupleMultiplicity_, 5, hv, hitsGPU.get(), hits_geGPU.get(), fast_fit_resultsGPU.get(), offset);
  
       kernel_CircleFit<5>(tupleMultiplicity_,
                           5,
                           bField_,
                           hitsGPU.get(),
                           hits_geGPU.get(),
                           fast_fit_resultsGPU.get(),
                           circle_fit_resultsGPU,
                           offset);
  
       kernel_LineFit<5>(tupleMultiplicity_,
                         5,
                         bField_,
                         outputSoa_,
                         hitsGPU.get(),
                         hits_geGPU.get(),
                         fast_fit_resultsGPU.get(),
                         circle_fit_resultsGPU,
                         offset);
     }
   }
 }

References cms::cuda::assert(), bField_, fit5as4_, maxNumberOfConcurrentFits_, caConstants::maxNumberOfTuples, hltrates_dqm_sourceclient-live_cfg::offset, outputSoa_, tupleMultiplicity_, and tuples_.

Referenced by CAHitNtupletGeneratorOnGPU::makeTuples().

◆ setBField()

void HelixFitOnGPU::setBField ( double bField )

inline

Definition at line 46 of file HelixFitOnGPU.h.

46 { bField_ = bField; }

References Calorimetry_cff::bField, and bField_.

Member Data Documentation

◆ bField_

float HelixFitOnGPU::bField_

private

Definition at line 63 of file HelixFitOnGPU.h.

Referenced by launchBrokenLineKernelsOnCPU(), launchRiemannKernelsOnCPU(), and setBField().

◆ fit5as4_

const bool HelixFitOnGPU::fit5as4_

private

Definition at line 65 of file HelixFitOnGPU.h.

Referenced by launchBrokenLineKernelsOnCPU(), and launchRiemannKernelsOnCPU().

◆ maxNumberOfConcurrentFits_

constexpr uint32_t HelixFitOnGPU::maxNumberOfConcurrentFits_ = riemannFit::maxNumberOfConcurrentFits

staticconstexprprivate

Definition at line 57 of file HelixFitOnGPU.h.

Referenced by launchBrokenLineKernelsOnCPU(), and launchRiemannKernelsOnCPU().

◆ outputSoa_

OutputSoA* HelixFitOnGPU::outputSoa_

private

Definition at line 62 of file HelixFitOnGPU.h.

Referenced by allocateOnGPU(), launchBrokenLineKernelsOnCPU(), and launchRiemannKernelsOnCPU().

◆ tupleMultiplicity_

const TupleMultiplicity* HelixFitOnGPU::tupleMultiplicity_ = nullptr

private

Definition at line 61 of file HelixFitOnGPU.h.

Referenced by allocateOnGPU(), launchBrokenLineKernelsOnCPU(), and launchRiemannKernelsOnCPU().

◆ tuples_

const Tuples* HelixFitOnGPU::tuples_ = nullptr

private

Definition at line 60 of file HelixFitOnGPU.h.

Referenced by allocateOnGPU(), launchBrokenLineKernelsOnCPU(), and launchRiemannKernelsOnCPU().

Public Types

Public Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Member Typedef Documentation

◆ HitsView

◆ OutputSoA

◆ TupleMultiplicity

◆ Tuples

Constructor & Destructor Documentation

◆ HelixFitOnGPU()

◆ ~HelixFitOnGPU()

Member Function Documentation

◆ allocateOnGPU()

◆ deallocateOnGPU()

◆ launchBrokenLineKernels()

◆ launchBrokenLineKernelsOnCPU()

◆ launchRiemannKernels()

◆ launchRiemannKernelsOnCPU()

◆ setBField()

Member Data Documentation

◆ bField_

◆ fit5as4_

◆ maxNumberOfConcurrentFits_

◆ outputSoa_

◆ tupleMultiplicity_

◆ tuples_