LArMvaHelper class. More...

#include <LArMvaHelper.h>

Public Types
typedef MvaTypes::MvaFeature	MvaFeature

typedef MvaTypes::MvaFeatureVector	MvaFeatureVector

typedef std::map< std::string, double >	DoubleMap

typedef MvaTypes::MvaFeatureMap	MvaFeatureMap

typedef std::map< std::string, pandora::AlgorithmTool * >	AlgorithmToolMap

Static Public Member Functions
template<typename TCONTAINER >
static pandora::StatusCode	ProduceTrainingExample (const std::string &trainingOutputFile, const bool result, TCONTAINER &&featureContainer)
	Produce a training example with the given features and result. More...

template<typename TCONTAINER >
static pandora::StatusCode	ProduceTrainingExample (const std::string &trainingOutputFile, const bool result, const pandora::StringVector &featureOrder, TCONTAINER &&featureContainer)
	Produce a training example with the given features and result - using a map. More...

template<typename TCONTAINER >
static bool	Classify (const MvaInterface &classifier, TCONTAINER &&featureContainer)
	Use the trained classifier to predict the boolean class of an example. More...

template<typename TCONTAINER >
static bool	Classify (const MvaInterface &classifier, const pandora::StringVector &featureOrder, TCONTAINER &&featureContainer)
	Use the trained classifier to predict the boolean class of an example – using a map. More...

template<typename TCONTAINER >
static double	CalculateClassificationScore (const MvaInterface &classifier, TCONTAINER &&featureContainer)
	Use the trained classifer to calculate the classification score of an example (>0 means boolean class true) More...

template<typename TCONTAINER >
static double	CalculateProbability (const MvaInterface &classifier, TCONTAINER &&featureContainer)
	Use the trained mva to calculate a classification probability for an example. More...

template<typename TCONTAINER >
static double	CalculateProbability (const MvaInterface &classifier, const pandora::StringVector &featureOrder, TCONTAINER &&featureContainer)
	Use the trained mva to calculate a classification probability for an example – using a map. More...

template<typename... Ts, typename... TARGS>
static MvaFeatureVector	CalculateFeatures (const MvaFeatureToolVector< Ts...> &featureToolVector, TARGS &&...args)
	Calculate the features in a given feature tool vector. More...

template<typename... Ts, typename... TARGS>
static MvaFeatureMap	CalculateFeatures (const pandora::StringVector &featureToolOrder, const MvaFeatureToolMap< Ts...> &featureToolMap, pandora::StringVector &featureOrder, TARGS &&...args)
	Calculate the features in a given feature tool map, and fill an MvaFeatureMap and vector with feature order. More...

template<typename T , typename... Ts, typename... TARGS>
static MvaFeatureVector	CalculateFeaturesOfType (const MvaFeatureToolVector< Ts...> &featureToolVector, TARGS &&...args)
	Calculate the features of a given derived feature tool type in a feature tool vector. More...

template<typename... Ts>
static pandora::StatusCode	AddFeatureToolToVector (pandora::AlgorithmTool *const pFeatureTool, MvaFeatureToolVector< Ts...> &featureToolVector)
	Add a feature tool to a vector of feature tools. More...

template<typename... Ts>
static pandora::StatusCode	AddFeatureToolToMap (pandora::AlgorithmTool *const pFeatureTool, std::string pFeatureToolName, MvaFeatureToolMap< Ts...> &featureToolMap)
	Add a feature tool to a map of feature tools. More...

static pandora::StatusCode	ProcessAlgorithmToolListToMap (const pandora::Algorithm &algorithm, const pandora::TiXmlHandle &xmlHandle, const std::string &listName, pandora::StringVector &algorithToolNameVector, AlgorithmToolMap &algorithmToolMap)
	Process a list of algorithms tools in an xml file, using a map. Idea is for this to go to XmlHelper in PandoraSDK eventually as an overload to ProcessAlgorithmToolList. More...

template<typename TLIST , typename... TLISTS>
static MvaFeatureVector	ConcatenateFeatureLists (TLIST &&featureList, TLISTS &&...featureLists)
	Recursively concatenate vectors of features. More...

static MvaFeatureVector	ConcatenateFeatureLists ()
	Recursively concatenate vectors of features (terminating method) More...

Static Private Member Functions
static std::string	GetTimestampString ()
	Get a timestamp string for this point in time. More...

template<typename TCONTAINER >
static pandora::StatusCode	WriteFeaturesToFile (std::ofstream &outfile, const std::string &delimiter, TCONTAINER &&featureContainer)
	Write the features of the given lists to file. More...

template<typename TCONTAINER >
static pandora::StatusCode	WriteFeaturesToFileImpl (std::ofstream &outfile, const std::string &delimiter, TCONTAINER &&featureContainer)
	Write the features of the given list to file (implementation method) More...

Detailed Description

LArMvaHelper class.

Definition at line 68 of file LArMvaHelper.h.

Member Typedef Documentation

typedef std::map<std::string, pandora::AlgorithmTool *> lar_content::LArMvaHelper::AlgorithmToolMap

Definition at line 76 of file LArMvaHelper.h.

typedef std::map<std::string, double> lar_content::LArMvaHelper::DoubleMap

Definition at line 73 of file LArMvaHelper.h.

typedef MvaTypes::MvaFeature lar_content::LArMvaHelper::MvaFeature

Definition at line 71 of file LArMvaHelper.h.

typedef MvaTypes::MvaFeatureMap lar_content::LArMvaHelper::MvaFeatureMap

Definition at line 75 of file LArMvaHelper.h.

typedef MvaTypes::MvaFeatureVector lar_content::LArMvaHelper::MvaFeatureVector

Definition at line 72 of file LArMvaHelper.h.

Member Function Documentation

template<typename... Ts>

pandora::StatusCode lar_content::LArMvaHelper::AddFeatureToolToMap	(	pandora::AlgorithmTool *const	pFeatureTool,
		std::string	pFeatureToolName,
		MvaFeatureToolMap< Ts...> &	featureToolMap
	)

static

Add a feature tool to a map of feature tools.

Parameters

pFeatureTool	the feature tool
pFeatureToolName	the name of the feature tool
featureToolMap	the map to append

Returns: success

Definition at line 462 of file LArMvaHelper.h.

 {
     if (MvaFeatureTool<Ts...> *const pCastFeatureTool = dynamic_cast<MvaFeatureTool<Ts...> *const>(pFeatureTool))
     {
         featureToolMap[pFeatureToolName] = pCastFeatureTool;
         return pandora::STATUS_CODE_SUCCESS;
     }
 
     return pandora::STATUS_CODE_FAILURE;
 }

template<typename... Ts>

pandora::StatusCode lar_content::LArMvaHelper::AddFeatureToolToVector	(	pandora::AlgorithmTool *const	pFeatureTool,
		MvaFeatureToolVector< Ts...> &	featureToolVector
	)

static

Add a feature tool to a vector of feature tools.

Parameters

pFeatureTool	the feature tool
featureToolVector	the vector to append

Returns: success

Definition at line 448 of file LArMvaHelper.h.

 {
     if (MvaFeatureTool<Ts...> *const pCastFeatureTool = dynamic_cast<MvaFeatureTool<Ts...> *const>(pFeatureTool))
     {
         featureToolVector.push_back(pCastFeatureTool);
         return pandora::STATUS_CODE_SUCCESS;
     }
 
     return pandora::STATUS_CODE_FAILURE;
 }

template<typename TCONTAINER >

double lar_content::LArMvaHelper::CalculateClassificationScore	(	const MvaInterface &	classifier,
		TCONTAINER &&	featureContainer
	)

static

Use the trained classifer to calculate the classification score of an example (>0 means boolean class true)

Parameters

classifier	the classifier
featureContainer	the container of features

Returns: the classification score

Definition at line 358 of file LArMvaHelper.h.

 {
     return classifier.CalculateClassificationScore(featureContainer);
 }

template<typename... Ts, typename... TARGS>

LArMvaHelper::MvaFeatureVector lar_content::LArMvaHelper::CalculateFeatures	(	const MvaFeatureToolVector< Ts...> &	featureToolVector,
		TARGS &&...	args
	)

static

Calculate the features in a given feature tool vector.

Parameters

featureToolVector	the feature tool vector
args	arguments to pass to the tool

Returns: the vector of features

Definition at line 396 of file LArMvaHelper.h.

 {
     LArMvaHelper::MvaFeatureVector featureVector;
 
     for (MvaFeatureTool<Ts...> *const pFeatureTool : featureToolVector)
         pFeatureTool->Run(featureVector, std::forward<TARGS>(args)...);
 
     return featureVector;
 }

template<typename... Ts, typename... TARGS>

LArMvaHelper::MvaFeatureMap lar_content::LArMvaHelper::CalculateFeatures	(	const pandora::StringVector &	featureToolOrder,
		const MvaFeatureToolMap< Ts...> &	featureToolMap,
		pandora::StringVector &	featureOrder,
		TARGS &&...	args
	)

static

Calculate the features in a given feature tool map, and fill an MvaFeatureMap and vector with feature order.

Parameters

featureToolOrder	vector of strings of the ordered keys
featureToolMap	the feature tool map
featureOrder	a vector that is to be filled with the order of features in the function
args	arguments to pass to the tool

Returns: the map of features

Definition at line 409 of file LArMvaHelper.h.

 {
     LArMvaHelper::MvaFeatureMap featureMap;
 
     for (auto const &pFeatureToolName : featureToolOrder)
     {
         if (featureToolMap.find(pFeatureToolName) == featureToolMap.end())
         {
             std::cout << "LArMvaHelper::CalculateFeatures "
                       << "- Error: feature tool " << pFeatureToolName << " not found." << std::endl;
             throw pandora::StatusCodeException(pandora::STATUS_CODE_NOT_FOUND);
         }
         featureToolMap.at(pFeatureToolName)->Run(featureMap, featureOrder, pFeatureToolName, std::forward<TARGS>(args)...);
     }
 
     return featureMap;
 }

template<typename T , typename... Ts, typename... TARGS>

LArMvaHelper::MvaFeatureVector lar_content::LArMvaHelper::CalculateFeaturesOfType	(	const MvaFeatureToolVector< Ts...> &	featureToolVector,
		TARGS &&...	args
	)

static

Calculate the features of a given derived feature tool type in a feature tool vector.

Parameters

featureToolVector	the feature tool vector
args	arguments to pass to the tool

Returns: the vector of features

Definition at line 431 of file LArMvaHelper.h.

 {
     using TD = typename std::decay<T>::type;
     LArMvaHelper::MvaFeatureVector featureVector;
 
     for (MvaFeatureTool<Ts...> *const pFeatureTool : featureToolVector)
     {
         if (TD *const pCastFeatureTool = dynamic_cast<TD *const>(pFeatureTool))
             pCastFeatureTool->Run(featureVector, std::forward<TARGS>(args)...);
     }
 
     return featureVector;
 }

template<typename TCONTAINER >

double lar_content::LArMvaHelper::CalculateProbability	(	const MvaInterface &	classifier,
		TCONTAINER &&	featureContainer
	)

static

Use the trained mva to calculate a classification probability for an example.

Parameters

classifier	the classifier
featureContainer	the container of features

Returns: the classification probability

Definition at line 366 of file LArMvaHelper.h.

 {
     return classifier.CalculateProbability(featureContainer);
 }

template<typename TCONTAINER >

double lar_content::LArMvaHelper::CalculateProbability	(	const MvaInterface &	classifier,
		const pandora::StringVector &	featureOrder,
		TCONTAINER &&	featureContainer
	)

static

Use the trained mva to calculate a classification probability for an example – using a map.

Parameters

classifier	the classifier
featureOrder	the vector of strings corresponding to ordered list of keys
featureContainer	the container of features

Returns: the classification probability

Definition at line 374 of file LArMvaHelper.h.

 {
     // Make a feature vector from the map and calculate the features
     LArMvaHelper::MvaFeatureVector featureVector;
 
     for (auto const &pFeatureToolName : featureOrder)
     {
         if (featureContainer.find(pFeatureToolName) == featureContainer.end())
         {
             std::cout << "LArMvaHelper::CalculateProbability "
                       << "- Error: feature tool " << pFeatureToolName << " not found." << std::endl;
             throw pandora::StatusCodeException(pandora::STATUS_CODE_NOT_FOUND);
         }
         featureVector.push_back(featureContainer.at(pFeatureToolName));
     }
 
     return CalculateProbability(classifier, featureVector);
 }

template<typename TCONTAINER >

bool lar_content::LArMvaHelper::Classify	(	const MvaInterface &	classifier,
		TCONTAINER &&	featureContainer
	)

static

Use the trained classifier to predict the boolean class of an example.

Parameters

classifier	the classifier
featureContainer	the container of features

Returns: the predicted boolean class of the example

Definition at line 328 of file LArMvaHelper.h.

 {
     return classifier.Classify(featureContainer);
 }

template<typename TCONTAINER >

bool lar_content::LArMvaHelper::Classify	(	const MvaInterface &	classifier,
		const pandora::StringVector &	featureOrder,
		TCONTAINER &&	featureContainer
	)

static

Use the trained classifier to predict the boolean class of an example – using a map.

Parameters

classifier	the classifier
featureOrder	the vector of strings corresponding to ordered list of keys
featureContainer	the container of features

Returns: the predicted boolean class of the example

Definition at line 336 of file LArMvaHelper.h.

 {
     // Make a feature vector from the map and calculate the features
     LArMvaHelper::MvaFeatureVector featureVector;
 
     for (auto const &pFeatureToolName : featureOrder)
     {
         if (featureContainer.find(pFeatureToolName) == featureContainer.end())
         {
             std::cout << "LArMvaHelper::Classify "
                       << "- Error: feature tool " << pFeatureToolName << " not found." << std::endl;
             throw pandora::StatusCodeException(pandora::STATUS_CODE_NOT_FOUND);
         }
         featureVector.push_back(featureContainer.at(pFeatureToolName));
     }
 
     return Classify(classifier, featureVector);
 }

template<typename TLIST , typename... TLISTS>

LArMvaHelper::MvaFeatureVector lar_content::LArMvaHelper::ConcatenateFeatureLists	(	TLIST &&	featureList,
		TLISTS &&...	featureLists
	)

static

Recursively concatenate vectors of features.

Parameters

featureList	a list of features
featureLists	optional further lists of features

Returns: the concatenated vector of features

Definition at line 520 of file LArMvaHelper.h.

 {
     static_assert(std::is_same<typename std::decay<TLIST>::type, LArMvaHelper::MvaFeatureVector>::value,
         "LArMvaHelper: Could not concatenate feature lists because one or more lists was not a vector of MvaFeatures");
 
     LArMvaHelper::MvaFeatureVector featureVector;
 
     for (const MvaFeature &feature : featureList)
         featureVector.push_back(feature);
 
     LArMvaHelper::MvaFeatureVector newFeatureVector = ConcatenateFeatureLists(std::forward<TLISTS>(featureLists)...);
     featureVector.insert(featureVector.end(), newFeatureVector.begin(), newFeatureVector.end());
 
     return featureVector;
 }

LArMvaHelper::MvaFeatureVector lar_content::LArMvaHelper::ConcatenateFeatureLists ( )

inlinestatic

Recursively concatenate vectors of features (terminating method)

Definition at line 538 of file LArMvaHelper.h.

 {
     return LArMvaHelper::MvaFeatureVector();
 }

std::string lar_content::LArMvaHelper::GetTimestampString ( )

inlinestaticprivate

Get a timestamp string for this point in time.

Returns: a timestamp string

Definition at line 476 of file LArMvaHelper.h.

 {
     std::time_t timestampNow = std::chrono::system_clock::to_time_t(std::chrono::system_clock::now());
 
     struct tm *pTimeInfo(NULL);
     char buffer[80];
 
     pTimeInfo = localtime(&timestampNow);
     strftime(buffer, 80, "%x_%X", pTimeInfo);
 
     std::string timeString(buffer);
 
     if (!timeString.empty() && timeString.back() == '\n') // last char is always a newline
         timeString.pop_back();
 
     return timeString;
 }

StatusCode lar_content::LArMvaHelper::ProcessAlgorithmToolListToMap	(	const pandora::Algorithm &	algorithm,
		const pandora::TiXmlHandle &	xmlHandle,
		const std::string &	listName,
		pandora::StringVector &	algorithToolNameVector,
		AlgorithmToolMap &	algorithmToolMap
	)

static

Process a list of algorithms tools in an xml file, using a map. Idea is for this to go to XmlHelper in PandoraSDK eventually as an overload to ProcessAlgorithmToolList.

Parameters

algorithm	the parent algorithm calling this function
xmlHandle	the relevant xml handle
listName	the name of the algorithm tool list
algorithmToolMap	to receive the vector of addresses of the algorithm tool instances, but also keep the name

Definition at line 16 of file LArMvaHelper.cc.

 {
     // Fill a vector with names in the desired run order as well as the map
 
     if ("algorithm" != xmlHandle.ToNode()->ValueStr())
         return STATUS_CODE_NOT_ALLOWED;
 
     const TiXmlHandle algorithmListHandle = TiXmlHandle(xmlHandle.FirstChild(listName).Element());
 
     for (TiXmlElement *pXmlElement = algorithmListHandle.FirstChild("tool").Element(); nullptr != pXmlElement;
          pXmlElement = pXmlElement->NextSiblingElement("tool"))
     {
         AlgorithmTool *pAlgorithmTool(nullptr);
         PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::CreateAlgorithmTool(algorithm, pXmlElement, pAlgorithmTool));
         std::string toolName = pXmlElement->Attribute("type");
         // If already exists, then make the second have the instance name attached
         if (algorithmToolMap.find(toolName) != algorithmToolMap.end())
             toolName += "_" + pAlgorithmTool->GetInstanceName();
         algorithmToolMap[toolName] = pAlgorithmTool;
         algorithmToolNameVector.push_back(toolName);
     }
 
     return STATUS_CODE_SUCCESS;
 }

template<typename TCONTAINER >

pandora::StatusCode lar_content::LArMvaHelper::ProduceTrainingExample	(	const std::string &	trainingOutputFile,
		const bool	result,
		TCONTAINER &&	featureContainer
	)

static

Produce a training example with the given features and result.

Parameters

trainingOutputFile	the file to which to append the example
featureContainer	the container of features

Returns: success

Definition at line 282 of file LArMvaHelper.h.

 {
     std::ofstream outfile;
     outfile.open(trainingOutputFile, std::ios_base::app); // always append to the output file
 
     if (!outfile.is_open())
     {
         std::cout << "LArMvaHelper: could not open file for training examples at " << trainingOutputFile << std::endl;
         return pandora::STATUS_CODE_FAILURE;
     }
 
     std::string delimiter(",");
     outfile << GetTimestampString() << delimiter;
 
     PANDORA_RETURN_RESULT_IF(pandora::STATUS_CODE_SUCCESS, !=, WriteFeaturesToFile(outfile, delimiter, featureContainer));
     outfile << static_cast<int>(result) << '\n';
 
     return pandora::STATUS_CODE_SUCCESS;
 }

template<typename TCONTAINER >

pandora::StatusCode lar_content::LArMvaHelper::ProduceTrainingExample	(	const std::string &	trainingOutputFile,
		const bool	result,
		const pandora::StringVector &	featureOrder,
		TCONTAINER &&	featureContainer
	)

static

Produce a training example with the given features and result - using a map.

Parameters

trainingOutputFile	the file to which to append the example
featureOrder	the vector of strings corresponding to ordered list of keys
featureContainer	the container of features

Returns: success

Definition at line 305 of file LArMvaHelper.h.

 {
     // Make a feature vector from the map and calculate the features
     LArMvaHelper::MvaFeatureVector featureVector;
 
     for (auto const &pFeatureToolName : featureOrder)
     {
         if (featureContainer.find(pFeatureToolName) == featureContainer.end())
         {
             std::cout << "LArMvaHelper::ProduceTrainingExample "
                       << "- Error: feature tool " << pFeatureToolName << " not found." << std::endl;
             throw pandora::StatusCodeException(pandora::STATUS_CODE_NOT_FOUND);
         }
         featureVector.push_back(featureContainer.at(pFeatureToolName));
     }
 
     return ProduceTrainingExample(trainingOutputFile, result, featureVector);
 }

template<typename TCONTAINER >

pandora::StatusCode lar_content::LArMvaHelper::WriteFeaturesToFile	(	std::ofstream &	outfile,
		const std::string &	delimiter,
		TCONTAINER &&	featureContainer
	)

inlinestaticprivate

Write the features of the given lists to file.

Parameters

outfile	the std::ofstream object to use
delimiter	the delimiter string
featureContainer	a container of features to write

Returns: success

Definition at line 497 of file LArMvaHelper.h.

 {
     static_assert(std::is_same<typename std::decay<TCONTAINER>::type, LArMvaHelper::MvaFeatureVector>::value,
         "LArMvaHelper: Could not write training set example because a passed parameter was not a vector of MvaFeatures");
 
     PANDORA_RETURN_RESULT_IF(pandora::STATUS_CODE_SUCCESS, !=, WriteFeaturesToFileImpl(outfile, delimiter, featureContainer));
     return pandora::STATUS_CODE_SUCCESS;
 }

template<typename TCONTAINER >

pandora::StatusCode lar_content::LArMvaHelper::WriteFeaturesToFileImpl	(	std::ofstream &	outfile,
		const std::string &	delimiter,
		TCONTAINER &&	featureContainer
	)

staticprivate

Write the features of the given list to file (implementation method)

Parameters

outfile	the std::ofstream object to use
delimiter	the delimiter string
featureContainer	a container of features to write

Returns: success

Definition at line 509 of file LArMvaHelper.h.

 {
     for (const MvaFeature &feature : featureContainer)
         outfile << feature.Get() << delimiter;
 
     return pandora::STATUS_CODE_SUCCESS;
 }

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

Public Types

Static Public Member Functions

Static Private Member Functions

Detailed Description

Member Typedef Documentation

Member Function Documentation