#include <PunchThroughClassifier.h>

Inheritance diagram for ISF::PunchThroughClassifier:

Collaboration diagram for ISF::PunchThroughClassifier:

Public Member Functions
	PunchThroughClassifier (const std::string &, const std::string &, const IInterface *)
	Constructor. More...

virtual	~PunchThroughClassifier ()=default
	Destructor. More...

virtual StatusCode	initialize () override final
	AlgTool initialize method. More...

StatusCode	initializeScaler (const std::string &scalerConfigFile)
	input variable MinMaxScaler initialize method More...

StatusCode	initializeNetwork (const std::string &networkConfigFile)
	neural network initialize method More...

StatusCode	initializeCalibrator (const std::string &calibratorConfigFile)
	isotonic regressor calibrator initialize method More...

virtual double	computePunchThroughProbability (const ISF::ISFParticle &isfp, const TFCSSimulationState &simulstate) const override
	interface method to return probability prediction of punch through More...

std::map< std::string, std::map< std::string, double > >	scaleInputs (std::map< std::string, std::map< std::string, double > > &inputs) const
	scale NN inputs using MinMaxScaler More...

double	calibrateOutput (double &networkOutput) const
	calibrate NN output using isotonic regressor More...

Static Public Member Functions
static std::map< std::string, std::map< std::string, double > >	computeInputs (const ISF::ISFParticle &isfp, const TFCSSimulationState &simulstate)
	calcalate NN inputs based on isfp and simulstate More...

Private Attributes
std::unique_ptr< lwt::LightweightGraph >	m_graph {}
	NN graph. More...

double	m_scalerMin {}
	input variable MinMaxScaler members More...

double	m_scalerMax {}

std::map< std::string, double >	m_scalerMinMap

std::map< std::string, double >	m_scalerMaxMap

std::string	m_calibratorConfigFile
	isotonic regressor calibrator members More...

double	m_calibrationMin {}

double	m_calibrationMax {}

std::map< double, double >	m_calibrationMap

std::string	m_networkConfigFileName

std::string	m_scalerConfigFileName

std::string	m_calibratorConfigFileName

Detailed Description

Definition at line 26 of file PunchThroughClassifier.h.

Constructor & Destructor Documentation

◆ PunchThroughClassifier()

ISF::PunchThroughClassifier::PunchThroughClassifier	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	parent
	)

Constructor.

Definition at line 24 of file PunchThroughClassifier.cxx.

     : base_class(type, name, parent) {
  
     declareProperty( "ScalerConfigFileName",          m_scalerConfigFileName   );
     declareProperty( "NetworkConfigFileName",          m_networkConfigFileName   );
     declareProperty( "CalibratorConfigFileName",          m_calibratorConfigFileName   );
 }

◆ ~PunchThroughClassifier()

virtual ISF::PunchThroughClassifier::~PunchThroughClassifier ( )

virtualdefault

Destructor.

Member Function Documentation

◆ calibrateOutput()

double ISF::PunchThroughClassifier::calibrateOutput ( double & networkOutput ) const

calibrate NN output using isotonic regressor

Definition at line 198 of file PunchThroughClassifier.cxx.

                                                                              {
  
     //calibrate output of network using isotonic regressor model
  
     //if network output is outside of the range of isotonic regressor then return min and max values
     if (networkOutput < m_calibrationMin){
         return m_calibrationMin;
     }
     else if (networkOutput > m_calibrationMax){
         return m_calibrationMax;
     }
  
     //otherwise find neighbouring points in isotonic regressor
     auto upper = m_calibrationMap.upper_bound(networkOutput);
     auto lower = upper--;
  
     //Perform linear interpolation between points
     double m = (upper->second - lower->second)/(upper->first - lower->first);
     double c = lower->second - m * lower->first;
     double calibrated = m * networkOutput + c;
  
     return calibrated;
 }

◆ computeInputs()

std::map< std::string, std::map< std::string, double > > ISF::PunchThroughClassifier::computeInputs	(	const ISF::ISFParticle &	isfp,
		const TFCSSimulationState &	simulstate
	)

static

calcalate NN inputs based on isfp and simulstate

Definition at line 157 of file PunchThroughClassifier.cxx.

                                                                                                                                                         {
  
     //calculate inputs for NN
  
     std::map<std::string, std::map<std::string, double> > networkInputs;
  
     //add initial particle and total energy variables
     networkInputs["node_0"] = {
         {"variable_0", isfp.momentum().mag() },
         {"variable_1", std::abs(isfp.position().eta()) },
         {"variable_2", isfp.position().phi() },
         {"variable_3", simulstate.E()},
     };
  
     //add energy fraction variables
     for (unsigned int i = 0; i < 24; i++){
         networkInputs["node_0"].insert({"variable_" + std::to_string(i + 4), simulstate.Efrac(i)});
     }
  
     return networkInputs;
 }

◆ computePunchThroughProbability()

double ISF::PunchThroughClassifier::computePunchThroughProbability	(	const ISF::ISFParticle &	isfp,
		const TFCSSimulationState &	simulstate
	)		const

overridevirtual

interface method to return probability prediction of punch through

Definition at line 32 of file PunchThroughClassifier.cxx.

                                                                                                                                         {
  
     std::map<std::string, std::map<std::string, double> > networkInputs = computeInputs(isfp, simulstate); //compute inputs
  
     networkInputs = scaleInputs(networkInputs); //scale inputs
  
     std::map<std::string, double> networkOutputs = m_graph->compute(networkInputs); //call neural network on inputs
  
     double calibratedOutput = calibrateOutput(networkOutputs["out_0"]); //calibrate neural network output
  
     return calibratedOutput;
 }

◆ initialize()

StatusCode ISF::PunchThroughClassifier::initialize ( )

finaloverridevirtual

AlgTool initialize method.

Definition at line 46 of file PunchThroughClassifier.cxx.

                                                 {
  
     ATH_MSG_VERBOSE( "[ punchthroughclassifier ] initialize()" );
  
     std::string resolvedScalerFileName = PathResolverFindCalibFile (m_scalerConfigFileName);
     if ( initializeScaler(resolvedScalerFileName) != StatusCode::SUCCESS)
     {
         ATH_MSG_ERROR("[ punchthroughclassifier ] unable to load punchthroughclassifier input scaler");
     }
  
     std::string resolvedNetworkFileName = PathResolverFindCalibFile (m_networkConfigFileName);
     if ( initializeNetwork(resolvedNetworkFileName) != StatusCode::SUCCESS)
     {
         ATH_MSG_ERROR("[ punchthroughclassifier ] unable to load punchthroughclassifier network");
     }
  
     std::string resolvedCalibratorFileName = PathResolverFindCalibFile (m_calibratorConfigFileName);
     if ( initializeCalibrator(resolvedCalibratorFileName) != StatusCode::SUCCESS)
     {
         ATH_MSG_ERROR("[ punchthroughclassifier ] unable to load punchthroughclassifier calibrator");
     }
  
     return StatusCode::SUCCESS;
 }

◆ initializeCalibrator()

StatusCode ISF::PunchThroughClassifier::initializeCalibrator ( const std::string & calibratorConfigFile )

isotonic regressor calibrator initialize method

Definition at line 126 of file PunchThroughClassifier.cxx.

                                                                                                 {
  
     //parse xml that contains config for isotonic regressor used to calibrate the network output
     ATH_MSG_INFO( "[ punchthroughclassifier ] Loading calibrator: " << calibratorConfigFile);
  
     xmlDocPtr doc = xmlParseFile( calibratorConfigFile.c_str() );
  
     for( xmlNodePtr nodeRoot = doc->children; nodeRoot != nullptr; nodeRoot = nodeRoot->next) {
  
         if (xmlStrEqual( nodeRoot->name, BAD_CAST "Transformations" )) {
             for( xmlNodePtr nodeTransform = nodeRoot->children; nodeTransform != nullptr; nodeTransform = nodeTransform->next ) {
  
                 //get lower and upper bounds of isotonic regressor
                 if (xmlStrEqual( nodeTransform->name, BAD_CAST "LimitValues" )) {
                     m_calibrationMin = atof( (const char*) xmlGetProp( nodeTransform, BAD_CAST "min" ) );
                     m_calibrationMax = atof( (const char*) xmlGetProp( nodeTransform, BAD_CAST "max" ) );
                 }
  
                 //get defined points where isotonic regressor knows transform
                 if (xmlStrEqual( nodeTransform->name, BAD_CAST "LinearNorm" )) {
                     double orig = atof( (const char*) xmlGetProp( nodeTransform, BAD_CAST "orig" ) );
                     double norm = atof( (const char*) xmlGetProp( nodeTransform, BAD_CAST "norm" ) );
                     m_calibrationMap.insert ( std::pair<double,double>(orig, norm) );
                 }
             }
         }
     }
  
     return StatusCode::SUCCESS;
 }

◆ initializeNetwork()

StatusCode ISF::PunchThroughClassifier::initializeNetwork ( const std::string & networkConfigFile )

neural network initialize method

Definition at line 105 of file PunchThroughClassifier.cxx.

                                                                                           {
  
     ATH_MSG_INFO( "[ punchthroughclassifier ] Loading classifier: " << networkConfigFile);
  
     std::ifstream input(networkConfigFile);
     if(!input){
         ATH_MSG_ERROR("Could not find json file " << networkConfigFile );
         return StatusCode::FAILURE;
     }
  
     m_graph  = std::make_unique<lwt::LightweightGraph>(lwt::parse_json_graph(input));
     if(!m_graph){
         ATH_MSG_ERROR("Could not parse graph json file " << networkConfigFile );
         return StatusCode::FAILURE;
     }
  
  
     return StatusCode::SUCCESS;
 }

◆ initializeScaler()

StatusCode ISF::PunchThroughClassifier::initializeScaler ( const std::string & scalerConfigFile )

input variable MinMaxScaler initialize method

Definition at line 71 of file PunchThroughClassifier.cxx.

                                                                                         {
  
     //parse xml that contains config for MinMaxScaler for each of the network inputs
  
     xmlDocPtr doc = xmlParseFile( scalerConfigFile.c_str() );
  
     ATH_MSG_INFO( "[ punchthroughclassifier ] Loading scaler: " << scalerConfigFile);
  
     for( xmlNodePtr nodeRoot = doc->children; nodeRoot != nullptr; nodeRoot = nodeRoot->next) {
  
         if (xmlStrEqual( nodeRoot->name, BAD_CAST "Transformations" )) {
             for( xmlNodePtr nodeTransform = nodeRoot->children; nodeTransform != nullptr; nodeTransform = nodeTransform->next ) {
  
                 //Get min and max values that we normalise values to
                 if (xmlStrEqual( nodeTransform->name, BAD_CAST "ScalerValues" )) {
                     m_scalerMin = atof( (const char*) xmlGetProp( nodeTransform, BAD_CAST "min" ) );
                     m_scalerMax = atof( (const char*) xmlGetProp( nodeTransform, BAD_CAST "max" ) );
                 }
  
                 //Get values necessary to normalise each input variable
                 if (xmlStrEqual( nodeTransform->name, BAD_CAST "VarScales" )) {
                     std::string name = (const char*) xmlGetProp( nodeTransform, BAD_CAST "name" );
                     double min = atof( (const char*) xmlGetProp( nodeTransform, BAD_CAST "min" ) );
                     double max = atof( (const char*) xmlGetProp( nodeTransform, BAD_CAST "max" ) );
                     m_scalerMinMap.insert ( std::pair<std::string, double>(name, min) );
                     m_scalerMaxMap.insert ( std::pair<std::string, double>(name, max) );
                 }
             }
         }
     }
  
     return StatusCode::SUCCESS;
 }

◆ scaleInputs()

std::map< std::string, std::map< std::string, double > > ISF::PunchThroughClassifier::scaleInputs ( std::map< std::string, std::map< std::string, double > > & inputs ) const

scale NN inputs using MinMaxScaler

Definition at line 179 of file PunchThroughClassifier.cxx.

                                                                                                                                                {
  
     //apply MinMaxScaler to network inputs
  
     for (auto& var : inputs["node_0"]) {
  
         double x_std;
         if(m_scalerMaxMap.at(var.first) != m_scalerMinMap.at(var.first)){
             x_std = (var.second - m_scalerMinMap.at(var.first)) / (m_scalerMaxMap.at(var.first) - m_scalerMinMap.at(var.first));
         }
         else{
             x_std = (var.second - m_scalerMinMap.at(var.first));
         }
         var.second = x_std * (m_scalerMax - m_scalerMin) + m_scalerMin;
     }
  
     return inputs;
 }

Member Data Documentation

◆ m_calibrationMap

std::map<double, double> ISF::PunchThroughClassifier::m_calibrationMap

private

Definition at line 73 of file PunchThroughClassifier.h.

◆ m_calibrationMax

double ISF::PunchThroughClassifier::m_calibrationMax {}

private

Definition at line 72 of file PunchThroughClassifier.h.

◆ m_calibrationMin

double ISF::PunchThroughClassifier::m_calibrationMin {}

private

Definition at line 71 of file PunchThroughClassifier.h.

◆ m_calibratorConfigFile

std::string ISF::PunchThroughClassifier::m_calibratorConfigFile

private

isotonic regressor calibrator members

Definition at line 70 of file PunchThroughClassifier.h.

◆ m_calibratorConfigFileName

std::string ISF::PunchThroughClassifier::m_calibratorConfigFileName

private

Definition at line 78 of file PunchThroughClassifier.h.

◆ m_graph

std::unique_ptr<lwt::LightweightGraph> ISF::PunchThroughClassifier::m_graph {}

private

NN graph.

Definition at line 61 of file PunchThroughClassifier.h.

◆ m_networkConfigFileName

std::string ISF::PunchThroughClassifier::m_networkConfigFileName

private

Definition at line 76 of file PunchThroughClassifier.h.

◆ m_scalerConfigFileName

std::string ISF::PunchThroughClassifier::m_scalerConfigFileName

private

Definition at line 77 of file PunchThroughClassifier.h.

◆ m_scalerMax

double ISF::PunchThroughClassifier::m_scalerMax {}

private

Definition at line 65 of file PunchThroughClassifier.h.

◆ m_scalerMaxMap

std::map<std::string, double> ISF::PunchThroughClassifier::m_scalerMaxMap

private

Definition at line 67 of file PunchThroughClassifier.h.

◆ m_scalerMin

double ISF::PunchThroughClassifier::m_scalerMin {}

private

input variable MinMaxScaler members

Definition at line 64 of file PunchThroughClassifier.h.

◆ m_scalerMinMap

std::map<std::string, double> ISF::PunchThroughClassifier::m_scalerMinMap

private

Definition at line 66 of file PunchThroughClassifier.h.

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

Public Member Functions

Static Public Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ PunchThroughClassifier()

◆ ~PunchThroughClassifier()

Member Function Documentation

◆ calibrateOutput()

◆ computeInputs()

◆ computePunchThroughProbability()

◆ initialize()

◆ initializeCalibrator()

◆ initializeNetwork()

◆ initializeScaler()

◆ scaleInputs()

Member Data Documentation

◆ m_calibrationMap

◆ m_calibrationMax

◆ m_calibrationMin

◆ m_calibratorConfigFile

◆ m_calibratorConfigFileName

◆ m_graph

◆ m_networkConfigFileName

◆ m_scalerConfigFileName

◆ m_scalerMax

◆ m_scalerMaxMap

◆ m_scalerMin

◆ m_scalerMinMap