LArDiscreteProbabilityHelper class. More...

#include <LArDiscreteProbabilityHelper.h>

Public Member Functions
template<>
DiscreteProbabilityVector	MakeRandomisedSample (const DiscreteProbabilityVector &t, std::mt19937 &randomNumberGenerator)

template<>
unsigned int	GetSize (const DiscreteProbabilityVector &t)

template<>
float	GetElement (const DiscreteProbabilityVector &t, const unsigned int index)

Static Public Member Functions
template<typename T >
static float	CalculateCorrelationCoefficientPValueFromPermutationTest (const T &t1, const T &t2, std::mt19937 &randomNumberGenerator, const unsigned int nPermutations)
	Calculate P value for measured correlation coefficient between two datasets via a permutation test. More...

template<typename T >
static float	CalculateCorrelationCoefficientPValueFromStudentTDistribution (const T &t1, const T &t2, const unsigned int nIntegrationSteps, const float upperLimit)
	Calculate P value for measured correlation coefficient between two datasets via a integrating the student T dist. More...

template<typename T >
static float	CalculateCorrelationCoefficient (const T &t1, const T &t2)
	Calculate the correlation coefficient between two datasets. More...

template<typename T >
static float	CalculateMean (const T &t)
	Calculate the mean of a dataset. More...

Static Private Member Functions
template<typename T >
static T	MakeRandomisedSample (const T &t, std::mt19937 &randomNumberGenerator)
	Make a randomised copy of a dataset. More...

template<typename T >
static std::vector< T >	MakeRandomisedSample (const std::vector< T > &t, std::mt19937 &randomNumberGenerator)
	Make a randomised copy of dataset (dataset is an std::vector) More...

template<typename T >
static unsigned int	GetSize (const T &t)
	Get the size the size of a dataset. More...

template<typename T >
static unsigned int	GetSize (const std::vector< T > &t)
	Get the size of a dataset (dataset is an std::vector) More...

template<typename T >
static float	GetElement (const T &t, const unsigned int index)
	Get an element in a dataset. More...

template<typename T >
static float	GetElement (const std::vector< T > &t, const unsigned int index)
	Get an element in a dataset (dataset is an std::vector) More...

Detailed Description

LArDiscreteProbabilityHelper class.

Definition at line 22 of file LArDiscreteProbabilityHelper.h.

Member Function Documentation

template<typename T >

template float lar_content::LArDiscreteProbabilityHelper::CalculateCorrelationCoefficient	(	const T &	t1,
		const T &	t2
	)

static

Calculate the correlation coefficient between two datasets.

Parameters

t1	the first input dataset
t2	the second input dataset

Returns: the correlation coefficient

Definition at line 74 of file LArDiscreteProbabilityHelper.cc.

 {
     const unsigned int size1(LArDiscreteProbabilityHelper::GetSize(t1));
     const unsigned int size2(LArDiscreteProbabilityHelper::GetSize(t2));
     if (size1 != size2)
         throw pandora::StatusCodeException(pandora::STATUS_CODE_INVALID_PARAMETER);
 
     if (2 > size1)
         throw pandora::StatusCodeException(pandora::STATUS_CODE_INVALID_PARAMETER);
 
     const float mean1(LArDiscreteProbabilityHelper::CalculateMean(t1));
     const float mean2(LArDiscreteProbabilityHelper::CalculateMean(t2));
 
     float variance1(0.f), variance2(0.f), covariance(0.f);
 
     for (unsigned int iElement = 0; iElement < size1; ++iElement)
     {
         const float diff1(LArDiscreteProbabilityHelper::GetElement(t1, iElement) - mean1);
         const float diff2(LArDiscreteProbabilityHelper::GetElement(t2, iElement) - mean2);
 
         variance1 += diff1 * diff1;
         variance2 += diff2 * diff2;
         covariance += diff1 * diff2;
     }
 
     if (variance1 < std::numeric_limits<float>::epsilon() || variance2 < std::numeric_limits<float>::epsilon())
         throw pandora::StatusCodeException(pandora::STATUS_CODE_FAILURE);
 
     const float sqrtVars(std::sqrt(variance1 * variance2));
     if (sqrtVars < std::numeric_limits<float>::epsilon())
         throw pandora::StatusCodeException(pandora::STATUS_CODE_FAILURE);
 
     return covariance / sqrtVars;
 }

template<typename T >

template float lar_content::LArDiscreteProbabilityHelper::CalculateCorrelationCoefficientPValueFromPermutationTest	(	const T &	t1,
		const T &	t2,
		std::mt19937 &	randomNumberGenerator,
		const unsigned int	nPermutations
	)

static

Calculate P value for measured correlation coefficient between two datasets via a permutation test.

Parameters

t1	the first input dataset
t2	the second input dataset
randomNumberGenerator	the random number generator to shuffle the datasets
nPermutations	the number of permutations to run

Returns: the p-value

Definition at line 16 of file LArDiscreteProbabilityHelper.cc.

 {
     if (1 > nPermutations)
         throw pandora::StatusCodeException(pandora::STATUS_CODE_INVALID_PARAMETER);
 
     const float rNominal(LArDiscreteProbabilityHelper::CalculateCorrelationCoefficient(t1, t2));
 
     unsigned int nExtreme(0);
     for (unsigned int iPermutation = 0; iPermutation < nPermutations; ++iPermutation)
     {
         const float rRandomised(LArDiscreteProbabilityHelper::CalculateCorrelationCoefficient(
             LArDiscreteProbabilityHelper::MakeRandomisedSample(t1, randomNumberGenerator),
             LArDiscreteProbabilityHelper::MakeRandomisedSample(t2, randomNumberGenerator)));
 
         if ((rRandomised - rNominal) > std::numeric_limits<float>::epsilon())
             nExtreme++;
     }
 
     return static_cast<float>(nExtreme) / static_cast<float>(nPermutations);
 }

template<typename T >

template float lar_content::LArDiscreteProbabilityHelper::CalculateCorrelationCoefficientPValueFromStudentTDistribution	(	const T &	t1,
		const T &	t2,
		const unsigned int	nIntegrationSteps,
		const float	upperLimit
	)

static

Calculate P value for measured correlation coefficient between two datasets via a integrating the student T dist.

Parameters

t1	the first input dataset
t2	the second input dataset
nIntegrationSteps	how many steps to use in the trapezium integration
upperLimit	the upper limit of the integration

Returns: the p-value

Definition at line 41 of file LArDiscreteProbabilityHelper.cc.

 {
     const float correlation(LArDiscreteProbabilityHelper::CalculateCorrelationCoefficient(t1, t2));
     const float dof(static_cast<float>(LArDiscreteProbabilityHelper::GetSize(t1)) - 2.f);
 
     if (0 > dof)
         throw pandora::StatusCodeException(pandora::STATUS_CODE_INVALID_PARAMETER);
 
     const float tTestStatisticDenominator(1.f - correlation - correlation);
 
     if (tTestStatisticDenominator < std::numeric_limits<float>::epsilon())
         throw pandora::StatusCodeException(pandora::STATUS_CODE_FAILURE);
 
     const float tTestStatistic(correlation * std::sqrt(dof) / (std::sqrt(tTestStatisticDenominator)));
     const float tDistCoeff(std::tgamma(0.5f * (dof + 1.f)) / std::tgamma(0.5f * dof) / (std::sqrt(dof * M_PI)));
 
     const float dx((upperLimit - tTestStatistic) / static_cast<float>(nIntegrationSteps));
     float integral(tDistCoeff * std::pow(1.f + tTestStatistic * tTestStatistic / dof, -0.5f * (dof + 1.f)) +
                    tDistCoeff * std::pow(1.f + upperLimit * upperLimit / dof, -0.5f * (dof + 1.f)));
     for (unsigned int iStep = 1; iStep < nIntegrationSteps; ++iStep)
     {
         integral += 2.f * tDistCoeff *
                     std::pow(1.f + (tTestStatistic + static_cast<float>(iStep) * dx) * (tTestStatistic + static_cast<float>(iStep) * dx) / dof,
                         -0.5f * (dof + 1.f));
     }
 
     return integral * dx / 2.f;
 }

template<typename T >

template float lar_content::LArDiscreteProbabilityHelper::CalculateMean ( const T & t )

static

Calculate the mean of a dataset.

Parameters

t	the dataset

Returns: the mean

Definition at line 112 of file LArDiscreteProbabilityHelper.cc.

 {
     const unsigned int size(LArDiscreteProbabilityHelper::GetSize(t));
     if (1 > size)
         throw pandora::StatusCodeException(pandora::STATUS_CODE_NOT_INITIALIZED);
 
     float mean(0.f);
     for (unsigned int iElement = 0; iElement < size; ++iElement)
         mean += LArDiscreteProbabilityHelper::GetElement(t, iElement);
 
     return mean / static_cast<float>(size);
 }

template<typename T >

static float lar_content::LArDiscreteProbabilityHelper::GetElement	(	const T &	t,
		const unsigned int	index
	)

staticprivate

Get an element in a dataset.

Parameters

t	the dataset
index	the index of the element

Returns: the dataset element

template<typename T >

float lar_content::LArDiscreteProbabilityHelper::GetElement	(	const std::vector< T > &	t,
		const unsigned int	index
	)

inlinestaticprivate

Get an element in a dataset (dataset is an std::vector)

Parameters

t	the std::vector dataset
index	the index of the element

Returns: the std::vector-based dataset element

Definition at line 174 of file LArDiscreteProbabilityHelper.h.

 {
     return static_cast<float>(t.at(index));
 }

template<>

float lar_content::LArDiscreteProbabilityHelper::GetElement	(	const DiscreteProbabilityVector &	t,
		const unsigned int	index
	)

inline

Definition at line 180 of file LArDiscreteProbabilityHelper.h.

 {
     return static_cast<float>(t.GetProbability(index));
 }

template<typename T >

static unsigned int lar_content::LArDiscreteProbabilityHelper::GetSize ( const T & t )

staticprivate

Get the size the size of a dataset.

Parameters

t	the dataset

Returns: the dataset size

template<typename T >

unsigned int lar_content::LArDiscreteProbabilityHelper::GetSize ( const std::vector< T > & t )

inlinestaticprivate

Get the size of a dataset (dataset is an std::vector)

Parameters

t	the std::vector dataset

Returns: the std::vector-based dataset size

Definition at line 160 of file LArDiscreteProbabilityHelper.h.

 {
     return t.size();
 }

template<>

unsigned int lar_content::LArDiscreteProbabilityHelper::GetSize ( const DiscreteProbabilityVector & t )

inline

Definition at line 166 of file LArDiscreteProbabilityHelper.h.

 {
     return t.GetSize();
 }

template<typename T >

static T lar_content::LArDiscreteProbabilityHelper::MakeRandomisedSample	(	const T &	t,
		std::mt19937 &	randomNumberGenerator
	)

staticprivate

Make a randomised copy of a dataset.

Parameters

t	the dataset to be shuffled
randomNumberGenerator	the random number generator

Returns: the reshuffled dataset

template<typename T >

std::vector< T > lar_content::LArDiscreteProbabilityHelper::MakeRandomisedSample	(	const std::vector< T > &	t,
		std::mt19937 &	randomNumberGenerator
	)

inlinestaticprivate

Make a randomised copy of dataset (dataset is an std::vector)

Parameters

t	the std::vector-based dataset to be shuffled
randomNumberGenerator	the random number generator

Returns: the reshuffled std::vector

Definition at line 143 of file LArDiscreteProbabilityHelper.h.

 {
     std::vector<T> randomisedVector(t);
     std::shuffle(randomisedVector.begin(), randomisedVector.end(), randomNumberGenerator);
 
     return randomisedVector;
 }

template<>

DiscreteProbabilityVector lar_content::LArDiscreteProbabilityHelper::MakeRandomisedSample	(	const DiscreteProbabilityVector &	t,
		std::mt19937 &	randomNumberGenerator
	)

inline

Definition at line 152 of file LArDiscreteProbabilityHelper.h.

 {
     return DiscreteProbabilityVector(t, randomNumberGenerator);
 }

The documentation for this class was generated from the following files:

Public Member Functions

Static Public Member Functions

Static Private Member Functions

Detailed Description

Member Function Documentation