PunchThroughG4Classifier Class Reference

#include <PunchThroughG4Classifier.h>

Inheritance diagram for PunchThroughG4Classifier:

Collaboration diagram for PunchThroughG4Classifier:

Public Member Functions
	PunchThroughG4Classifier (const std::string &, const std::string &, const IInterface *)
	Constructor.
virtual	~PunchThroughG4Classifier ()=default
	Destructor.
virtual StatusCode	initialize () override
	AlgTool initialize method.
virtual StatusCode	finalize () override
	AlgTool finalize method.
StatusCode	initializeScaler (const std::string &scalerConfigFile)
	input variable MinMaxScaler initialize method
StatusCode	initializeNetwork (const std::string &networkConfigFile)
	neural network initialize method
StatusCode	initializeCalibrator (const std::string &calibratorConfigFile)
	isotonic regressor calibrator initialize method
virtual double	computePunchThroughProbability (const G4FastTrack &fastTrack, const double simE, const std::vector< double > &simEfrac) const override
	interface method to return probability prediction of punch through
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
double	calibrateOutput (double &networkOutput) const
	calibrate NN output using isotonic regressor

Static Public Member Functions
static std::map< std::string, std::map< std::string, double > >	computeInputs (const G4FastTrack &fastTrack, const double simE, const std::vector< double > &simEfrac)
	calcalate NN inputs based on G4FastTrack and simulstate

Private Attributes
std::unique_ptr< lwt::LightweightGraph >	m_graph {}
	NN graph.
double	m_scalerMin {}
	input variable MinMaxScaler members
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
double	m_calibrationMin {}
double	m_calibrationMax {}
std::map< double, double >	m_calibrationMap
StringProperty	m_scalerConfigFileName {this, "ScalerConfigFileName", "", ""}
StringProperty	m_networkConfigFileName {this, "NetworkConfigFileName", "", ""}
StringProperty	m_calibratorConfigFileName {this, "CalibratorConfigFileName", "", ""}

Detailed Description

Definition at line 22 of file PunchThroughG4Classifier.h.

Constructor & Destructor Documentation

PunchThroughG4Classifier()

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

Constructor.

Definition at line 30 of file PunchThroughG4Classifier.cxx.

    : base_class(type, name, parent) {
}

~PunchThroughG4Classifier()

virtual PunchThroughG4Classifier::~PunchThroughG4Classifier ( )

virtualdefault

Destructor.

Member Function Documentation

calibrateOutput()

double PunchThroughG4Classifier::calibrateOutput

(

double &

networkOutput

)

const

calibrate NN output using isotonic regressor

Definition at line 234 of file PunchThroughG4Classifier.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 > > PunchThroughG4Classifier::computeInputs ( const G4FastTrack & fastTrack, const double simE, const std::vector< double > & simEfrac )

static

calcalate NN inputs based on G4FastTrack and simulstate

Definition at line 193 of file PunchThroughG4Classifier.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", fastTrack.GetPrimaryTrack()->GetMomentum().mag() },
        {"variable_1", std::abs(fastTrack.GetPrimaryTrack()->GetPosition().eta()) },
        {"variable_2", fastTrack.GetPrimaryTrack()->GetPosition().phi() },
        {"variable_3", simE},
    };
 
    //add energy fraction variables
    for (unsigned int i = 0; i < simEfrac.size(); i++) { //from 0 to 23, 24 layers
        networkInputs["node_0"].insert({"variable_" + std::to_string(i + 4), simEfrac[i]});
    }
 
    return networkInputs;
}

computePunchThroughProbability()

double PunchThroughG4Classifier::computePunchThroughProbability ( const G4FastTrack & fastTrack, const double simE, const std::vector< double > & simEfrac ) const

overridevirtual

interface method to return probability prediction of punch through

Definition at line 180 of file PunchThroughG4Classifier.cxx.

                                                                                                                                                         {
 
    std::map<std::string, std::map<std::string, double> > networkInputs = computeInputs(fastTrack, simE, simEfrac); //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;
}

finalize()

StatusCode PunchThroughG4Classifier::finalize ( )

overridevirtual

AlgTool finalize method.

Definition at line 50 of file PunchThroughG4Classifier.cxx.

                                             {
 
    ATH_MSG_DEBUG( "[punchthroughclassifier] finalize() successful" );
 
    return StatusCode::SUCCESS;
}

initialize()

StatusCode PunchThroughG4Classifier::initialize ( )

overridevirtual

AlgTool initialize method.

Definition at line 34 of file PunchThroughG4Classifier.cxx.

                                               {
 
    ATH_MSG_DEBUG( "[ punchthroughclassifier ] Initializing PunchThroughG4Classifier" );
 
    std::string resolvedScalerFileName = PathResolverFindCalibFile (m_scalerConfigFileName);
    ATH_CHECK ( initializeScaler(resolvedScalerFileName) );
 
    std::string resolvedNetworkFileName = PathResolverFindCalibFile (m_networkConfigFileName);
    ATH_CHECK ( initializeNetwork(resolvedNetworkFileName) );
 
    std::string resolvedCalibratorFileName = PathResolverFindCalibFile (m_calibratorConfigFileName);
    ATH_CHECK ( initializeCalibrator(resolvedCalibratorFileName) );
 
    return StatusCode::SUCCESS;
}

initializeCalibrator()

StatusCode PunchThroughG4Classifier::initializeCalibrator

(

const std::string &

calibratorConfigFile

)

isotonic regressor calibrator initialize method

Definition at line 131 of file PunchThroughG4Classifier.cxx.

                                                                                               {
    // Initialize pointers
    xmlDocPtr doc;
    xmlChar* xmlBuff = nullptr; 
 
    //parse xml that contains config for isotonic regressor used to calibrate the network output
    ATH_MSG_DEBUG( "[ punchthroughclassifier ] Loading calibrator: " << calibratorConfigFile);
 
    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" )) {
                    if ((xmlBuff = xmlGetProp(nodeTransform, BAD_CAST "min")) != nullptr) {
                        m_calibrationMin = atof(reinterpret_cast<const char*>(xmlBuff));
                    }
                    if ((xmlBuff = xmlGetProp(nodeTransform, BAD_CAST "max")) != nullptr) {
                        m_calibrationMax = atof(reinterpret_cast<const char*>(xmlBuff));
                    }
                }
 
                //get defined points where isotonic regressor knows transform
                if (xmlStrEqual( nodeTransform->name, BAD_CAST "LinearNorm" )) {
                    double orig = -1;
                    double norm = -1;
                    if ((xmlBuff = xmlGetProp(nodeTransform, BAD_CAST "orig")) != nullptr) {
                        orig = atof(reinterpret_cast<const char*>(xmlBuff));
                    }
                    if ((xmlBuff = xmlGetProp(nodeTransform, BAD_CAST "norm")) != nullptr) {
                        norm = atof(reinterpret_cast<const char*>(xmlBuff));
                    }
 
                    // Insert into maps
                    m_calibrationMap.insert ( std::pair<double,double>(orig, norm) );
                }
            }
        }
    }
 
    // free memory when done 
    xmlFreeDoc(doc);
 
    return StatusCode::SUCCESS;
}

initializeNetwork()

StatusCode PunchThroughG4Classifier::initializeNetwork

(

const std::string &

networkConfigFile

)

neural network initialize method

Definition at line 111 of file PunchThroughG4Classifier.cxx.

                                                                                         {
 
    ATH_MSG_DEBUG( "[ 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 PunchThroughG4Classifier::initializeScaler

(

const std::string &

scalerConfigFile

)

input variable MinMaxScaler initialize method

Definition at line 57 of file PunchThroughG4Classifier.cxx.

                                                                                       {
    // Initialize pointers
    xmlDocPtr doc;
    xmlChar* xmlBuff = nullptr; 
 
    // Parse xml that contains config for MinMaxScaler for each of the network inputs
    doc = xmlParseFile( scalerConfigFile.c_str() );
 
    ATH_MSG_DEBUG( "[ 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" )) {
                    if ((xmlBuff = xmlGetProp(nodeTransform, BAD_CAST "min")) != nullptr) {
                        m_scalerMin = atof(reinterpret_cast<const char*>(xmlBuff));
                    }
                    if ((xmlBuff = xmlGetProp(nodeTransform, BAD_CAST "max")) != nullptr) {
                        m_scalerMax = atof(reinterpret_cast<const char*>(xmlBuff));
                    }
                }
 
                //Get values necessary to normalise each input variable
                if (xmlStrEqual( nodeTransform->name, BAD_CAST "VarScales" )) {
                    std::string name = "";
                    double min=-1, max=-1;
 
                    if ((xmlBuff = xmlGetProp(nodeTransform, BAD_CAST "name")) != nullptr) {
                        name = reinterpret_cast<const char*>(xmlBuff);
                    }
                    if ((xmlBuff = xmlGetProp(nodeTransform, BAD_CAST "min")) != nullptr) {
                        min = atof(reinterpret_cast<const char*>(xmlBuff));
                    }
                    if ((xmlBuff = xmlGetProp(nodeTransform, BAD_CAST "max")) != nullptr) {
                        max = atof(reinterpret_cast<const char*>(xmlBuff));
                    }
 
                    // Insert into maps
                    m_scalerMinMap.insert ( std::pair<std::string, double>(name, min) );
                    m_scalerMaxMap.insert ( std::pair<std::string, double>(name, max) );
                }
            }
        }
    }
 
    // free memory when done 
    xmlFreeDoc(doc);
 
    return StatusCode::SUCCESS;
}

scaleInputs()

std::map< std::string, std::map< std::string, double > > PunchThroughG4Classifier::scaleInputs

(

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

inputs

)

const

scale NN inputs using MinMaxScaler

Definition at line 215 of file PunchThroughG4Classifier.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> PunchThroughG4Classifier::m_calibrationMap

private

Definition at line 71 of file PunchThroughG4Classifier.h.

m_calibrationMax

double PunchThroughG4Classifier::m_calibrationMax {}

private

Definition at line 70 of file PunchThroughG4Classifier.h.

{};

m_calibrationMin

double PunchThroughG4Classifier::m_calibrationMin {}

private

Definition at line 69 of file PunchThroughG4Classifier.h.

{};

m_calibratorConfigFile

std::string PunchThroughG4Classifier::m_calibratorConfigFile

private

isotonic regressor calibrator members

Definition at line 68 of file PunchThroughG4Classifier.h.

m_calibratorConfigFileName

StringProperty PunchThroughG4Classifier::m_calibratorConfigFileName {this, "CalibratorConfigFileName", "", ""}

private

Definition at line 78 of file PunchThroughG4Classifier.h.

{this, "CalibratorConfigFileName", "", ""};

m_graph

std::unique_ptr<lwt::LightweightGraph> PunchThroughG4Classifier::m_graph {}

private

NN graph.

Definition at line 59 of file PunchThroughG4Classifier.h.

{};

m_networkConfigFileName

StringProperty PunchThroughG4Classifier::m_networkConfigFileName {this, "NetworkConfigFileName", "", ""}

private

Definition at line 77 of file PunchThroughG4Classifier.h.

{this,    "NetworkConfigFileName",    "", ""};

m_scalerConfigFileName

StringProperty PunchThroughG4Classifier::m_scalerConfigFileName {this, "ScalerConfigFileName", "", ""}

private

Definition at line 76 of file PunchThroughG4Classifier.h.

{this,     "ScalerConfigFileName",     "", ""};

m_scalerMax

double PunchThroughG4Classifier::m_scalerMax {}

private

Definition at line 63 of file PunchThroughG4Classifier.h.

{};

m_scalerMaxMap

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

private

Definition at line 65 of file PunchThroughG4Classifier.h.

m_scalerMin

double PunchThroughG4Classifier::m_scalerMin {}

private

input variable MinMaxScaler members

Definition at line 62 of file PunchThroughG4Classifier.h.

{};

m_scalerMinMap

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

private

Definition at line 64 of file PunchThroughG4Classifier.h.

---

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

• PunchThroughG4Classifier.h
• PunchThroughG4Classifier.cxx