DiscreteProbabilityVector class. More...

#include <LArDiscreteProbabilityVector.h>

Classes
class	DiscreteProbabilityDatum
	DiscreteProbabilityData class. More...

Public Types
template<typename TX , typename TY >
using	InputDatum = std::pair< TX, TY >

template<typename TX , typename TY >
using	InputData = std::vector< InputDatum< TX, TY >>

typedef InputData< float, float >	AllFloatInputData

typedef pandora::FloatVector	ResamplingPoints

Public Member Functions
template<typename TX , typename TY >
	DiscreteProbabilityVector (const InputData< TX, TY > &inputData, const TX xUpperBound, const bool useWidths)
	Constructor. More...

	DiscreteProbabilityVector (const DiscreteProbabilityVector &discreteProbabilityVector, const ResamplingPoints &resamplingPoints)
	Constructor. More...

	DiscreteProbabilityVector (const DiscreteProbabilityVector &discreteProbabilityVector, std::mt19937 &randomNumberGenerator)
	Constructor. More...

float	EvaluateCumulativeProbability (const float x) const
	Evaluate the cumulative probability at arbitrary x. More...

unsigned int	GetSize () const
	Get the size of the probability vector. More...

float	GetX (const unsigned int index) const
	Get the x value of the element in the vector. More...

float	GetProbability (const unsigned int index) const
	Get the probability value of the element in the vector. More...

float	GetProbabilityDensity (const unsigned int index) const
	Get the probability density value of the element in the vector. More...

float	GetCumulativeProbability (const unsigned int index) const
	Get the cumulative probability value of the element in the vector. More...

float	GetWidth (const unsigned int index) const
	Get the width of the element in the vectorr. More...

void	GetAllAtIndex (const unsigned int index, float &x, float &probabilityDensity, float &cumulativeProbability, float &width) const
	Get all information stored at a particular index. More...

Private Types
typedef std::vector < DiscreteProbabilityDatum >	DiscreteProbabilityData

Private Member Functions
template<typename TX , typename TY >
DiscreteProbabilityData	InitialiseDiscreteProbabilityData (InputData< TX, TY > inputData) const
	Get a initialised probability data vector from the input data. More...

DiscreteProbabilityData	ResampleDiscreteProbabilityData (const DiscreteProbabilityVector &discreteProbabilityVector, const ResamplingPoints &resamplingPoints) const
	Get a resampled probability data vector by resampling another probability data vector. More...

DiscreteProbabilityData	RandomiseDiscreteProbabilityData (const DiscreteProbabilityVector &discreteProbabilityVector, std::mt19937 &randomNumberGenerator) const
	Get a randomised probability data vector in which the x values are unchanged, the probability density is randomised and the cumulative probability is recalculated. More...

template<typename TX , typename TY >
float	CalculateNormalisation (const InputData< TX, TY > &inputData) const
	Calculate the probability normalisation. More...

void	VerifyCompleteData () const
	Verify the integrity of the complete probability vector. More...

void	VerifyElementRequest (const unsigned int index) const
	Verify the integrity of the element request. More...

Static Private Member Functions
template<typename TX , typename TY >
static bool	SortInputDataByX (const InputDatum< TX, TY > &lhs, const InputDatum< TX, TY > &rhs)
	Sort the input data according to their x value. More...

Private Attributes
float	m_xUpperBound
	the upper bound of the probability vector More...

bool	m_useWidths
	controls whether bin widths are used in calculations More...

DiscreteProbabilityData	m_discreteProbabilityData
	the probability data More...

Detailed Description

DiscreteProbabilityVector class.

Definition at line 25 of file LArDiscreteProbabilityVector.h.

Member Typedef Documentation

typedef InputData<float, float> lar_content::DiscreteProbabilityVector::AllFloatInputData

Definition at line 34 of file LArDiscreteProbabilityVector.h.

typedef std::vector<DiscreteProbabilityDatum> lar_content::DiscreteProbabilityVector::DiscreteProbabilityData

private

Definition at line 188 of file LArDiscreteProbabilityVector.h.

template<typename TX , typename TY >

using lar_content::DiscreteProbabilityVector::InputData = std::vector<InputDatum<TX, TY>>

Definition at line 32 of file LArDiscreteProbabilityVector.h.

template<typename TX , typename TY >

using lar_content::DiscreteProbabilityVector::InputDatum = std::pair<TX, TY>

Definition at line 29 of file LArDiscreteProbabilityVector.h.

typedef pandora::FloatVector lar_content::DiscreteProbabilityVector::ResamplingPoints

Definition at line 36 of file LArDiscreteProbabilityVector.h.

Constructor & Destructor Documentation

template<typename TX , typename TY >

lar_content::DiscreteProbabilityVector::DiscreteProbabilityVector	(	const InputData< TX, TY > &	inputData,
		const TX	xUpperBound,
		const bool	useWidths
	)

Constructor.

Parameters

inputData	the data used to construct the probability vector
xUpperBound	the upper bound of the probability vector
useWidths	bool controlling whether the bin widths are used in calculations

Definition at line 19 of file LArDiscreteProbabilityVector.cc.

                                                                                                                                    :
     m_xUpperBound(static_cast<float>(xUpperBound)),
     m_useWidths(useWidths),
     m_discreteProbabilityData(this->InitialiseDiscreteProbabilityData(inputData))
 {
     this->VerifyCompleteData();
 }

lar_content::DiscreteProbabilityVector::DiscreteProbabilityVector	(	const DiscreteProbabilityVector &	discreteProbabilityVector,
		const ResamplingPoints &	resamplingPoints
	)

Constructor.

Parameters

discreteProbabilityVector	a discrete probability vector to resample from
resamplingPoints	the points to resample the discrete probability vector with

Definition at line 39 of file LArDiscreteProbabilityVector.cc.

                                                                                                                                                          :
     m_xUpperBound(discreteProbabilityVector.m_xUpperBound),
     m_useWidths(discreteProbabilityVector.m_useWidths),
     m_discreteProbabilityData(this->ResampleDiscreteProbabilityData(discreteProbabilityVector, resamplingPoints))
 {
     this->VerifyCompleteData();
 }

lar_content::DiscreteProbabilityVector::DiscreteProbabilityVector	(	const DiscreteProbabilityVector &	discreteProbabilityVector,
		std::mt19937 &	randomNumberGenerator
	)

Constructor.

Parameters

discreteProbabilityVector	a discrete probability vector to randomly rearrange
randomNumberGenerator	the random number generator for the random reshuffling

Definition at line 29 of file LArDiscreteProbabilityVector.cc.

                                                                                                                                                   :
     m_xUpperBound(discreteProbabilityVector.m_xUpperBound),
     m_useWidths(discreteProbabilityVector.m_useWidths),
     m_discreteProbabilityData(this->RandomiseDiscreteProbabilityData(discreteProbabilityVector, randomNumberGenerator))
 {
     this->VerifyCompleteData();
 }

Member Function Documentation

template<typename TX , typename TY >

template float lar_content::DiscreteProbabilityVector::CalculateNormalisation ( const InputData< TX, TY > & inputData ) const

private

Calculate the probability normalisation.

Parameters

inputData the input data

Returns: the probability normalisation

Definition at line 199 of file LArDiscreteProbabilityVector.cc.

 {
     if (2 > inputData.size())
         throw pandora::StatusCodeException(pandora::STATUS_CODE_INVALID_PARAMETER);
 
     float normalisation(0.f);
 
     for (unsigned int iDatum = 0; iDatum < inputData.size() - 1; ++iDatum)
     {
         const float y(static_cast<float>(inputData.at(iDatum).second));
         normalisation +=
             y * (m_useWidths ? static_cast<float>(inputData.at(iDatum + 1).first) - static_cast<float>(inputData.at(iDatum).first) : 1.f);
     }
     const float y(static_cast<float>(inputData.back().second));
     normalisation += y * (m_useWidths ? m_xUpperBound - static_cast<float>(inputData.back().first) : 1.f);
 
     return normalisation;
 }

float lar_content::DiscreteProbabilityVector::EvaluateCumulativeProbability ( const float x ) const

Evaluate the cumulative probability at arbitrary x.

Parameters

x	the x value

Returns: the cumulative probability

Definition at line 49 of file LArDiscreteProbabilityVector.cc.

 {
     if (x - m_discreteProbabilityData.back().GetX() > std::numeric_limits<float>::epsilon())
         return 1.f;
 
     if (x - m_discreteProbabilityData.front().GetX() < std::numeric_limits<float>::epsilon())
         return 0.f;
 
     for (unsigned int iDatum = 1; iDatum < m_discreteProbabilityData.size(); ++iDatum)
     {
         if (x - m_discreteProbabilityData.at(iDatum).GetX() > std::numeric_limits<float>::epsilon())
             continue;
 
         const float xLow(m_discreteProbabilityData.at(iDatum - 1).GetX());
         const float yLow(m_discreteProbabilityData.at(iDatum - 1).GetCumulativeDatum());
         const float xHigh(m_discreteProbabilityData.at(iDatum).GetX());
         const float yHigh(m_discreteProbabilityData.at(iDatum).GetCumulativeDatum());
 
         if (std::fabs(xHigh - xLow) < std::numeric_limits<float>::epsilon())
             throw pandora::StatusCodeException(pandora::STATUS_CODE_INVALID_PARAMETER);
 
         const float m((yHigh - yLow) / (xHigh - xLow));
         const float c(yLow - m * xLow);
 
         return m * x + c;
     }
 
     throw pandora::StatusCodeException(pandora::STATUS_CODE_INVALID_PARAMETER);
 }

void lar_content::DiscreteProbabilityVector::GetAllAtIndex	(	const unsigned int	index,
		float &	x,
		float &	probabilityDensity,
		float &	cumulativeProbability,
		float &	width
	)		const

inline

Get all information stored at a particular index.

Parameters

index	the index in the vector
x	the x value
probabilityDensity	the probability density value
cumulativeProbability	the cumulative probability value
width	the width of the probability bin

Definition at line 315 of file LArDiscreteProbabilityVector.h.

 {
     this->VerifyElementRequest(index);
 
     const DiscreteProbabilityDatum &theDatum(m_discreteProbabilityData.at(index));
     x = theDatum.GetX();
     probabilityDensity = theDatum.GetDensityDatum();
     cumulativeProbability = theDatum.GetCumulativeDatum();
     width = theDatum.GetWidth();
 }

float lar_content::DiscreteProbabilityVector::GetCumulativeProbability ( const unsigned int index ) const

inline

Get the cumulative probability value of the element in the vector.

Parameters

index the index in the vector

Returns: the cumulative probability

Definition at line 297 of file LArDiscreteProbabilityVector.h.

 {
     this->VerifyElementRequest(index);
 
     return m_discreteProbabilityData.at(index).GetCumulativeDatum();
 }

float lar_content::DiscreteProbabilityVector::GetProbability ( const unsigned int index ) const

inline

Get the probability value of the element in the vector.

Parameters

index the index in the vector

Returns: the probability

Definition at line 279 of file LArDiscreteProbabilityVector.h.

 {
     this->VerifyElementRequest(index);
 
     return m_discreteProbabilityData.at(index).GetDensityDatum() * (m_useWidths ? m_discreteProbabilityData.at(index).GetWidth() : 1.f);
 }

float lar_content::DiscreteProbabilityVector::GetProbabilityDensity ( const unsigned int index ) const

inline

Get the probability density value of the element in the vector.

Parameters

index the index in the vector

Returns: the probability density

Definition at line 288 of file LArDiscreteProbabilityVector.h.

 {
     this->VerifyElementRequest(index);
 
     return m_discreteProbabilityData.at(index).GetDensityDatum();
 }

unsigned int lar_content::DiscreteProbabilityVector::GetSize ( ) const

inline

Get the size of the probability vector.

Returns: the probability vector size

Definition at line 263 of file LArDiscreteProbabilityVector.h.

 {
     return m_discreteProbabilityData.size();
 }

float lar_content::DiscreteProbabilityVector::GetWidth ( const unsigned int index ) const

inline

Get the width of the element in the vectorr.

Parameters

index the index in the vector

Returns: the width of the probability bin

Definition at line 306 of file LArDiscreteProbabilityVector.h.

 {
     this->VerifyElementRequest(index);
 
     return m_discreteProbabilityData.at(index).GetWidth();
 }

float lar_content::DiscreteProbabilityVector::GetX ( const unsigned int index ) const

inline

Get the x value of the element in the vector.

Parameters

index the index in the vector

Returns: the x value

Definition at line 270 of file LArDiscreteProbabilityVector.h.

 {
     this->VerifyElementRequest(index);
 
     return m_discreteProbabilityData.at(index).GetX();
 }

template<typename TX , typename TY >

template DiscreteProbabilityVector::DiscreteProbabilityData lar_content::DiscreteProbabilityVector::InitialiseDiscreteProbabilityData ( InputData< TX, TY > inputData ) const

private

Get a initialised probability data vector from the input data.

Parameters

inputData the input data

Returns: a fully-initialised discrete probability data vector

Definition at line 82 of file LArDiscreteProbabilityVector.cc.

 {
     if (2 > inputData.size())
         throw pandora::StatusCodeException(pandora::STATUS_CODE_INVALID_PARAMETER);
 
     std::sort(inputData.begin(), inputData.end(), DiscreteProbabilityVector::SortInputDataByX<TX, TY>);
 
     if (inputData.back().first - m_xUpperBound > std::numeric_limits<float>::epsilon())
         throw pandora::StatusCodeException(pandora::STATUS_CODE_INVALID_PARAMETER);
 
     const float normalisation(this->CalculateNormalisation(inputData));
 
     if (normalisation < std::numeric_limits<float>::epsilon())
         throw pandora::StatusCodeException(pandora::STATUS_CODE_FAILURE);
 
     float accumulationDatum(0.f);
 
     DiscreteProbabilityData data;
     for (unsigned int iDatum = 0; iDatum < inputData.size() - 1; ++iDatum)
     {
         const float x(static_cast<float>(inputData.at(iDatum).first));
         const float deltaX(static_cast<float>(inputData.at(iDatum + 1).first) - x);
         const float densityDatum(static_cast<float>(inputData.at(iDatum).second) / normalisation);
         accumulationDatum += densityDatum * (m_useWidths ? deltaX : 1.f);
         data.emplace_back(DiscreteProbabilityVector::DiscreteProbabilityDatum(x, densityDatum, accumulationDatum, deltaX));
     }
     const float x(static_cast<float>(inputData.back().first));
     const float deltaX(m_xUpperBound - x);
     const float densityDatum(static_cast<float>(inputData.back().second) / normalisation);
     accumulationDatum += densityDatum * (m_useWidths ? deltaX : 1.f);
     data.emplace_back(DiscreteProbabilityVector::DiscreteProbabilityDatum(x, densityDatum, accumulationDatum, deltaX));
 
     return data;
 }

DiscreteProbabilityVector::DiscreteProbabilityData lar_content::DiscreteProbabilityVector::RandomiseDiscreteProbabilityData	(	const DiscreteProbabilityVector &	discreteProbabilityVector,
		std::mt19937 &	randomNumberGenerator
	)		const

private

Get a randomised probability data vector in which the x values are unchanged, the probability density is randomised and the cumulative probability is recalculated.

Parameters

discreteProbabilityVector	another discrete probability vector
randomNumberGenerator	the random number generator for the random reshuffling

Returns: a resampled probability data vector

Definition at line 159 of file LArDiscreteProbabilityVector.cc.

 {
     DiscreteProbabilityData randomisedProbabilityData;
 
     std::vector<unsigned int> randomisedElements(discreteProbabilityVector.GetSize());
     std::iota(std::begin(randomisedElements), std::end(randomisedElements), 0);
     std::shuffle(std::begin(randomisedElements), std::end(randomisedElements), randomNumberGenerator);
 
     float xPos(discreteProbabilityVector.GetX(0));
     float cumulativeProbability(0.f);
     for (unsigned int iElement = 0; iElement < discreteProbabilityVector.GetSize(); ++iElement)
     {
         const unsigned int randomElementIndex(randomisedElements.at(iElement));
         const float deltaX(discreteProbabilityVector.GetWidth(randomElementIndex));
         const float probabilityDensity(discreteProbabilityVector.GetProbabilityDensity(randomElementIndex));
         cumulativeProbability += probabilityDensity * (m_useWidths ? deltaX : 1.f);
         randomisedProbabilityData.emplace_back(
             DiscreteProbabilityVector::DiscreteProbabilityDatum(xPos, probabilityDensity, cumulativeProbability, deltaX));
         xPos += deltaX;
     }
 
     return randomisedProbabilityData;
 }

DiscreteProbabilityVector::DiscreteProbabilityData lar_content::DiscreteProbabilityVector::ResampleDiscreteProbabilityData	(	const DiscreteProbabilityVector &	discreteProbabilityVector,
		const ResamplingPoints &	resamplingPoints
	)		const

private

Get a resampled probability data vector by resampling another probability data vector.

Parameters

discreteProbabilityVector	another discrete probability vector
resamplingPoints	the points to resample the discrete probability vector with

Returns: a resampled probability data vector

Definition at line 119 of file LArDiscreteProbabilityVector.cc.

 {
     if (2 > resamplingPoints.size())
         throw pandora::StatusCodeException(pandora::STATUS_CODE_INVALID_PARAMETER);
 
     DiscreteProbabilityData resampledProbabilityData;
 
     float prevCumulativeData(0.f);
     for (unsigned int iSample = 0; iSample < resamplingPoints.size() - 1; ++iSample)
     {
         const float xResampled(resamplingPoints.at(iSample));
         const float deltaX(resamplingPoints.at(iSample + 1) - xResampled);
 
         if (deltaX < std::numeric_limits<float>::epsilon())
             throw pandora::StatusCodeException(pandora::STATUS_CODE_INVALID_PARAMETER);
 
         const float cumulativeDatumResampled(discreteProbabilityVector.EvaluateCumulativeProbability(xResampled));
         const float densityDatumResampled((cumulativeDatumResampled - prevCumulativeData) / (m_useWidths ? deltaX : 1.f));
         resampledProbabilityData.emplace_back(
             DiscreteProbabilityVector::DiscreteProbabilityDatum(xResampled, densityDatumResampled, cumulativeDatumResampled, deltaX));
         prevCumulativeData = cumulativeDatumResampled;
     }
 
     const float xResampled(resamplingPoints.back());
     const float deltaX(m_xUpperBound - xResampled);
 
     if (deltaX < std::numeric_limits<float>::epsilon())
         throw pandora::StatusCodeException(pandora::STATUS_CODE_INVALID_PARAMETER);
 
     const float cumulativeDatumResampled(discreteProbabilityVector.EvaluateCumulativeProbability(xResampled));
     const float densityDatumResampled((cumulativeDatumResampled - prevCumulativeData) / (m_useWidths ? deltaX : 1.f));
     resampledProbabilityData.emplace_back(
         DiscreteProbabilityVector::DiscreteProbabilityDatum(xResampled, densityDatumResampled, cumulativeDatumResampled, deltaX));
 
     return resampledProbabilityData;
 }

template<typename TX , typename TY >

template bool lar_content::DiscreteProbabilityVector::SortInputDataByX	(	const InputDatum< TX, TY > &	lhs,
		const InputDatum< TX, TY > &	rhs
	)

staticprivate

Sort the input data according to their x value.

Parameters

lhs	the first InputDatum
lhs	the second InputDatum

Returns: a bool dictacting swapping the two InputDatums

Definition at line 187 of file LArDiscreteProbabilityVector.cc.

 {
     const float deltaX(static_cast<float>(rhs.first) - static_cast<float>(lhs.first));
     if (std::fabs(deltaX) < std::numeric_limits<float>::epsilon())
         return (lhs.second < rhs.second);
 
     return (lhs.first < rhs.first);
 }

void lar_content::DiscreteProbabilityVector::VerifyCompleteData ( ) const

inlineprivate

Verify the integrity of the complete probability vector.

Definition at line 368 of file LArDiscreteProbabilityVector.h.

 {
     if (2 > m_discreteProbabilityData.size())
         throw pandora::StatusCodeException(pandora::STATUS_CODE_NOT_INITIALIZED);
 
     if (m_discreteProbabilityData.back().GetX() - m_xUpperBound > std::numeric_limits<float>::epsilon())
         throw pandora::StatusCodeException(pandora::STATUS_CODE_INVALID_PARAMETER);
 
     return;
 }

void lar_content::DiscreteProbabilityVector::VerifyElementRequest ( const unsigned int index ) const

inlineprivate

Verify the integrity of the element request.

Parameters

index the index in the probability vector

Definition at line 381 of file LArDiscreteProbabilityVector.h.

 {
     if (this->GetSize() < index)
         throw pandora::StatusCodeException(pandora::STATUS_CODE_OUT_OF_RANGE);
 
     return;
 }

Member Data Documentation

DiscreteProbabilityData lar_content::DiscreteProbabilityVector::m_discreteProbabilityData

private

the probability data

Definition at line 258 of file LArDiscreteProbabilityVector.h.

bool lar_content::DiscreteProbabilityVector::m_useWidths

private

controls whether bin widths are used in calculations

Definition at line 257 of file LArDiscreteProbabilityVector.h.

float lar_content::DiscreteProbabilityVector::m_xUpperBound

private

the upper bound of the probability vector

Definition at line 256 of file LArDiscreteProbabilityVector.h.

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

Classes

Public Types

Public Member Functions

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation