Matriplex Namespace Reference

Classes
struct	CholeskyInverter
struct	CholeskyInverter< T, 3, N >
struct	CholeskyInverterSym
struct	CholeskyInverterSym< T, 3, N >
struct	CramerInverter
struct	CramerInverter< T, 2, N >
struct	CramerInverter< T, 3, N >
struct	CramerInverterSym
struct	CramerInverterSym< T, 2, N >
struct	CramerInverterSym< T, 3, N >
class	Matriplex
class	MatriplexSym
class	MatriplexVector
struct	MultiplyCls
struct	MultiplyCls< T, 3, N >
struct	MultiplyCls< T, 6, N >
struct	SymMultiplyCls
struct	SymMultiplyCls< T, 3, N >
struct	SymMultiplyCls< T, 6, N >

Typedefs
typedef int	idx_t
template<typename T , idx_t D1, idx_t D2, idx_t N>
using	MPlex = Matriplex< T, D1, D2, N >
template<typename T , idx_t D, idx_t N>
using	MPlexSym = MatriplexSym< T, D, N >
template<class MP >
using	MPlexVec = MatriplexVector< MP >

Functions
void	align_check (const char *pref, void *adr)
void *	aligned_alloc64 (std::size_t size)
template<typename T , idx_t D, idx_t N>
void	invertCholesky (MPlexVec< MPlex< T, D, D, N >> &A, int n_to_process=0)
template<typename T , idx_t D, idx_t N>
void	invertCholesky (MPlex< T, D, D, N > &A)
template<typename T , idx_t D, idx_t N>
void	invertCholeskySym (MPlexVec< MPlexSym< T, D, N >> &A, int n_to_process=0)
template<typename T , idx_t D, idx_t N>
void	invertCholeskySym (MPlexSym< T, D, N > &A)
template<typename T , idx_t D, idx_t N>
void	invertCramer (MPlexVec< MPlex< T, D, D, N >> &A, int n_to_process=0)
template<typename T , idx_t D, idx_t N>
void	invertCramer (MPlex< T, D, D, N > &A, double *determ=nullptr)
template<typename T , idx_t D, idx_t N>
void	invertCramerSym (MPlexVec< MPlexSym< T, D, N >> &A, int n_to_process=0)
template<typename T , idx_t D, idx_t N>
void	invertCramerSym (MPlexSym< T, D, N > &A, double *determ=nullptr)
template<typename T , idx_t D1, idx_t D2, idx_t D3, idx_t N>
void	multiply (const MPlexVec< MPlex< T, D1, D2, N >> &A, const MPlexVec< MPlex< T, D2, D3, N >> &B, MPlexVec< MPlex< T, D1, D3, N >> &C, int n_to_process=0)
template<typename T , idx_t D, idx_t N>
void	multiply (const MPlexVec< MPlexSym< T, D, N >> &A, const MPlexVec< MPlexSym< T, D, N >> &B, MPlexVec< MPlex< T, D, D, N >> &C, int n_to_process=0)
template<typename T , idx_t D, idx_t N>
void	multiply (const MPlexSym< T, D, N > &A, const MPlexSym< T, D, N > &B, MPlex< T, D, D, N > &C)
template<typename T , idx_t D, idx_t N>
void	multiply (const MPlex< T, D, D, N > &A, const MPlex< T, D, D, N > &B, MPlex< T, D, D, N > &C)
template<typename T , idx_t D1, idx_t D2, idx_t D3, idx_t N>
void	multiply3in (MPlexVec< MPlex< T, D1, D2, N >> &A, MPlexVec< MPlex< T, D2, D3, N >> &B, MPlexVec< MPlex< T, D1, D3, N >> &C, int n_to_process=0)
template<typename T , idx_t D1, idx_t D2, idx_t D3, idx_t N>
void	multiplyGeneral (const MPlexVec< MPlex< T, D1, D2, N >> &A, const MPlexVec< MPlex< T, D2, D3, N >> &B, MPlexVec< MPlex< T, D1, D3, N >> &C, int n_to_process=0)
template<typename T , idx_t D1, idx_t D2, idx_t D3, idx_t N>
void	multiplyGeneral (const MPlex< T, D1, D2, N > &A, const MPlex< T, D2, D3, N > &B, MPlex< T, D1, D3, N > &C)
constexpr std::size_t	round_up_align64 (std::size_t size)

Variables
const idx_t	gSymOffsets [7][36]

Typedef Documentation

idx_t

typedef int Matriplex::idx_t

Definition at line 86 of file MatriplexCommon.h.

MPlex

template<typename T , idx_t D1, idx_t D2, idx_t N>

using Matriplex::MPlex = typedef Matriplex<T, D1, D2, N>

Definition at line 188 of file Matriplex.h.

MPlexSym

template<typename T , idx_t D, idx_t N>

using Matriplex::MPlexSym = typedef MatriplexSym<T, D, N>

Definition at line 269 of file MatriplexSym.h.

MPlexVec

template<class MP >

using Matriplex::MPlexVec = typedef MatriplexVector<MP>

Definition at line 48 of file MatriplexVector.h.

Function Documentation

align_check()

void Matriplex::align_check	(	const char *	pref,
		void *	adr
	)

Definition at line 4 of file MatriplexCommon.cc.

Referenced by mkfit::MkFitter::checkAlignment().

                                                {
    printf("%s 0x%llx  -  modulo 64 = %lld\n", pref, (long long unsigned)adr, (long long)adr % 64);
  }

aligned_alloc64()

void* Matriplex::aligned_alloc64 ( std::size_t  size )

inline

Definition at line 13 of file Memory.h.

References round_up_align64(), and findQualityFiles::size.

Referenced by mkfit::Pool< mkfit::MkFitter >::create(), and Matriplex::MatriplexVector< MP >::MatriplexVector().

{ return std::aligned_alloc(64, round_up_align64(size)); }

invertCholesky() [1/2]

template<typename T , idx_t D, idx_t N>

void Matriplex::invertCholesky	(	MPlexVec< MPlex< T, D, D, N >> &	A,
		int	n_to_process = 0
	)

Definition at line 126 of file MatriplexVector.h.

References A, mps_fire::i, invertCholesky(), and np.

                                                                            {
    const int np = n_to_process ? n_to_process : A.size();

    for (int i = 0; i < np; ++i) {
      invertCholesky(A[i]);
    }
  }

invertCholesky() [2/2]

template<typename T , idx_t D, idx_t N>

void Matriplex::invertCholesky

(

MPlex< T, D, D, N > &

A

)

Definition at line 478 of file Matriplex.h.

References A, and Matriplex::CholeskyInverter< T, D, N >::invert().

Referenced by invertCholesky().

                                            {
    CholeskyInverter<T, D, N>::invert(A);
  }

invertCholeskySym() [1/2]

template<typename T , idx_t D, idx_t N>

void Matriplex::invertCholeskySym	(	MPlexVec< MPlexSym< T, D, N >> &	A,
		int	n_to_process = 0
	)

Definition at line 144 of file MatriplexVector.h.

References A, mps_fire::i, invertCholeskySym(), and np.

                                                                               {
    const int np = n_to_process ? n_to_process : A.size();

    for (int i = 0; i < np; ++i) {
      invertCholeskySym(A[i]);
    }
  }

invertCholeskySym() [2/2]

template<typename T , idx_t D, idx_t N>

void Matriplex::invertCholeskySym

(

MPlexSym< T, D, N > &

A

)

Definition at line 461 of file MatriplexSym.h.

References A, and Matriplex::CholeskyInverterSym< T, D, N >::invert().

Referenced by invertCholeskySym().

                                               {
    CholeskyInverterSym<T, D, N>::invert(A);
  }

invertCramer() [1/2]

template<typename T , idx_t D, idx_t N>

void Matriplex::invertCramer	(	MPlexVec< MPlex< T, D, D, N >> &	A,
		int	n_to_process = 0
	)

Definition at line 117 of file MatriplexVector.h.

References A, mps_fire::i, invertCramer(), and np.

                                                                          {
    const int np = n_to_process ? n_to_process : A.size();

    for (int i = 0; i < np; ++i) {
      invertCramer(A[i]);
    }
  }

invertCramer() [2/2]

template<typename T , idx_t D, idx_t N>

void Matriplex::invertCramer	(	MPlex< T, D, D, N > &	A,
		double *	determ = nullptr
	)

Definition at line 424 of file Matriplex.h.

References A, and Matriplex::CramerInverter< T, D, N >::invert().

Referenced by mkfit::conformalFitMPlex(), and invertCramer().

                                                                    {
    CramerInverter<T, D, N>::invert(A, determ);
  }

invertCramerSym() [1/2]

template<typename T , idx_t D, idx_t N>

void Matriplex::invertCramerSym	(	MPlexVec< MPlexSym< T, D, N >> &	A,
		int	n_to_process = 0
	)

Definition at line 135 of file MatriplexVector.h.

References A, mps_fire::i, invertCramerSym(), and np.

                                                                             {
    const int np = n_to_process ? n_to_process : A.size();

    for (int i = 0; i < np; ++i) {
      invertCramerSym(A[i]);
    }
  }

invertCramerSym() [2/2]

template<typename T , idx_t D, idx_t N>

void Matriplex::invertCramerSym	(	MPlexSym< T, D, N > &	A,
		double *	determ = nullptr
	)

Definition at line 410 of file MatriplexSym.h.

References A, and Matriplex::CramerInverterSym< T, D, N >::invert().

Referenced by invertCramerSym(), mkfit::kalmanOperation(), and mkfit::kalmanOperationEndcap().

                                                                       {
    CramerInverterSym<T, D, N>::invert(A, determ);
  }

multiply() [1/4]

template<typename T , idx_t D1, idx_t D2, idx_t D3, idx_t N>

void Matriplex::multiply	(	const MPlexVec< MPlex< T, D1, D2, N >> &	A,
		const MPlexVec< MPlex< T, D2, D3, N >> &	B,
		MPlexVec< MPlex< T, D1, D3, N >> &	C,
		int	n_to_process = 0
	)

Definition at line 53 of file MatriplexVector.h.

References A, cms::cuda::assert(), B, correctionTermsCaloMet_cff::C, mps_fire::i, multiply(), and np.

                                      {
    assert(A.size() == B.size());
    assert(A.size() == C.size());

    const int np = n_to_process ? n_to_process : A.size();

    for (int i = 0; i < np; ++i) {
      multiply(A[i], B[i], C[i]);
    }
  }

multiply() [2/4]

template<typename T , idx_t D, idx_t N>

void Matriplex::multiply	(	const MPlexVec< MPlexSym< T, D, N >> &	A,
		const MPlexVec< MPlexSym< T, D, N >> &	B,
		MPlexVec< MPlex< T, D, D, N >> &	C,
		int	n_to_process = 0
	)

Definition at line 100 of file MatriplexVector.h.

References A, cms::cuda::assert(), B, correctionTermsCaloMet_cff::C, mps_fire::i, multiply(), and np.

                                      {
    assert(A.size() == B.size());
    assert(A.size() == C.size());

    const int np = n_to_process ? n_to_process : A.size();

    for (int i = 0; i < np; ++i) {
      multiply(A[i], B[i], C[i]);
    }
  }

multiply() [3/4]

template<typename T , idx_t D, idx_t N>

void Matriplex::multiply	(	const MPlexSym< T, D, N > &	A,
		const MPlexSym< T, D, N > &	B,
		MPlex< T, D, D, N > &	C
	)

Definition at line 337 of file MatriplexSym.h.

References A, B, correctionTermsCaloMet_cff::C, and Matriplex::SymMultiplyCls< T, D, N >::multiply().

                                                                                              {
    SymMultiplyCls<T, D, N>::multiply(A, B, C);
  }

multiply() [4/4]

template<typename T , idx_t D, idx_t N>

void Matriplex::multiply	(	const MPlex< T, D, D, N > &	A,
		const MPlex< T, D, D, N > &	B,
		MPlex< T, D, D, N > &	C
	)

Definition at line 340 of file Matriplex.h.

References A, B, correctionTermsCaloMet_cff::C, Matriplex::MultiplyCls< T, D, N >::multiply(), and N.

Referenced by multiply(), multiply3in(), and AlignmentExtendedCorrelationsEntry::operator*=().

                                                                                              {
#ifdef DEBUG
    printf("Multipl %d %d\n", D, N);
#endif

    MultiplyCls<T, D, N>::multiply(A, B, C);
  }

multiply3in()

template<typename T , idx_t D1, idx_t D2, idx_t D3, idx_t N>

void Matriplex::multiply3in	(	MPlexVec< MPlex< T, D1, D2, N >> &	A,
		MPlexVec< MPlex< T, D2, D3, N >> &	B,
		MPlexVec< MPlex< T, D1, D3, N >> &	C,
		int	n_to_process = 0
	)

Definition at line 83 of file MatriplexVector.h.

References A, cms::cuda::assert(), B, correctionTermsCaloMet_cff::C, mps_fire::i, multiply(), and np.

                                         {
    assert(A.size() == B.size());
    assert(A.size() == C.size());

    const int np = n_to_process ? n_to_process : A.size();

    for (int i = 0; i < np; ++i) {
      multiply(A[i], B[i], C[i]);
      multiply(B[i], C[i], A[i]);
      multiply(C[i], A[i], B[i]);
    }
  }

multiplyGeneral() [1/2]

template<typename T , idx_t D1, idx_t D2, idx_t D3, idx_t N>

void Matriplex::multiplyGeneral	(	const MPlexVec< MPlex< T, D1, D2, N >> &	A,
		const MPlexVec< MPlex< T, D2, D3, N >> &	B,
		MPlexVec< MPlex< T, D1, D3, N >> &	C,
		int	n_to_process = 0
	)

Definition at line 68 of file MatriplexVector.h.

References A, cms::cuda::assert(), B, correctionTermsCaloMet_cff::C, mps_fire::i, multiplyGeneral(), and np.

                                             {
    assert(A.size() == B.size());
    assert(A.size() == C.size());

    const int np = n_to_process ? n_to_process : A.size();

    for (int i = 0; i < np; ++i) {
      multiplyGeneral(A[i], B[i], C[i]);
    }
  }

multiplyGeneral() [2/2]

template<typename T , idx_t D1, idx_t D2, idx_t D3, idx_t N>

void Matriplex::multiplyGeneral	(	const MPlex< T, D1, D2, N > &	A,
		const MPlex< T, D2, D3, N > &	B,
		MPlex< T, D1, D3, N > &	C
	)

Definition at line 195 of file Matriplex.h.

References A, B, correctionTermsCaloMet_cff::C, trklet::D3, mps_fire::i, dqmiolumiharvest::j, dqmdumpme::k, N, and dqmiodumpmetadata::n.

Referenced by multiplyGeneral().

                                                                                                           {
    for (idx_t i = 0; i < D1; ++i) {
      for (idx_t j = 0; j < D3; ++j) {
        const idx_t ijo = N * (i * D3 + j);

#pragma omp simd
        for (idx_t n = 0; n < N; ++n) {
          C.fArray[ijo + n] = 0;
        }

        for (idx_t k = 0; k < D2; ++k) {
          const idx_t iko = N * (i * D2 + k);
          const idx_t kjo = N * (k * D3 + j);

#pragma omp simd
          for (idx_t n = 0; n < N; ++n) {
            C.fArray[ijo + n] += A.fArray[iko + n] * B.fArray[kjo + n];
          }
        }
      }
    }
  }

round_up_align64()

constexpr std::size_t Matriplex::round_up_align64

(

std::size_t

size

)

Definition at line 8 of file Memory.h.

References findQualityFiles::size.

Referenced by aligned_alloc64().

                                                       {
    constexpr std::size_t mask = 64 - 1;
    return size & mask ? (size & ~mask) + 64 : size;
  }

Variable Documentation

gSymOffsets

const idx_t Matriplex::gSymOffsets[7][36]

Initial value:

= {{},
                                    {},
                                    {0, 1, 1, 2},
                                    {0, 1, 3, 1, 2, 4, 3, 4, 5},  
                                    {},
                                    {},
                                    {0, 1, 3, 6, 10, 15, 1,  2,  4,  7,  11, 16, 3,  4,  5,  8,  12, 17,
                                     6, 7, 8, 9, 13, 18, 10, 11, 12, 13, 14, 19, 15, 16, 17, 18, 19, 20}}

Definition at line 13 of file MatriplexSym.h.

Referenced by Matriplex::MatriplexSym< float, LL, NN >::off(), and Matriplex::MatriplexSym< float, LL, NN >::offsets().