TFCSGANEtaSlice Class Reference

#include <TFCSGANEtaSlice.h>

Inheritance diagram for TFCSGANEtaSlice:

Collaboration diagram for TFCSGANEtaSlice:

Public Types
typedef std::map< int, std::vector< double > >	FitResultsPerLayer
typedef std::map< int, double >	ExtrapolatorWeights
typedef std::map< std::string, std::map< std::string, double > >	NetworkInputs
typedef std::map< std::string, double >	NetworkOutputs

Public Member Functions
	TFCSGANEtaSlice ()
	TFCSGANEtaSlice (int pid, int etaMin, int etaMax, const TFCSGANXMLParameters &param)
virtual	~TFCSGANEtaSlice ()
	TFCSGANEtaSlice (const TFCSGANEtaSlice &)=delete
TFCSGANEtaSlice &	operator= (const TFCSGANEtaSlice &)=delete
bool	LoadGAN ()
void	CalculateMeanPointFromDistributionOfR ()
void	ExtractExtrapolatorMeansFromInputs ()
NetworkOutputs	GetNetworkOutputs (const TFCSTruthState *truth, const TFCSExtrapolationState *extrapol, TFCSSimulationState &simulstate) const
bool	IsGanCorrectlyLoaded () const
const FitResultsPerLayer &	GetFitResults () const
const ExtrapolatorWeights &	GetExtrapolatorWeights ()
void	Print () const
bool	msgLvl (const MSG::Level lvl) const
	Check whether the logging system is active at the provided verbosity level.
MsgStream &	msg () const
	Return a stream for sending messages directly (no decoration)
MsgStream &	msg (const MSG::Level lvl) const
	Return a decorated starting stream for sending messages.
MSG::Level	level () const
	Retrieve output level.
virtual void	setLevel (MSG::Level lvl)
	Update outputlevel.

Static Public Member Functions
static std::string	startMsg (MSG::Level lvl, const std::string &file, int line)
	Make a message to decorate the start of logging.

Private Member Functions
VNetworkBase *	GetNetAll () const
VNetworkBase *	GetNetLow () const
VNetworkBase *	GetNetHigh () const
bool	LoadGANNoRange (std::string inputFileName)
bool	LoadGANFromRange (std::string inputFileName, std::string energyRange)

Private Attributes
int	m_pid {}
int	m_etaMin {}
int	m_etaMax {}
std::string	m_inputFolderName
FitResultsPerLayer	m_allFitResults
ExtrapolatorWeights	m_extrapolatorWeights
TFCSGANLWTNNHandler *	m_gan_all = nullptr
TFCSGANLWTNNHandler *	m_gan_low = nullptr
TFCSGANLWTNNHandler *	m_gan_high = nullptr
std::unique_ptr< VNetworkBase >	m_net_all = nullptr
std::unique_ptr< VNetworkBase >	m_net_low = nullptr
std::unique_ptr< VNetworkBase >	m_net_high = nullptr
TFCSGANXMLParameters	m_param {}
std::string	m_nm
	Message source name.

Static Private Attributes
static boost::thread_specific_ptr< MsgStream > m_msg_tls	ATLAS_THREAD_SAFE
	Do not persistify!

Detailed Description

Definition at line 30 of file TFCSGANEtaSlice.h.

Member Typedef Documentation

ExtrapolatorWeights

typedef std::map<int, double> TFCSGANEtaSlice::ExtrapolatorWeights

Definition at line 41 of file TFCSGANEtaSlice.h.

FitResultsPerLayer

typedef std::map<int, std::vector<double> > TFCSGANEtaSlice::FitResultsPerLayer

Definition at line 40 of file TFCSGANEtaSlice.h.

NetworkInputs

typedef std::map<std::string, std::map<std::string, double> > TFCSGANEtaSlice::NetworkInputs

Definition at line 42 of file TFCSGANEtaSlice.h.

NetworkOutputs

typedef std::map<std::string, double> TFCSGANEtaSlice::NetworkOutputs

Definition at line 43 of file TFCSGANEtaSlice.h.

Constructor & Destructor Documentation

TFCSGANEtaSlice() [1/3]

TFCSGANEtaSlice::TFCSGANEtaSlice

(

)

Definition at line 27 of file TFCSGANEtaSlice.cxx.

{}

TFCSGANEtaSlice() [2/3]

TFCSGANEtaSlice::TFCSGANEtaSlice	(	int	pid,
		int	etaMin,
		int	etaMax,
		const TFCSGANXMLParameters &	param )

Definition at line 29 of file TFCSGANEtaSlice.cxx.

    : m_pid(pid), m_etaMin(etaMin), m_etaMax(etaMax), m_param(param) {}

~TFCSGANEtaSlice()

TFCSGANEtaSlice::~TFCSGANEtaSlice ( )

virtual

Definition at line 33 of file TFCSGANEtaSlice.cxx.

                                  {
  // Deleting a nullptr is a noop
  delete m_gan_all;
  delete m_gan_low;
  delete m_gan_high;
}

TFCSGANEtaSlice() [3/3]

TFCSGANEtaSlice::TFCSGANEtaSlice ( const TFCSGANEtaSlice & )

delete

Member Function Documentation

CalculateMeanPointFromDistributionOfR()

void TFCSGANEtaSlice::CalculateMeanPointFromDistributionOfR

(

)

Definition at line 121 of file TFCSGANEtaSlice.cxx.

                                                            {
  std::string rootFileName = std::format("{}/rootFiles/pid{}_E1048576_eta_{}_{}.root",
                                         m_param.GetInputFolder(),
                                         m_pid,
                                         m_etaMin,
                                         m_etaMin + 5);
  ATH_MSG_DEBUG("Opening file " << rootFileName);
  std::unique_ptr<TFile> file (TFile::Open(rootFileName.c_str(), "read"));
  if (!file || file->IsZombie()) {
      throw std::runtime_error(std::format("Failed to open or initialize ROOT file: {}", rootFileName));
  }
  for (int layer : m_param.GetRelevantLayers()) {
    ATH_MSG_DEBUG("Layer " << layer);
    TFCSGANXMLParameters::Binning binsInLayers = m_param.GetBinning();
    TH2D *h2 = &binsInLayers[layer];
 
    std::string histoName = std::format("r{}w", layer);
    TH1D *h1 = (TH1D *)file->Get(histoName.c_str());
    if (std::isnan(h1->Integral())) {
      histoName = std::format("r{}", layer);
      h1 = (TH1D *)file->Get(histoName.c_str());
    }
 
    TAxis *x = (TAxis *)h2->GetXaxis();
    for (int ix = 1; ix <= h2->GetNbinsX(); ++ix) {
      ATH_MSG_DEBUG(ix);
      h1->GetXaxis()->SetRangeUser(x->GetBinLowEdge(ix), x->GetBinUpEdge(ix));
 
      double result = 0;
      if (h1->Integral() > 0 && h1->GetNbinsX() > 2) {
        TFitResultPtr res(0);
 
        res = h1->Fit("expo", "SQ");
        if (res >= 0 && !std::isnan(res->Parameter(0))) {
          result = res->Parameter(1);
        }
      }
      m_allFitResults[layer].push_back(result);
    }
  }
  ATH_MSG_DEBUG("Done initialisaing fits");
}

ExtractExtrapolatorMeansFromInputs()

void TFCSGANEtaSlice::ExtractExtrapolatorMeansFromInputs

(

)

Definition at line 164 of file TFCSGANEtaSlice.cxx.

                                                         {
  std::string rootFileName = std::format("{}/rootFiles/pid{}_E65536_eta_{}_{}_validation.root",
                                         m_param.GetInputFolder(),
                                         m_pid,
                                         m_etaMin,
                                         m_etaMin + 5);
  ATH_MSG_DEBUG("Opening file " << rootFileName);
  std::unique_ptr<TFile> file (TFile::Open(rootFileName.c_str(), "read"));
  if (!file || file->IsZombie()) {
    throw std::runtime_error(std::format("Failed to open or initialize ROOT file: {}", rootFileName));
  }
  for (int layer : m_param.GetRelevantLayers()) {
    TH1D *h = new TH1D("h", "h", 100, 0.01, 1);
    TTree *tree = (TTree *)file->Get("rootTree");
    std::string command = std::format("extrapWeight_{}>>h", layer);
    tree->Draw(command.c_str());
    m_extrapolatorWeights[layer] = h->GetMean();
    ATH_MSG_DEBUG("Extrapolation: layer " << layer << " mean "
                                          << m_extrapolatorWeights[layer]);
  }
}

GetExtrapolatorWeights()

const ExtrapolatorWeights & TFCSGANEtaSlice::GetExtrapolatorWeights ( )

inline

Definition at line 55 of file TFCSGANEtaSlice.h.

{ return m_extrapolatorWeights; }

GetFitResults()

const FitResultsPerLayer & TFCSGANEtaSlice::GetFitResults ( ) const

inline

Definition at line 54 of file TFCSGANEtaSlice.h.

{ return m_allFitResults; }

GetNetAll()

VNetworkBase * TFCSGANEtaSlice::GetNetAll ( ) const

private

Definition at line 40 of file TFCSGANEtaSlice.cxx.

                                               {
  if (m_net_all != nullptr)
    return m_net_all.get();
  return m_gan_all;
}

GetNetHigh()

VNetworkBase * TFCSGANEtaSlice::GetNetHigh ( ) const

private

Definition at line 50 of file TFCSGANEtaSlice.cxx.

                                                {
  if (m_net_high != nullptr)
    return m_net_high.get();
  return m_gan_high;
}

GetNetLow()

VNetworkBase * TFCSGANEtaSlice::GetNetLow ( ) const

private

Definition at line 45 of file TFCSGANEtaSlice.cxx.

                                               {
  if (m_net_low != nullptr)
    return m_net_low.get();
  return m_gan_low;
}

GetNetworkOutputs()

VNetworkBase::NetworkOutputs TFCSGANEtaSlice::GetNetworkOutputs	(	const TFCSTruthState *	truth,
		const TFCSExtrapolationState *	extrapol,
		TFCSSimulationState &	simulstate ) const

Definition at line 187 of file TFCSGANEtaSlice.cxx.

                                                                          {
  double randUniformZ = 0.;
  NetworkInputs inputs;
 
  int maxExp = 0, minExp = 0;
  if (m_pid == 22 || std::abs(m_pid) == 11) {
    if (truth->P() >
        4096) { // This is the momentum, not the energy, because the split is
                // based on the samples which are produced with the momentum
      maxExp = 22;
      minExp = 12;
    } else {
      maxExp = 12;
      minExp = 6;
    }
  } else if (std::abs(m_pid) == 211) {
    maxExp = 22;
    minExp = 8;
  } else if (std::abs(m_pid) == 2212) {
    maxExp = 22;
    minExp = 10;
  }
 
  int p_min = std::pow(2, minExp);
  int p_max = std::pow(2, maxExp);
  // Keep min and max without mass offset as we do not train on antiparticles
  double Ekin_min =
      std::sqrt(std::pow(p_min, 2) + std::pow(truth->M(), 2)) - truth->M();
  double Ekin_max =
      std::sqrt(std::pow(p_max, 2) + std::pow(truth->M(), 2)) - truth->M();
  for (int i = 0; i < m_param.GetLatentSpaceSize(); i++) {
    randUniformZ = CLHEP::RandGauss::shoot(simulstate.randomEngine(), 0.5, 0.5);
    inputs["Noise"].insert(std::pair<std::string, double>(
        "variable_" + std::to_string(i), randUniformZ));
  }
 
  // double e = log(truth->Ekin()/Ekin_min)/log(Ekin_max/Ekin_min) ;
  // Could be uncommented , but would need the line above too
  // ATH_MSG_DEBUG( "Check label: " << e <<" Ekin:" << truth->Ekin() <<" p:" <<
  //                truth->P() <<" mass:" << truth->M() <<" Ekin_off:" <<
  //                truth->Ekin_off() << " Ekin_min:"<<Ekin_min<<"
  //                Ekin_max:"<<Ekin_max);
  // inputs["mycond"].insert ( std::pair<std::string,double>("variable_0",
  // truth->Ekin()/(std::pow(2,maxExp))) ); //Old conditioning using linear
  // interpolation, now use logaritminc interpolation
  inputs["mycond"].insert(std::pair<std::string, double>(
      "variable_0", log(truth->Ekin() / Ekin_min) / log(Ekin_max / Ekin_min)));
 
  if (m_param.GetGANVersion() >= 2) {
    if (false) { // conditioning on eta, should only be needed in transition
                 // regions and added only to the GANs that use it, for now all
                 // GANs have 3 conditioning inputs so filling zeros
      inputs["mycond"].insert(std::pair<std::string, double>(
          "variable_1", std::abs(extrapol->IDCaloBoundary_eta())));
    } else {
      inputs["mycond"].insert(std::pair<std::string, double>("variable_1", 0));
    }
  }
 
  VNetworkBase::NetworkOutputs outputs;
  if (m_param.GetGANVersion() == 1 || m_pid == 211 || m_pid == 2212) {
    outputs = GetNetAll()->compute(inputs);
  } else {
    if (truth->P() >
        4096) { // This is the momentum, not the energy, because the split is
                // based on the samples which are produced with the momentum
      ATH_MSG_DEBUG("Computing outputs given inputs for high");
      outputs = GetNetHigh()->compute(inputs);
    } else {
      outputs = GetNetLow()->compute(inputs);
    }
  }
  ATH_MSG_DEBUG("Start Network inputs ~~~~~~~~");
  ATH_MSG_DEBUG(VNetworkBase::representNetworkInputs(inputs, 10000));
  ATH_MSG_DEBUG("End Network inputs ~~~~~~~~");
  ATH_MSG_DEBUG("Start Network outputs ~~~~~~~~");
  ATH_MSG_DEBUG(VNetworkBase::representNetworkOutputs(outputs, 10000));
  ATH_MSG_DEBUG("End Network outputs ~~~~~~~~");
  return outputs;
}

IsGanCorrectlyLoaded()

bool TFCSGANEtaSlice::IsGanCorrectlyLoaded

(

)

const

Definition at line 56 of file TFCSGANEtaSlice.cxx.

                                                 {
  if (m_pid == 211 || m_pid == 2212) {
    if (GetNetAll() == nullptr) {
      return false;
    }
  } else {
    if (GetNetHigh() == nullptr || GetNetLow() == nullptr) {
      return false;
    }
  }
  return true;
}

level()

MSG::Level ISF_FCS::MLogging::level ( ) const

inlineinherited

Retrieve output level.

Definition at line 201 of file MLogging.h.

{ return msg().level(); }

LoadGAN()

bool TFCSGANEtaSlice::LoadGAN

(

)

Definition at line 69 of file TFCSGANEtaSlice.cxx.

                              {
  // Now load new data
  std::string inputFileName;
 
  CalculateMeanPointFromDistributionOfR();
  ExtractExtrapolatorMeansFromInputs();
 
  bool success = true;
 
  if (m_pid == 211) {
    inputFileName = std::format("{}/neural_net_{}_eta_{}_{}_All.*",
                                m_param.GetInputFolder(),
                                m_pid,
                                m_etaMin,
                                m_etaMax);
    ATH_MSG_DEBUG("Gan input file name " << inputFileName);
    m_net_all = TFCSNetworkFactory::create(std::move(inputFileName));
    if (m_net_all == nullptr)
      success = false;
  } else if (m_pid == 2212) {
    inputFileName = std::format("{}/neural_net_{}_eta_{}_{}_High10.*",
                                m_param.GetInputFolder(),
                                m_pid,
                                m_etaMin,
                                m_etaMax);
    ATH_MSG_DEBUG("Gan input file name " << inputFileName);
    m_net_all = TFCSNetworkFactory::create(std::move(inputFileName));
    if (m_net_all == nullptr)
      success = false;
  } else {
    inputFileName = std::format("{}/neural_net_{}_eta_{}_{}_High12.*",
                                m_param.GetInputFolder(),
                                m_pid,
                                m_etaMin,
                                m_etaMax);
    ATH_MSG_DEBUG("Gan input file name " << inputFileName);
    m_net_high = TFCSNetworkFactory::create(inputFileName);
    if (m_net_high == nullptr)
      success = false;
 
    inputFileName = std::format("{}/neural_net_{}_eta_{}_{}_UltraLow12.*",
                                m_param.GetInputFolder(),
                                m_pid,
                                m_etaMin,
                                m_etaMax);
    m_net_low = TFCSNetworkFactory::create(std::move(inputFileName));
    if (m_net_low == nullptr)
      success = false;
  }
  return success;
}

LoadGANFromRange()

bool TFCSGANEtaSlice::LoadGANFromRange ( std::string inputFileName, std::string energyRange )

private

LoadGANNoRange()

bool TFCSGANEtaSlice::LoadGANNoRange ( std::string inputFileName )

private

msg() [1/2]

MsgStream & ISF_FCS::MLogging::msg ( ) const

inlineinherited

Return a stream for sending messages directly (no decoration)

Definition at line 231 of file MLogging.h.

                                      {
  MsgStream *ms = m_msg_tls.get();
  if (!ms) {
    ms = new MsgStream(Athena::getMessageSvc(), m_nm);
    m_msg_tls.reset(ms);
  }
  return *ms;
}

msg() [2/2]

MsgStream & ISF_FCS::MLogging::msg ( const MSG::Level lvl ) const

inlineinherited

Return a decorated starting stream for sending messages.

Definition at line 240 of file MLogging.h.

                                                        {
  return msg() << lvl;
}

msgLvl()

bool ISF_FCS::MLogging::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Check whether the logging system is active at the provided verbosity level.

Definition at line 222 of file MLogging.h.

                                                     {
  if (msg().level() <= lvl) {
    msg() << lvl;
    return true;
  } else {
    return false;
  }
}

operator=()

TFCSGANEtaSlice & TFCSGANEtaSlice::operator= ( const TFCSGANEtaSlice & )

delete

Print()

void TFCSGANEtaSlice::Print

(

)

const

Definition at line 270 of file TFCSGANEtaSlice.cxx.

                                  {
  ATH_MSG_INFO("LWTNN Handler parameters");
  ATH_MSG_INFO("  pid: " << m_pid);
  ATH_MSG_INFO("  etaMin:" << m_etaMin);
  ATH_MSG_INFO("  etaMax: " << m_etaMax);
  m_param.Print();
}

setLevel()

void ISF_FCS::MLogging::setLevel ( MSG::Level lvl )

virtualinherited

Update outputlevel.

Definition at line 105 of file MLogging.cxx.

                                    {
  lvl = (lvl >= MSG::NUM_LEVELS) ? MSG::ALWAYS
        : (lvl < MSG::NIL)       ? MSG::NIL
                                 : lvl;
  msg().setLevel(lvl);
}

startMsg()

std::string ISF_FCS::MLogging::startMsg ( MSG::Level lvl, const std::string & file, int line )

staticinherited

Make a message to decorate the start of logging.

Print a message for the start of logging.

Definition at line 116 of file MLogging.cxx.

                                                                          {
  int col1_len = 20;
  int col2_len = 5;
  int col3_len = 10;
  auto last_slash = file.find_last_of('/');
  int path_len = last_slash == std::string::npos ? 0 : last_slash;
  int trim_point = path_len;
  int total_len = file.length();
  if (total_len - path_len > col1_len)
    trim_point = total_len - col1_len;
  std::string trimmed_name = file.substr(trim_point);
  const char *LevelNames[MSG::NUM_LEVELS] = {
      "NIL", "VERBOSE", "DEBUG", "INFO", "WARNING", "ERROR", "FATAL", "ALWAYS"};
  std::string level = LevelNames[lvl];
  std::string level_string = std::string("(") + level + ") ";
  std::stringstream output;
  output << std::setw(col1_len) << std::right << trimmed_name << ":"
         << std::setw(col2_len) << std::left << line << std::setw(col3_len)
         << std::right << level_string;
  return output.str();
}

Member Data Documentation

ATLAS_THREAD_SAFE

boost::thread_specific_ptr<MsgStream> m_msg_tls ISF_FCS::MLogging::ATLAS_THREAD_SAFE

inlinestaticprivateinherited

Do not persistify!

MsgStream instance (a std::cout like with print-out levels)

Definition at line 215 of file MLogging.h.

m_allFitResults

FitResultsPerLayer TFCSGANEtaSlice::m_allFitResults

private

Definition at line 66 of file TFCSGANEtaSlice.h.

m_etaMax

int TFCSGANEtaSlice::m_etaMax {}

private

Definition at line 62 of file TFCSGANEtaSlice.h.

{};

m_etaMin

int TFCSGANEtaSlice::m_etaMin {}

private

Definition at line 61 of file TFCSGANEtaSlice.h.

{};

m_extrapolatorWeights

ExtrapolatorWeights TFCSGANEtaSlice::m_extrapolatorWeights

private

Definition at line 67 of file TFCSGANEtaSlice.h.

m_gan_all

TFCSGANLWTNNHandler* TFCSGANEtaSlice::m_gan_all = nullptr

private

Definition at line 71 of file TFCSGANEtaSlice.h.

m_gan_high

TFCSGANLWTNNHandler* TFCSGANEtaSlice::m_gan_high = nullptr

private

Definition at line 73 of file TFCSGANEtaSlice.h.

m_gan_low

TFCSGANLWTNNHandler* TFCSGANEtaSlice::m_gan_low = nullptr

private

Definition at line 72 of file TFCSGANEtaSlice.h.

m_inputFolderName

std::string TFCSGANEtaSlice::m_inputFolderName

private

Definition at line 64 of file TFCSGANEtaSlice.h.

m_net_all

std::unique_ptr<VNetworkBase> TFCSGANEtaSlice::m_net_all = nullptr

private

Definition at line 75 of file TFCSGANEtaSlice.h.

m_net_high

std::unique_ptr<VNetworkBase> TFCSGANEtaSlice::m_net_high = nullptr

private

Definition at line 77 of file TFCSGANEtaSlice.h.

m_net_low

std::unique_ptr<VNetworkBase> TFCSGANEtaSlice::m_net_low = nullptr

private

Definition at line 76 of file TFCSGANEtaSlice.h.

m_nm

std::string ISF_FCS::MLogging::m_nm

privateinherited

Message source name.

Definition at line 211 of file MLogging.h.

m_param

TFCSGANXMLParameters TFCSGANEtaSlice::m_param {}

private

Definition at line 86 of file TFCSGANEtaSlice.h.

{};

m_pid

int TFCSGANEtaSlice::m_pid {}

private

Definition at line 60 of file TFCSGANEtaSlice.h.

{};

---

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

• TFCSGANEtaSlice.h
• TFCSGANEtaSlice.cxx