Classes
class	ClusterTracksByDensityKernel

class	ClusterTracksDBSCAN

class	ClusterTracksIterative

class	FitVerticesKernel

class	Init

class	LoadTracks

class	Producer

class	SortByPt2Kernel

class	SplitVerticesKernel

class	VertexFinderOneKernel

Typedefs
using	Hist = cms::alpakatools::HistoContainer< uint8_t, 256, 16000, 8, uint16_t >

using	PixelVertexWorkSpaceSoADevice = PortableCollection<::vertexFinder::PixelVertexWSSoALayout<> >

using	PixelVertexWorkSpaceSoAHost = ::vertexFinder::PixelVertexWorkSpaceSoAHost

using	VtxSoAView = ::reco::ZVertexSoAView

using	WsSoAView = ::vertexFinder::PixelVertexWorkSpaceSoAView

Functions
template<typename TAcc >
ALPAKA_FN_ACC ALPAKA_FN_INLINE	__attribute__ ((always_inline)) void fitVertices(const TAcc &acc

template<typename TAcc >
ALPAKA_FN_ACC ALPAKA_FN_INLINE void	__attribute__ ((always_inline)) clusterTracksByDensity(const TAcc &acc

	ALPAKA_ASSERT_ACC (nvFinal<=nvIntermediate)

	ALPAKA_ASSERT_ACC (wv)

	ALPAKA_ASSERT_ACC (chi2)

	ALPAKA_ASSERT_ACC (zt)

	ALPAKA_ASSERT_ACC (ezt2)

	ALPAKA_ASSERT_ACC (izt)

	ALPAKA_ASSERT_ACC (nn)

	ALPAKA_ASSERT_ACC (iv)

	ALPAKA_ASSERT_ACC (static_cast< int >(nt)<=hist.capacity())

	ALPAKA_ASSERT_ACC (hist.size()==nt)

	ALPAKA_ASSERT_ACC (foundClusters< ::zVertex::MAXVTX)

const uint32_t	blockIdx (alpaka::getIdx< alpaka::Grid, alpaka::Blocks >(acc)[0u])

if	constexpr (verbose)

hist	finalize (acc, hws)

	for (auto i :cms::alpakatools::uniform_elements(acc, foundClusters))

	for (auto kv=blockIdx;kv< nvFinal;kv+=gridDimension)

	for (auto j :cms::alpakatools::uniform_elements(acc, Hist::totbins()))

	for (auto i :cms::alpakatools::uniform_elements(acc, nt))

const uint32_t	gridDimension (alpaka::getWorkDiv< alpaka::Grid, alpaka::Blocks >(acc)[0u])

	if (threadIdxLocal< 32) hws[threadIdxLocal]=0

template<typename TAcc >
ALPAKA_FN_ACC ALPAKA_FN_INLINE void	sortByPt2 (const TAcc &acc, VtxSoAView &data, WsSoAView &ws)

const uint32_t	threadIdxLocal (alpaka::getIdx< alpaka::Block, alpaka::Threads >(acc)[0u])

Variables
float *__restrict__	chi2 = data.chi2()

ALPAKA_FN_ACC ALPAKA_FN_INLINE VtxSoAView WsSoAView float	chi2Max

ALPAKA_FN_ACC ALPAKA_FN_INLINE void VtxSoAView WsSoAView int float float float	chi2max

auto &__restrict__	data = pdata

ALPAKA_FN_ACC ALPAKA_FN_INLINE void VtxSoAView WsSoAView int float	eps

auto	er2mx = errmax * errmax

ALPAKA_FN_ACC ALPAKA_FN_INLINE void VtxSoAView WsSoAView int float float	errmax

float const *__restrict__	ezt2 = ws.ezt2()

auto &	foundClusters = alpaka::declareSharedVar<unsigned int, __COUNTER__>(acc)

auto &	hist = alpaka::declareSharedVar<Hist, __COUNTER__>(acc)

auto &	hws = alpaka::declareSharedVar<Hist::Counter[32], __COUNTER__>(acc)

auto &	it = alpaka::declareSharedVar<uint32_t[MAXTK], __COUNTER__>(acc)

int32_t *__restrict__	iv = ws.iv()

uint8_t *__restrict__	izt = ws.izt()

ALPAKA_FN_ACC ALPAKA_FN_INLINE VtxSoAView WsSoAView float	maxChi2

constexpr float	maxChi2ForFinalFit = 5000.f

constexpr float	maxChi2ForFirstFit = 50.f

constexpr float	maxChi2ForSplit = 9.f

constexpr uint32_t	MAXTK = 512

ALPAKA_FN_ACC ALPAKA_FN_INLINE void VtxSoAView WsSoAView int	minT

auto &	newV = alpaka::declareSharedVar<uint8_t[MAXTK], __COUNTER__>(acc)

int32_t *__restrict__	nn = data.ndof()

auto &	noise = alpaka::declareSharedVar<int, __COUNTER__>(acc)

auto &	nq = alpaka::declareSharedVar<uint32_t, __COUNTER__>(acc)

auto	nt = ws.ntrks()

uint32_t &	nvFinal = data.nvFinal()

uint32_t &	nvIntermediate = ws.nvIntermediate()

ALPAKA_FN_ACC ALPAKA_FN_INLINE void VtxSoAView &	pdata

ALPAKA_FN_ACC ALPAKA_FN_INLINE void VtxSoAView WsSoAView &	pws

constexpr bool	verbose = false

auto &__restrict__	ws = pws

float *__restrict__	wv = data.wv()

auto &	ww = alpaka::declareSharedVar<float[MAXTK], __COUNTER__>(acc)

float const *__restrict__	zt = ws.zt()

float *__restrict__	zv = data.zv()

auto &	zz = alpaka::declareSharedVar<float[MAXTK], __COUNTER__>(acc)

Typedef Documentation

◆ Hist

using ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::Hist = typedef cms::alpakatools::HistoContainer<uint8_t, 256, 16000, 8, uint16_t>

Definition at line 66 of file clusterTracksByDensity.h.

◆ PixelVertexWorkSpaceSoADevice

using ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::PixelVertexWorkSpaceSoADevice = typedef PortableCollection<::vertexFinder::PixelVertexWSSoALayout<> >

Definition at line 16 of file PixelVertexWorkSpaceSoADeviceAlpaka.h.

◆ PixelVertexWorkSpaceSoAHost

using ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::PixelVertexWorkSpaceSoAHost = typedef ::vertexFinder::PixelVertexWorkSpaceSoAHost

Definition at line 17 of file PixelVertexWorkSpaceSoADeviceAlpaka.h.

◆ VtxSoAView

typedef::reco::ZVertexSoAView ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::VtxSoAView

Definition at line 20 of file clusterTracksByDensity.h.

◆ WsSoAView

typedef::vertexFinder::PixelVertexWorkSpaceSoAView ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::WsSoAView

Definition at line 21 of file clusterTracksByDensity.h.

Function Documentation

◆ attribute() [1/2]

template<typename TAcc >

ALPAKA_FN_ACC ALPAKA_FN_INLINE ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::__attribute__ ( (always_inline) ) const &

◆ attribute() [2/2]

template<typename TAcc >

ALPAKA_FN_ACC ALPAKA_FN_INLINE void ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::__attribute__ ( (always_inline) ) const &

◆ ALPAKA_ASSERT_ACC() [1/11]

ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::ALPAKA_ASSERT_ACC ( nvFinal<= nvIntermediate )

◆ ALPAKA_ASSERT_ACC() [2/11]

ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::ALPAKA_ASSERT_ACC ( wv )

◆ ALPAKA_ASSERT_ACC() [3/11]

ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::ALPAKA_ASSERT_ACC ( chi2 )

◆ ALPAKA_ASSERT_ACC() [4/11]

ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::ALPAKA_ASSERT_ACC ( zt )

Referenced by for(), ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::ClusterTracksIterative::operator()(), ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::ClusterTracksDBSCAN::operator()(), and ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::LoadTracks< TrackerTraits >::operator()().

◆ ALPAKA_ASSERT_ACC() [5/11]

ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::ALPAKA_ASSERT_ACC ( ezt2 )

◆ ALPAKA_ASSERT_ACC() [6/11]

ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::ALPAKA_ASSERT_ACC ( izt )

◆ ALPAKA_ASSERT_ACC() [7/11]

ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::ALPAKA_ASSERT_ACC ( nn )

◆ ALPAKA_ASSERT_ACC() [8/11]

ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::ALPAKA_ASSERT_ACC ( iv )

◆ ALPAKA_ASSERT_ACC() [9/11]

ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::ALPAKA_ASSERT_ACC ( static_cast< int > nt)<=hist.capacity( )

◆ ALPAKA_ASSERT_ACC() [10/11]

ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::ALPAKA_ASSERT_ACC ( hist. size() = =nt )

◆ ALPAKA_ASSERT_ACC() [11/11]

ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::ALPAKA_ASSERT_ACC ( )

◆ blockIdx()

const uint32_t ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::blockIdx ( alpaka::getIdx< alpaka::Grid, alpaka::Blocks > (acc)[0u] )

◆ constexpr()

if ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::constexpr ( verbose )

Definition at line 41 of file clusterTracksByDensity.h.

References chi2max, eps, errmax, minT, and cms::alpakatools::once_per_block().

Referenced by ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::ClusterTracksIterative::operator()(), ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::ClusterTracksDBSCAN::operator()(), and sortByPt2().

                            {
       if (cms::alpakatools::once_per_block(acc))
         printf("params %d %f %f %f\n", minT, eps, errmax, chi2max);
     }

◆ finalize()

hist ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::finalize	(	acc	,
		hws
	)

Referenced by reco::TaggingVariableList::insert().

◆ for() [1/4]

ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::for ( auto i :cms::alpakatools::uniform_elementsacc, foundClusters )

Definition at line 45 of file fitVertices.h.

References chi2, mps_fire::i, wv, and zv.

                 : cms::alpakatools::uniform_elements(acc, foundClusters)) {
       zv[i] = 0;
       wv[i] = 0;
       chi2[i] = 0;
     }

◆ for() [2/4]

ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::for ( )

Definition at line 58 of file splitVertices.h.

References ALPAKA_ASSERT_ACC(), cms::cudacompat::atomicAdd(), cms::cudacompat::atomicInc(), chi2, d0, d1, ezt2, mps_fire::i, cms::alpakatools::independent_group_elements(), it, iv, dqmdumpme::k, maxChi2, maxiter, MAXTK, gpuVertexFinder::more, dqmPostProcessing_online::newer, newV, nn, nq, nt, threadIdxLocal(), cms::alpakatools::uniform_elements(), verbose, ws, wv, ww, zt, zv, and zz.

                                                                 {
       if (nn[kv] < 4)
         continue;
       if (chi2[kv] < maxChi2 * float(nn[kv]))
         continue;
 
       ALPAKA_ASSERT_ACC(nn[kv] < int32_t(MAXTK));
 
       if ((uint32_t)nn[kv] >= MAXTK)
         continue;  // too bad FIXME
 
       nq = 0u;
       alpaka::syncBlockThreads(acc);
 
       // copy to local
       for (auto k : cms::alpakatools::independent_group_elements(acc, nt)) {
         if (iv[k] == int(kv)) {
           auto old = alpaka::atomicInc(acc, &nq, MAXTK, alpaka::hierarchy::Threads{});
           zz[old] = zt[k] - zv[kv];
           newV[old] = zz[old] < 0 ? 0 : 1;
           ww[old] = 1.f / ezt2[k];
           it[old] = k;
         }
       }
 
       // the new vertices
       auto& znew = alpaka::declareSharedVar<float[2], __COUNTER__>(acc);
       auto& wnew = alpaka::declareSharedVar<float[2], __COUNTER__>(acc);
       alpaka::syncBlockThreads(acc);
 
       ALPAKA_ASSERT_ACC(int(nq) == nn[kv] + 1);
 
       int maxiter = 20;
       // kt-min....
       bool more = true;
       while (alpaka::syncBlockThreadsPredicate<alpaka::BlockOr>(acc, more)) {
         more = false;
         if (0 == threadIdxLocal) {
           znew[0] = 0;
           znew[1] = 0;
           wnew[0] = 0;
           wnew[1] = 0;
         }
         alpaka::syncBlockThreads(acc);
 
         for (auto k : cms::alpakatools::uniform_elements(acc, nq)) {
           auto i = newV[k];
           alpaka::atomicAdd(acc, &znew[i], zz[k] * ww[k], alpaka::hierarchy::Threads{});
           alpaka::atomicAdd(acc, &wnew[i], ww[k], alpaka::hierarchy::Threads{});
         }
         alpaka::syncBlockThreads(acc);
 
         if (0 == threadIdxLocal) {
           znew[0] /= wnew[0];
           znew[1] /= wnew[1];
         }
         alpaka::syncBlockThreads(acc);
 
         for (auto k : cms::alpakatools::uniform_elements(acc, nq)) {
           auto d0 = fabs(zz[k] - znew[0]);
           auto d1 = fabs(zz[k] - znew[1]);
           auto newer = d0 < d1 ? 0 : 1;
           more |= newer != newV[k];
           newV[k] = newer;
         }
         --maxiter;
         if (maxiter <= 0)
           more = false;
       }
 
       // avoid empty vertices
       if (0 == wnew[0] || 0 == wnew[1])
         continue;
 
       // quality cut
       auto dist2 = (znew[0] - znew[1]) * (znew[0] - znew[1]);
 
       auto chi2Dist = dist2 / (1.f / wnew[0] + 1.f / wnew[1]);
 
       if (verbose && 0 == threadIdxLocal)
         printf("inter %d %f %f\n", 20 - maxiter, chi2Dist, dist2 * wv[kv]);
 
       if (chi2Dist < 4)
         continue;
 
       // get a new global vertex
       auto& igv = alpaka::declareSharedVar<uint32_t, __COUNTER__>(acc);
       if (0 == threadIdxLocal)
         igv = alpaka::atomicAdd(acc, &ws.nvIntermediate(), 1u, alpaka::hierarchy::Blocks{});
       alpaka::syncBlockThreads(acc);
       for (auto k : cms::alpakatools::uniform_elements(acc, nq)) {
         if (1 == newV[k])
           iv[it[k]] = igv;
       }
 
     }  // loop on vertices

◆ for() [3/4]

ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::for ( auto j :cms::alpakatools::uniform_elementsacc, Hist::totbins() )

Definition at line 70 of file clusterTracksByDensity.h.

References hist, and dqmiolumiharvest::j.

                 : cms::alpakatools::uniform_elements(acc, Hist::totbins())) {
       hist.off[j] = 0;
     }

◆ for() [4/4]

ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::for ( auto i :cms::alpakatools::uniform_elementsacc, nt )

Definition at line 82 of file clusterTracksByDensity.h.

References ALPAKA_ASSERT_ACC(), hist, mps_fire::i, createfilelist::int, iv, izt, SiStripPI::max, zVertex::MAXTRACKS, SiStripPI::min, nn, and zt.

                 : cms::alpakatools::uniform_elements(acc, nt)) {
       ALPAKA_ASSERT_ACC(i < ::zVertex::MAXTRACKS);
       int iz = int(zt[i] * 10.);  // valid if eps<=0.1
       // iz = std::clamp(iz, INT8_MIN, INT8_MAX);  // sorry c++17 only
       iz = std::min(std::max(iz, INT8_MIN), INT8_MAX);
       izt[i] = iz - INT8_MIN;
       ALPAKA_ASSERT_ACC(iz - INT8_MIN >= 0);
       ALPAKA_ASSERT_ACC(iz - INT8_MIN < 256);
       hist.count(acc, izt[i]);
       iv[i] = i;
       nn[i] = 0;
     }

◆ gridDimension()

const uint32_t ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::gridDimension ( alpaka::getWorkDiv< alpaka::Grid, alpaka::Blocks > (acc)[0u] )

Referenced by ALPAKA_ACCELERATOR_NAMESPACE::pixelDetails::FillHitsModuleStart< TrackerTraits >::operator()().

◆ if()

ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::if ( )

pure virtual

◆ sortByPt2()

template<typename TAcc >

ALPAKA_FN_ACC ALPAKA_FN_INLINE void ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::sortByPt2	(	const TAcc &	acc,
		VtxSoAView &	data,
		WsSoAView &	ws
	)

Definition at line 26 of file sortByPt2.h.

References cms::cudacompat::atomicAdd(), constexpr(), data, mps_fire::i, iv, dqmiolumiharvest::j, nt, nvFinal, gpuVertexFinder::ptt2, gpuVertexFinder::ptv2, jetUpdater_cfi::sort, gpuVertexFinder::sortInd, threadIdxLocal(), cms::alpakatools::uniform_elements(), and ws.

Referenced by ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::VertexFinderOneKernel::operator()(), and ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::SortByPt2Kernel::operator()().

                                                                                                   {
     auto nt = ws.ntrks();
     float const* __restrict__ ptt2 = ws.ptt2();
     uint32_t const& nvFinal = data.nvFinal();
 
     int32_t const* __restrict__ iv = ws.iv();
     float* __restrict__ ptv2 = data.ptv2();
     uint16_t* __restrict__ sortInd = data.sortInd();
 
     if (nvFinal < 1)
       return;
 
     // fill indexing
     for (auto i : cms::alpakatools::uniform_elements(acc, nt)) {
       data.idv()[ws.itrk()[i]] = iv[i];
     };
 
     // can be done asynchronously at the end of previous event
     for (auto i : cms::alpakatools::uniform_elements(acc, nvFinal)) {
       ptv2[i] = 0;
     };
     alpaka::syncBlockThreads(acc);
 
     for (auto i : cms::alpakatools::uniform_elements(acc, nt)) {
       if (iv[i] <= 9990) {
         alpaka::atomicAdd(acc, &ptv2[iv[i]], ptt2[i], alpaka::hierarchy::Blocks{});
       }
     };
     alpaka::syncBlockThreads(acc);
 
     const uint32_t threadIdxLocal(alpaka::getIdx<alpaka::Block, alpaka::Threads>(acc)[0u]);
     if (1 == nvFinal) {
       if (threadIdxLocal == 0)
         sortInd[0] = 0;
       return;
     }
 
     if constexpr (not cms::alpakatools::requires_single_thread_per_block_v<TAcc>) {
       auto& sws = alpaka::declareSharedVar<uint16_t[1024], __COUNTER__>(acc);
       // sort using only 16 bits
       cms::alpakatools::radixSort<Acc1D, float, 2>(acc, ptv2, sortInd, sws, nvFinal);
     } else {
       for (uint16_t i = 0; i < nvFinal; ++i)
         sortInd[i] = i;
       std::sort(sortInd, sortInd + nvFinal, [&](auto i, auto j) { return ptv2[i] < ptv2[j]; });
     }
   }