#include <GainUncertainty.h>

Inheritance diagram for egGain::GainUncertainty:

Collaboration diagram for egGain::GainUncertainty:

Public Types
enum class	GainType { MEDIUM , LOW , MEDIUMLOW }

Public Member Functions
	GainUncertainty (const std::string &filename, bool splitGainUnc=false, const std::string &name="GainUncertainty", bool setInterpolation=false)
	~GainUncertainty ()
double	getUncertainty (double etaCalo_input, double et_input, PATCore::ParticleType::Type ptype=PATCore::ParticleType::Electron, bool useUncertainty=false, GainType gainType=GainType::MEDIUMLOW) const
void	setLevel (MSG::Level lvl)
	Change the current logging level.
Functions providing the same interface as AthMessaging
bool	msgLvl (const MSG::Level lvl) const
	Test the output level of the object.
MsgStream &	msg () const
	The standard message stream.
MsgStream &	msg (const MSG::Level lvl) const
	The standard message stream.

Private Member Functions
void	initMessaging () const
	Initialize our message level and MessageSvc.

Private Attributes
TH1 *	m_alpha_specialGainRun
TH1 *	m_gain_impact_Zee
TH1 *	m_gain_Impact_elec [s_nEtaBins] {}
TH1 *	m_gain_Impact_conv [s_nEtaBins] {}
TH1 *	m_gain_Impact_unco [s_nEtaBins] {}
TH1 *	m_gain_Impact_elec_medium [s_nEtaBins] {}
TH1 *	m_gain_Impact_conv_medium [s_nEtaBins] {}
TH1 *	m_gain_Impact_unco_medium [s_nEtaBins] {}
TH1 *	m_gain_Impact_elec_low [s_nEtaBins] {}
TH1 *	m_gain_Impact_conv_low [s_nEtaBins] {}
TH1 *	m_gain_Impact_unco_low [s_nEtaBins] {}
bool	m_useInterpolation
std::string	m_nm
	Message source name.
boost::thread_specific_ptr< MsgStream >	m_msg_tls
	MsgStream instance (a std::cout like with print-out levels)
std::atomic< IMessageSvc * >	m_imsg { nullptr }
	MessageSvc pointer.
std::atomic< MSG::Level >	m_lvl { MSG::NIL }
	Current logging level.
std::atomic_flag m_initialized	ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT
	Messaging initialized (initMessaging)

Static Private Attributes
static const int	s_nEtaBins = 5

Detailed Description

Definition at line 17 of file GainUncertainty.h.

Member Enumeration Documentation

◆ GainType

enum class egGain::GainUncertainty::GainType

strong

Enumerator
MEDIUM
LOW
MEDIUMLOW

Definition at line 23 of file GainUncertainty.h.

23{ MEDIUM, LOW, MEDIUMLOW };

EMAmbiguityType::MEDIUM

@ MEDIUM

Definition EMAmbiguityToolDefs.h:18

Constructor & Destructor Documentation

◆ GainUncertainty()

egGain::GainUncertainty::GainUncertainty	(	const std::string &	filename,
		bool	splitGainUnc = false,
		const std::string &	name = "GainUncertainty",
		bool	setInterpolation = false )

Definition at line 17 of file GainUncertainty.cxx.

    : asg::AsgMessaging(thisname.c_str()) {
 
  ATH_MSG_INFO("opening file " << filename);
  std::unique_ptr<TFile> gainFile(TFile::Open(filename.c_str(), "READ"));
 
  if (not(m_alpha_specialGainRun =
              (TH1*)(gainFile->Get("alpha_specialGainRun"))))
    ATH_MSG_FATAL("cannot open alpha_specialGainRun");
  m_alpha_specialGainRun->SetDirectory(nullptr);
  if (not(m_gain_impact_Zee = (TH1*)(gainFile->Get("gain_impact_Zee"))))
    ATH_MSG_FATAL("cannot open gain_impact_Zee");
  m_gain_impact_Zee->SetDirectory(nullptr);
  for (int i = 0; i < s_nEtaBins; i++) {
    char name[60];
    sprintf(name, "gain_Impact_elec_%d", i);
    if (not(m_gain_Impact_elec[i] = (TH1*)(gainFile->Get(name))))
      ATH_MSG_FATAL("cannot open " << name);
    m_gain_Impact_elec[i]->SetDirectory(nullptr);
    sprintf(name, "gain_Impact_conv_%d", i);
    if (not(m_gain_Impact_conv[i] = (TH1*)(gainFile->Get(name))))
      ATH_MSG_FATAL("cannot open " << name);
    m_gain_Impact_conv[i]->SetDirectory(nullptr);
    sprintf(name, "gain_Impact_unco_%d", i);
    if (not(m_gain_Impact_unco[i] = (TH1*)(gainFile->Get(name))))
      ATH_MSG_FATAL("cannot open " << name);
    m_gain_Impact_unco[i]->SetDirectory(nullptr);
 
    if (splitGainUnc) {
      sprintf(name, "gain_Impact_elec_%d_medium", i);
      if (not(m_gain_Impact_elec_medium[i] = (TH1*)(gainFile->Get(name))))
        ATH_MSG_FATAL("cannot open " << name);
      m_gain_Impact_elec_medium[i]->SetDirectory(nullptr);
 
      sprintf(name, "gain_Impact_conv_%d_medium", i);
      if (not(m_gain_Impact_conv_medium[i] = (TH1*)(gainFile->Get(name))))
        ATH_MSG_FATAL("cannot open " << name);
      m_gain_Impact_conv_medium[i]->SetDirectory(nullptr);
 
      sprintf(name, "gain_Impact_unco_%d_medium", i);
      if (not(m_gain_Impact_unco_medium[i] = (TH1*)(gainFile->Get(name))))
        ATH_MSG_FATAL("cannot open " << name);
      m_gain_Impact_unco_medium[i]->SetDirectory(nullptr);
 
      sprintf(name, "gain_Impact_elec_%d_low", i);
      if (not(m_gain_Impact_elec_low[i] = (TH1*)(gainFile->Get(name))))
        ATH_MSG_FATAL("cannot open " << name);
      m_gain_Impact_elec_low[i]->SetDirectory(nullptr);
 
      sprintf(name, "gain_Impact_conv_%d_low", i);
      if (not(m_gain_Impact_conv_low[i] = (TH1*)(gainFile->Get(name))))
        ATH_MSG_FATAL("cannot open " << name);
      m_gain_Impact_conv_low[i]->SetDirectory(nullptr);
 
      sprintf(name, "gain_Impact_unco_%d_low", i);
      if (not(m_gain_Impact_unco_low[i] = (TH1*)(gainFile->Get(name))))
        ATH_MSG_FATAL("cannot open " << name);
      m_gain_Impact_unco_low[i]->SetDirectory(nullptr);
    }
  }
 
  m_useInterpolation = setInterpolation;
}

◆ ~GainUncertainty()

egGain::GainUncertainty::~GainUncertainty ( )

Definition at line 84 of file GainUncertainty.cxx.

                                  {
  delete m_alpha_specialGainRun;
  delete m_gain_impact_Zee;
  for (int i = 0; i < s_nEtaBins; i++) {
    delete m_gain_Impact_elec[i];
    delete m_gain_Impact_conv[i];
    delete m_gain_Impact_unco[i];
 
    delete m_gain_Impact_elec_medium[i];
    delete m_gain_Impact_conv_medium[i];
    delete m_gain_Impact_unco_medium[i];
 
    delete m_gain_Impact_elec_low[i];
    delete m_gain_Impact_conv_low[i];
    delete m_gain_Impact_unco_low[i];
  }
}

Member Function Documentation

◆ getUncertainty()

double egGain::GainUncertainty::getUncertainty	(	double	etaCalo_input,
		double	et_input,
		PATCore::ParticleType::Type	ptype = PATCore::ParticleType::Electron,
		bool	useUncertainty = false,
		GainType	gainType = GainType::MEDIUMLOW ) const

Definition at line 106 of file GainUncertainty.cxx.

                                                                {
  double aeta = std::fabs(etaCalo_input);
  int ibin = -1;
  if (aeta < 0.8)
    ibin = 0;
  else if (aeta < 1.37)
    ibin = 1;
  else if (aeta < 1.52)
    ibin = 2;
  else if (aeta < 1.80)
    ibin = 3;
  else if (aeta < 2.50)
    ibin = 4;
  if (ibin < 0)
    return 0.;
  ATH_MSG_VERBOSE("GainUncertainty::getUncertainty " << etaCalo_input << " "
                                                     << et_input << " " << ptype
                                                     << " ibin " << ibin);
 
  // Protection needed as the histograms stops at 1 TeV
  if (et_input > 999999.)
    et_input = 999999.;
 
  //       std::cout << " --- in  GainUncertainty::getUncertainty " <<
  //       etaCalo_input << " " << et_input << " " << ptype << " ibin " << ibin
  //       << std::endl;
 
  TH1* hImpact = nullptr;
  // Medium+Low gain effect
  if (gainType == GainType::MEDIUMLOW) {
    if (ptype == PATCore::ParticleType::Electron)
      hImpact = m_gain_Impact_elec[ibin];
    else if (ptype == PATCore::ParticleType::ConvertedPhoton)
      hImpact = m_gain_Impact_conv[ibin];
    else if (ptype == PATCore::ParticleType::UnconvertedPhoton)
      hImpact = m_gain_Impact_unco[ibin];
    else {
      ATH_MSG_WARNING(
          "Trying to get Gain correction of not allowed particle type");
      return 0;
    }
  }
 
  // Medium gain effect
  else if (gainType == GainType::MEDIUM) {
    if (ptype == PATCore::ParticleType::Electron)
      hImpact = m_gain_Impact_elec_medium[ibin];
    else if (ptype == PATCore::ParticleType::ConvertedPhoton)
      hImpact = m_gain_Impact_conv_medium[ibin];
    else if (ptype == PATCore::ParticleType::UnconvertedPhoton)
      hImpact = m_gain_Impact_unco_medium[ibin];
    else {
      ATH_MSG_WARNING(
          "Trying to get Gain correction of not allowed particle type");
      return 0;
    }
  }
  // Low gain effect
  else if (gainType == GainType::LOW) {
    if (ptype == PATCore::ParticleType::Electron)
      hImpact = m_gain_Impact_elec_low[ibin];
    else if (ptype == PATCore::ParticleType::ConvertedPhoton)
      hImpact = m_gain_Impact_conv_low[ibin];
    else if (ptype == PATCore::ParticleType::UnconvertedPhoton)
      hImpact = m_gain_Impact_unco_low[ibin];
    else {
      ATH_MSG_WARNING(
          "Trying to get Gain correction of not allowed particle type");
      return 0;
    }
  }
 
  double max_et = hImpact->GetXaxis()->GetBinUpEdge(hImpact->GetNbinsX());
  // Protection needed to match maximum Et in the histogram
  if (0.001 * et_input > max_et) {
    et_input = (max_et - 1.) * 1000.;
  }
 
  double impact = 0;
  if (m_useInterpolation) {
    impact = hImpact->Interpolate(0.001 * et_input);
    ATH_MSG_DEBUG(
        "L2 gain impact without interpolation: "
        << hImpact->GetBinContent(hImpact->FindFixBin(0.001 * et_input)));
    ATH_MSG_DEBUG("L2 gain impact with interpolation: "
                  << hImpact->Interpolate(0.001 * et_input));
  } else {
    impact = hImpact->GetBinContent(hImpact->FindFixBin(0.001 * et_input));
  }
 
  int ieta = m_alpha_specialGainRun->FindFixBin(aeta);
  if (useL2GainUncertainty)
    ATH_MSG_INFO("Applying 100% uncertainy on l2 gain corrections");
 
  double alphaG = m_alpha_specialGainRun->GetBinContent(ieta);
 
  double impactZee =
      m_gain_impact_Zee->GetBinContent(m_gain_impact_Zee->FindFixBin(aeta));
 
  double_t sigmaE = alphaG * impact / impactZee;
 
  ATH_MSG_VERBOSE("alpha_specialGainRun, gain_impact_Zee, impact, sigmaE = "
                  << alphaG << " " << impactZee << " " << impact << " "
                  << sigmaE);
 
  return sigmaE;
}

◆ initMessaging()

void AthMessaging::initMessaging ( ) const

privateinherited

Initialize our message level and MessageSvc.

This method should only be called once.

Definition at line 39 of file AthMessaging.cxx.

{
  m_imsg = Athena::getMessageSvc();
  // If user did not set an explicit level, set a default
  if (m_lvl == MSG::NIL) {
    m_lvl = m_imsg ?
      static_cast<MSG::Level>( m_imsg.load()->outputLevel(m_nm) ) :
      MSG::INFO;
  }
}

◆ msg() [1/2]

MsgStream & asg::AsgMessaging::msg ( ) const

inherited

The standard message stream.

Returns: A reference to the default message stream of this object.

Definition at line 49 of file AsgMessaging.cxx.

                                      {
#ifndef XAOD_STANDALONE
      return ::AthMessaging::msg();
#else // not XAOD_STANDALONE
      return m_msg;
#endif // not XAOD_STANDALONE
   }

◆ msg() [2/2]

MsgStream & asg::AsgMessaging::msg ( const MSG::Level lvl ) const

inherited

The standard message stream.

Parameters

lvl	The message level to set the stream to

Returns: A reference to the default message stream, set to level "lvl"

Definition at line 57 of file AsgMessaging.cxx.

                                                          {
#ifndef XAOD_STANDALONE
      return ::AthMessaging::msg( lvl );
#else // not XAOD_STANDALONE
      m_msg << lvl;
      return m_msg;
#endif // not XAOD_STANDALONE
   }

◆ msgLvl()

bool asg::AsgMessaging::msgLvl ( const MSG::Level lvl ) const

inherited

Test the output level of the object.

Parameters

lvl	The message level to test against

Returns: boolean Indicting if messages at given level will be printed; true If messages at level "lvl" will be printed

Definition at line 41 of file AsgMessaging.cxx.

                                                       {
#ifndef XAOD_STANDALONE
      return ::AthMessaging::msgLvl( lvl );
#else // not XAOD_STANDALONE
      return m_msg.msgLevel( lvl );
#endif // not XAOD_STANDALONE
   }

◆ setLevel()

void AthMessaging::setLevel ( MSG::Level lvl )

inherited

Change the current logging level.

Use this rather than msg().setLevel() for proper operation with MT.

Definition at line 28 of file AthMessaging.cxx.

{
  m_lvl = lvl;
}

Member Data Documentation

◆ ATLAS_THREAD_SAFE

std::atomic_flag m_initialized AthMessaging::ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT

mutableprivateinherited

Messaging initialized (initMessaging)

Definition at line 141 of file AthMessaging.h.

◆ m_alpha_specialGainRun

TH1* egGain::GainUncertainty::m_alpha_specialGainRun

private

Definition at line 38 of file GainUncertainty.h.

◆ m_gain_Impact_conv

TH1* egGain::GainUncertainty::m_gain_Impact_conv[s_nEtaBins] {}

private

Definition at line 41 of file GainUncertainty.h.

41{};

◆ m_gain_Impact_conv_low

TH1* egGain::GainUncertainty::m_gain_Impact_conv_low[s_nEtaBins] {}

private

Definition at line 47 of file GainUncertainty.h.

47{};

◆ m_gain_Impact_conv_medium

TH1* egGain::GainUncertainty::m_gain_Impact_conv_medium[s_nEtaBins] {}

private

Definition at line 44 of file GainUncertainty.h.

44{};

◆ m_gain_Impact_elec

TH1* egGain::GainUncertainty::m_gain_Impact_elec[s_nEtaBins] {}

private

Definition at line 40 of file GainUncertainty.h.

40{};

◆ m_gain_Impact_elec_low

TH1* egGain::GainUncertainty::m_gain_Impact_elec_low[s_nEtaBins] {}

private

Definition at line 46 of file GainUncertainty.h.

46{};

◆ m_gain_Impact_elec_medium

TH1* egGain::GainUncertainty::m_gain_Impact_elec_medium[s_nEtaBins] {}

private

Definition at line 43 of file GainUncertainty.h.

43{};

◆ m_gain_Impact_unco

TH1* egGain::GainUncertainty::m_gain_Impact_unco[s_nEtaBins] {}

private

Definition at line 42 of file GainUncertainty.h.

42{};

◆ m_gain_Impact_unco_low

TH1* egGain::GainUncertainty::m_gain_Impact_unco_low[s_nEtaBins] {}

private

Definition at line 48 of file GainUncertainty.h.

48{};

◆ m_gain_Impact_unco_medium

TH1* egGain::GainUncertainty::m_gain_Impact_unco_medium[s_nEtaBins] {}

private

Definition at line 45 of file GainUncertainty.h.

45{};

◆ m_gain_impact_Zee

TH1* egGain::GainUncertainty::m_gain_impact_Zee

private

Definition at line 39 of file GainUncertainty.h.

◆ m_imsg

std::atomic<IMessageSvc*> AthMessaging::m_imsg { nullptr }

mutableprivateinherited

MessageSvc pointer.

Definition at line 135 of file AthMessaging.h.

135{ nullptr };

◆ m_lvl

std::atomic<MSG::Level> AthMessaging::m_lvl { MSG::NIL }

mutableprivateinherited

Current logging level.

Definition at line 138 of file AthMessaging.h.

138{ MSG::NIL };

◆ m_msg_tls

boost::thread_specific_ptr<MsgStream> AthMessaging::m_msg_tls

mutableprivateinherited

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

Definition at line 132 of file AthMessaging.h.

◆ m_nm

std::string AthMessaging::m_nm

privateinherited

Message source name.

Definition at line 129 of file AthMessaging.h.

◆ m_useInterpolation

bool egGain::GainUncertainty::m_useInterpolation

private

Definition at line 50 of file GainUncertainty.h.

◆ s_nEtaBins

const int egGain::GainUncertainty::s_nEtaBins = 5

staticprivate

Definition at line 37 of file GainUncertainty.h.

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

Public Types

Public Member Functions

Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Member Enumeration Documentation

◆ GainType

Constructor & Destructor Documentation

◆ GainUncertainty()

◆ ~GainUncertainty()

Member Function Documentation

◆ getUncertainty()

◆ initMessaging()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msgLvl()

◆ setLevel()

Member Data Documentation

◆ ATLAS_THREAD_SAFE

◆ m_alpha_specialGainRun

◆ m_gain_Impact_conv

◆ m_gain_Impact_conv_low

◆ m_gain_Impact_conv_medium

◆ m_gain_Impact_elec

◆ m_gain_Impact_elec_low

◆ m_gain_Impact_elec_medium

◆ m_gain_Impact_unco

◆ m_gain_Impact_unco_low

◆ m_gain_Impact_unco_medium

◆ m_gain_impact_Zee

◆ m_imsg

◆ m_lvl

◆ m_msg_tls

◆ m_nm

◆ m_useInterpolation

◆ s_nEtaBins