#include <dumpAllSystematics.h>

Inheritance diagram for DumpAllSystematics:

Collaboration diagram for DumpAllSystematics:

Public Member Functions
	DumpAllSystematics (const std::string &name, ISvcLocator *svcLoc)
	Regular Algorithm constructor.
virtual StatusCode	initialize ()
virtual StatusCode	execute ()
virtual StatusCode	finalize ()
virtual StatusCode	sysInitialize () override
	Override sysInitialize.
virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies.
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard `StoreGateSvc` (event store) Returns (kind of) a pointer to the `StoreGateSvc`.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard `StoreGateSvc/DetectorStore` Returns (kind of) a pointer to the `StoreGateSvc`.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

Public Attributes
std::string	m_particle_name
std::string	m_reco_container_name
bool	m_keep_one

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed.

Private Types
enum class	ParticleType { ELECTRON , PHOTON }
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
StatusCode	do_truth (const xAOD::Egamma &particle)
StatusCode	do_egamma (const xAOD::Egamma &particle)
StatusCode	do_energy (xAOD::Egamma &particle, int itool)
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
ParticleType	m_particle_type = ParticleType::ELECTRON
TTree *	m_tree {}
unsigned long long	m_EventNumber {}
uint32_t	m_RunNumber {}
int	m_instance_index {}
float	m_actualIntPerXing {}
float	m_averageIntPerXing {}
float	m_truth_pt {}
float	m_truth_phi {}
float	m_truth_eta {}
float	m_truth_E {}
int	m_truth_pdgId {}
int	m_truth_parent_pdgId {}
bool	m_truth_matched {}
bool	m_truth_isConv {}
float	m_truth_Rconv {}
int	m_npv {}
float	m_cl_phi {}
float	m_cl_eta {}
float	m_cl_etaCalo {}
float	m_cl_rawcl_Es0 {}
float	m_cl_rawcl_Es1 {}
float	m_cl_rawcl_Es2 {}
float	m_cl_rawcl_Es3 {}
float	m_cl_E {}
float	m_ph_Rconv {}
int	m_ph_convFlag {}
float	m_wstot {}
std::vector< float >	m_nominal_E
std::vector< float >	m_energy_variations_sum_up
std::vector< float >	m_energy_variations_sum_down
std::vector< std::vector< float > >	m_energy_variations
ToolHandleArray< CP::IEgammaCalibrationAndSmearingTool >	m_EgammaCalibrationAndSmearingTools
DataObjIDColl	m_extendedExtraObjects
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default)
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default)
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

Definition at line 22 of file dumpAllSystematics.h.

Member Typedef Documentation

◆ StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< Algorithm > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Member Enumeration Documentation

◆ ParticleType

enum class DumpAllSystematics::ParticleType

strongprivate

Enumerator
ELECTRON
PHOTON

Definition at line 37 of file dumpAllSystematics.h.

  {
    ELECTRON,
    PHOTON
  };

Constructor & Destructor Documentation

◆ DumpAllSystematics()

DumpAllSystematics::DumpAllSystematics	(	const std::string &	name,
		ISvcLocator *	svcLoc )

Regular Algorithm constructor.

Definition at line 34 of file dumpAllSystematics.cxx.

  : AthAlgorithm(name, svcLoc)
{
  declareProperty("EgammaCalibrationAndSmearingTools", m_EgammaCalibrationAndSmearingTools);
  declareProperty("particle", m_particle_name="", "electron/photon");
  declareProperty("recoContainer", m_reco_container_name="", "reco container name");
  declareProperty("keepOnlyOne", m_keep_one=false, "keep only the most energetic particle");
}

Member Function Documentation

◆ declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty	(	Gaudi::Property< T, V, H > &	hndl,
		const SG::VarHandleKeyType &	)

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

◆ declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( Gaudi::Property< T, V, H > & t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                     {
    typedef typename SG::HandleClassifier<T>::type htype;
    return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
  }

◆ detStore()

const ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< Algorithm > >::detStore ( ) const

inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

95{ return m_detStore; }

AthCommonDataStore< AthCommonMsg< Algorithm > >::m_detStore

StoreGateSvc_t m_detStore

Definition AthCommonDataStore.h:393

◆ do_egamma()

StatusCode DumpAllSystematics::do_egamma ( const xAOD::Egamma & particle )

private

Definition at line 298 of file dumpAllSystematics.cxx.

{
  m_cl_phi = particle.phi();
  m_cl_eta = particle.caloCluster()->eta();
  m_cl_etaCalo = xAOD::get_eta_calo(*particle.caloCluster(),particle.author());
  m_cl_rawcl_Es0 = particle.caloCluster()->energyBE(0);
  m_cl_rawcl_Es1 = particle.caloCluster()->energyBE(1);
  m_cl_rawcl_Es2 = particle.caloCluster()->energyBE(2);
  m_cl_rawcl_Es3 = particle.caloCluster()->energyBE(3);
  static const SG::AuxElement::Accessor<float> wstot_accessor("wtots1");
  m_wstot = wstot_accessor.isAvailable(particle) ? wstot_accessor(particle) : -999;
  m_cl_E = particle.caloCluster()->e();
 
  return StatusCode::SUCCESS;
}

◆ do_energy()

StatusCode DumpAllSystematics::do_energy	(	xAOD::Egamma &	particle,
		int	itool )

private

Definition at line 314 of file dumpAllSystematics.cxx.

{
  m_nominal_E[itool] = m_energy_variations_sum_up[itool] = m_energy_variations_sum_down[itool] = -999.;
  std::fill(m_energy_variations[itool].begin(), m_energy_variations[itool].end(), -999.);
 
  if (m_EgammaCalibrationAndSmearingTools[itool]->applySystematicVariation(CP::SystematicSet()) != StatusCode::SUCCESS) {
    ATH_MSG_ERROR("cannot apply nominal energy");
    return StatusCode::FAILURE;
  }
  if (m_EgammaCalibrationAndSmearingTools[itool]->applyCorrection(particle) == CP::CorrectionCode::Ok) {
    m_nominal_E[itool] = particle.e();
    ATH_MSG_DEBUG("nominal energy: " << particle.e());
  }
  else {
    ATH_MSG_WARNING("Cannot calibrate electron, eta: "  << particle.eta() << " phi: " << particle.phi());
    return StatusCode::FAILURE;
  }
 
  // systematics
  m_energy_variations_sum_up[itool] = 0.;
  m_energy_variations_sum_down[itool] = 0.;
 
  const CP::SystematicSet& sys_set = m_EgammaCalibrationAndSmearingTools[itool]->recommendedSystematics();
  int isys = -1;  // ugly
  for (const auto& sys : sys_set) {
    ++isys;
    CP::SystematicSet ss;
    ss.insert(sys);
 
    if (m_EgammaCalibrationAndSmearingTools[itool]->applySystematicVariation(ss) != StatusCode::SUCCESS)  {
      ATH_MSG_ERROR("Cannot configure calibration tool for systematic");
      continue;
    }
 
    if (m_EgammaCalibrationAndSmearingTools[itool]->applyCorrection(particle) == CP::CorrectionCode::Ok) {
      m_energy_variations[itool][isys] = particle.e() / m_nominal_E[itool] - 1;
 
      if (sys.basename().find("SCALE") != std::string::npos) { // sum only the scale variations
        if (sys.parameter() == 1) m_energy_variations_sum_up[itool] += m_energy_variations[itool][isys] * m_energy_variations[itool][isys];
        else if (sys.parameter() == -1) m_energy_variations_sum_down[itool] += m_energy_variations[itool][isys] * m_energy_variations[itool][isys];
      }
      ATH_MSG_DEBUG("calibrated with systematic " << sys.name() << ": " << particle.e());
    }
    else {
      ATH_MSG_WARNING("Cannot calibrate electron with systematic");
    }
  }
 
  m_energy_variations_sum_up[itool] = sqrt(m_energy_variations_sum_up[itool]);
  m_energy_variations_sum_down[itool] = sqrt(m_energy_variations_sum_down[itool]);
 
  return StatusCode::SUCCESS;
}

◆ do_truth()

StatusCode DumpAllSystematics::do_truth ( const xAOD::Egamma & particle )

private

Definition at line 265 of file dumpAllSystematics.cxx.

{
  // truth
  const xAOD::TruthParticle* true_particle = nullptr;
  true_particle = xAOD::TruthHelpers::getTruthParticle(particle);
 
  if (true_particle) {
    m_truth_matched = true;
    m_truth_pt = true_particle->pt();
    m_truth_phi = true_particle->phi();
    m_truth_eta = true_particle->eta();
    m_truth_E = true_particle->e();
    m_truth_pdgId = true_particle->pdgId();
 
    m_truth_parent_pdgId = -999;
    for (size_t p = 0; p < true_particle->nParents(); ++p) {
      if (true_particle->parent(p)) { m_truth_parent_pdgId = true_particle->parent(p)->pdgId();  break; }
    }
 
    if (m_particle_type == ParticleType::PHOTON) {
      m_truth_isConv = xAOD::EgammaHelpers::isTrueConvertedPhoton(true_particle);
      m_truth_Rconv = (true_particle->pdgId() == 22) ? (true_particle->hasDecayVtx() ? true_particle->decayVtx()->perp() : 0) : -999;
    }
 
  }
  else {
    m_truth_pt = m_truth_phi = m_truth_eta = m_truth_E = m_truth_pdgId = m_truth_parent_pdgId = m_truth_Rconv = -999;
    m_truth_matched = false;
    m_truth_isConv = false;  // careful here (always check truth_matched before)
  }
  return StatusCode::SUCCESS;
}

◆ evtStore()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< Algorithm > >::evtStore ( )

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

85{ return m_evtStore; }

AthCommonDataStore< AthCommonMsg< Algorithm > >::m_evtStore

StoreGateSvc_t m_evtStore

Definition AthCommonDataStore.h:390

◆ execute()

StatusCode DumpAllSystematics::execute ( )

virtual

Definition at line 190 of file dumpAllSystematics.cxx.

{
  const xAOD::EventInfo* eventInfo = nullptr;
  ATH_CHECK(evtStore()->retrieve(eventInfo));
 
  m_actualIntPerXing = eventInfo->actualInteractionsPerCrossing();
  m_averageIntPerXing = eventInfo->averageInteractionsPerCrossing();
  m_EventNumber = eventInfo->eventNumber();
  m_RunNumber = eventInfo->runNumber();
 
  // vertex information
  const xAOD::VertexContainer* vtx_container = nullptr;
  if (!evtStore()->retrieve(vtx_container, "PrimaryVertices")) { m_npv = -999; }
  else {
    m_npv = 0;
    for (const auto* vtx : *vtx_container) { if (vtx->vertexType() == xAOD::VxType::PriVtx or vtx->vertexType() ==  xAOD::VxType::PileUp) ++m_npv; }
  }
 
 
  if (m_particle_type == ParticleType::ELECTRON) {  // TODO: find a better way to generalize to electron / photons
 
    const xAOD::ElectronContainer* electrons = nullptr;
    CHECK(evtStore()->retrieve(electrons, m_reco_container_name));
 
    std::pair<xAOD::ElectronContainer*, xAOD::ShallowAuxContainer*> electrons_shallowCopy = xAOD::shallowCopyContainer(*electrons);
    for (xAOD::Electron* el : *electrons_shallowCopy.first) {
      ATH_MSG_DEBUG("new electron eta: " << el->eta());
 
 
      CHECK(do_truth(*el));
      CHECK(do_egamma(*el));
      for (unsigned int itool = 0; itool != m_EgammaCalibrationAndSmearingTools.size(); ++itool) {
        CHECK(do_energy(*el, itool));
      }
 
      m_tree->Fill();
 
      if (m_keep_one) break;
    }
  }
  else if (m_particle_type == ParticleType::PHOTON) {
 
    const xAOD::PhotonContainer* photons = nullptr;
    CHECK(evtStore()->retrieve(photons, m_reco_container_name));
 
    std::pair<xAOD::PhotonContainer*, xAOD::ShallowAuxContainer*> photons_shallowCopy = xAOD::shallowCopyContainer(*photons);
    for (xAOD::Photon* ph : *photons_shallowCopy.first) {
      ATH_MSG_DEBUG("new photon eta: " << ph->eta());
 
      CHECK(do_truth(*ph));
      CHECK(do_egamma(*ph));
 
      if (const auto* vertex = ph->vertex()) {
      m_ph_Rconv = hypot(vertex->position().x(), vertex->position().y());
      }
      else { m_ph_Rconv = 0; }
 
      const auto original = xAOD::EgammaHelpers::conversionType(ph);
      if (original == 3) m_ph_convFlag = 2;
      else if (original != 0) m_ph_convFlag = 1;
      else m_ph_convFlag = original;
 
      for (unsigned int itool = 0; itool != m_EgammaCalibrationAndSmearingTools.size(); ++itool) {
        CHECK(do_energy(*ph, itool));
      }
 
      m_tree->Fill();
 
      if (m_keep_one) break;
    }
  }
 
  return StatusCode::SUCCESS;
}

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase & ExtraDeps )

protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

◆ extraOutputDeps()

const DataObjIDColl & AthAlgorithm::extraOutputDeps ( ) const

overridevirtualinherited

Return the list of extra output dependencies.

This list is extended to include symlinks implied by inheritance relations.

Definition at line 50 of file AthAlgorithm.cxx.

{
  // If we didn't find any symlinks to add, just return the collection
  // from the base class.  Otherwise, return the extended collection.
  if (!m_extendedExtraObjects.empty()) {
    return m_extendedExtraObjects;
  }
  return Algorithm::extraOutputDeps();
}

◆ finalize()

StatusCode DumpAllSystematics::finalize ( )

virtual

Definition at line 182 of file dumpAllSystematics.cxx.

                                        {
  ATH_MSG_INFO("Particle saved: " << m_tree->GetEntries());
  if (m_tree->GetEntries() == 0) ATH_MSG_WARNING("no particle saved");
  ATH_MSG_INFO("Finalizing " << name() << "...");
 
  return StatusCode::SUCCESS;
}

◆ initialize()

StatusCode DumpAllSystematics::initialize ( )

virtual

Definition at line 44 of file dumpAllSystematics.cxx.

{
  // Greet the user:
  ATH_MSG_INFO ("Initializing " << name() << "...");
 
  if (m_particle_name.empty()) {
    ATH_MSG_WARNING("particle property is empty, choose between \"photon\" or \"electron\". Assuming electron.");
    m_particle_name = "electron";
  }
  if (m_particle_name != "electron" and m_particle_name != "photon")
  {
    ATH_MSG_FATAL("cannot understand particle property: must be \"electron\" or \"photon\"");
  }
 
  m_particle_type = m_particle_name == "electron" ? ParticleType::ELECTRON : ParticleType::PHOTON;
 
  // Retrieve the tools:
  ATH_MSG_INFO("retrieving tools");
  if (!m_EgammaCalibrationAndSmearingTools.retrieve().isSuccess())
   { ATH_MSG_ERROR("Cannot retrieve calibration tools"); }
  ATH_MSG_INFO("retrieving tools, done");
 
  if (m_EgammaCalibrationAndSmearingTools.empty()) {
    ATH_MSG_FATAL("no tool specified in the job options");
    return StatusCode::FAILURE;
  }
  ATH_MSG_INFO("number of tools: " << m_EgammaCalibrationAndSmearingTools.size());
  if (m_reco_container_name.empty()) {
    if (m_particle_type == ParticleType::ELECTRON) m_reco_container_name = "Electrons";
    else m_reco_container_name = "Photons";
  }
 
  ATH_MSG_INFO("================================================================================");
  ATH_MSG_INFO("particle: " << m_particle_name);
  ATH_MSG_INFO("keep only one: " << m_keep_one);
  ATH_MSG_INFO("reco container: " << m_reco_container_name);
  ATH_MSG_INFO("================================================================================");
 
 
 
  ATH_MSG_DEBUG("creating tree");
 
  const std::string prefix = m_particle_type == ParticleType::ELECTRON ? "el_" : "ph_";
  m_tree = new TTree("all_sys", "all_sys");
  m_tree->Branch("index", &m_instance_index, "index/I")->SetTitle("index of the particle as in the original dataset");
  m_tree->Branch("actualIntPerXing", &m_actualIntPerXing, "actualIntPerXing/F");
  m_tree->Branch("eventNumber", &m_EventNumber, "eventNumber/I");
  m_tree->Branch("runNumber", &m_RunNumber, "runNumber/I");
  m_tree->Branch((prefix + "truth_E").c_str(), &m_truth_E, (prefix + "truth_E/F").c_str());
  m_tree->Branch((prefix + "truth_eta").c_str(), &m_truth_eta, (prefix + "truth_eta/F").c_str());
  m_tree->Branch((prefix + "truth_pt").c_str(), &m_truth_pt, (prefix + "truth_pt/F").c_str());
  m_tree->Branch((prefix + "truth_phi").c_str(), &m_truth_phi, (prefix + "truth_phi/F").c_str());
  m_tree->Branch((prefix + "truth_pdgId").c_str(), &m_truth_pdgId, (prefix + "truth_pdgId/I").c_str());
  m_tree->Branch((prefix + "truth_parent_pdgId").c_str(), &m_truth_parent_pdgId, (prefix + "truth_parent_pdgId/I").c_str());
  m_tree->Branch((prefix + "truth_matched").c_str(), &m_truth_matched, (prefix + "truth_matched/O").c_str());
  m_tree->Branch((prefix + "cl_eta").c_str(), &m_cl_eta, (prefix + "cl_eta/F").c_str());
  m_tree->Branch((prefix + "cl_etaCalo").c_str(), &m_cl_etaCalo, (prefix + "cl_etaCalo/F").c_str());
  m_tree->Branch((prefix + "cl_phi").c_str(), &m_cl_phi, (prefix + "cl_phi/F").c_str());
  m_tree->Branch((prefix + "cl_rawcl_Es0").c_str(), &m_cl_rawcl_Es0, (prefix + "cl_rawcl_Es0/F").c_str());
  m_tree->Branch((prefix + "cl_rawcl_Es1").c_str(), &m_cl_rawcl_Es1, (prefix + "cl_rawcl_Es1/F").c_str());
  m_tree->Branch((prefix + "cl_rawcl_Es2").c_str(), &m_cl_rawcl_Es2, (prefix + "cl_rawcl_Es2/F").c_str());
  m_tree->Branch((prefix + "cl_rawcl_Es3").c_str(), &m_cl_rawcl_Es3, (prefix + "cl_rawcl_Es3/F").c_str());
  m_tree->Branch((prefix + "cl_E").c_str(), &m_cl_E, (prefix + "cl_E/F").c_str())->SetTitle("original xAOD caloCluster energy");
  m_tree->Branch((prefix + "wstot").c_str(), &m_wstot, (prefix + "wstot/F").c_str());
  if (m_particle_type == ParticleType::PHOTON) {
    m_tree->Branch("ph_truth_isConv", &m_truth_isConv, "ph_truth_isConv/O");
    m_tree->Branch("ph_truth_Rconv", &m_truth_Rconv, "ph_truth_Rconv/F");
    m_tree->Branch("ph_Rconv", &m_ph_Rconv, "ph_Rconv/F");
    m_tree->Branch("ph_convFlag", &m_ph_convFlag, "ph_convFlag/I");
  }
  m_tree->Branch("npv", &m_npv, "npv/I");
 
  m_nominal_E.resize(m_EgammaCalibrationAndSmearingTools.size());
  m_energy_variations.resize(m_EgammaCalibrationAndSmearingTools.size());
  m_energy_variations_sum_up.resize(m_EgammaCalibrationAndSmearingTools.size());
  m_energy_variations_sum_down.resize(m_EgammaCalibrationAndSmearingTools.size());
 
  std::vector<std::vector<std::string> > all_sys_names_per_tool;
  std::set<std::string> all_sys_names;
 
  for (unsigned int itool = 0; itool != m_EgammaCalibrationAndSmearingTools.size(); ++itool) {
    const std::string tool_name = m_EgammaCalibrationAndSmearingTools[itool].name();
    {
      const std::string branch_name = prefix + tool_name + "_nominal_E";
      m_tree->Branch(branch_name.c_str(), &m_nominal_E[itool], (branch_name + "/F").c_str());
    }
 
    const CP::SystematicSet& sys_set = m_EgammaCalibrationAndSmearingTools[itool]->recommendedSystematics();
    ATH_MSG_INFO("size of the systematics set for tool [" << itool << "] " + m_EgammaCalibrationAndSmearingTools[itool].name() << ": " << sys_set.size());
    std::vector<std::string> sys_names; sys_names.reserve(sys_set.size());
    for (const auto& sys : sys_set) { if (sys.parameter() == 1) { sys_names.push_back(sys.name()); all_sys_names.insert(sys.name()); } }
    std::sort(sys_names.begin(), sys_names.end());
    all_sys_names_per_tool.push_back(sys_names);
 
 
    m_energy_variations[itool].resize(sys_set.size());
 
    int isys = 0;
    for (const auto& sys : sys_set) {
      const std::string branch_name = prefix + tool_name + "_ratio_" + sys.name();
      m_tree->Branch(branch_name.c_str(), &m_energy_variations[itool][isys],
                     (branch_name + "/F").c_str());
      ++isys;
    }
 
    m_tree->Branch((prefix + tool_name + "_ratio_SCALE_sum__1up").c_str(), &m_energy_variations_sum_up[itool], (prefix + tool_name +  "_ratio_SCALE_sum__1up/F").c_str());
    m_tree->Branch((prefix + tool_name + "_ratio_SCALE_sum__1down").c_str(), &m_energy_variations_sum_down[itool], (prefix + tool_name +  "_ratio_SCALE_sum__1down/F").c_str());
  }
 
  {
    std::string header = std::string(45, ' ');
    for (unsigned int i = 0; i != m_EgammaCalibrationAndSmearingTools.size(); ++i)  {
      header += std::format(" [{}] ", i);
    }
    ATH_MSG_INFO(header);
  }
  for (auto sysname : all_sys_names) {
    std::string line = std::format("{:>45}", sysname);
    for (const auto& sys_per_tool : all_sys_names_per_tool) {
      if (std::find(sys_per_tool.begin(), sys_per_tool.end(), sysname) != sys_per_tool.end()) line += "  X  ";
      else line += "     ";
    }
    ATH_MSG_INFO(line);
  }
 
  if (m_particle_type == ParticleType::ELECTRON) ATH_MSG_INFO("dumping electrons");
  else if (m_particle_type == ParticleType::PHOTON) ATH_MSG_INFO("dumping photons");
  
  // output configuration
  ServiceHandle<ITHistSvc> histSvc("THistSvc", name());
  CHECK(histSvc.retrieve());
  const std::string tree_stream = "/DATASTREAM";
  CHECK(histSvc->regTree(tree_stream + "/myTree", m_tree));
 
  return StatusCode::SUCCESS;
}

◆ inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Algorithm > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ msg()

MsgStream & AthCommonMsg< Algorithm >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

◆ msgLvl()

bool AthCommonMsg< Algorithm >::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

◆ outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Algorithm > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ renounce()

std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > AthCommonDataStore< AthCommonMsg< Algorithm > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

  {
    h.renounce();
    PBASE::renounce (h);
  }

◆ renounceArray()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::renounceArray ( SG::VarHandleKeyArray & handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

◆ sysInitialize()

StatusCode AthAlgorithm::sysInitialize ( )

overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

Loop through all output handles, and if they're WriteCondHandles, automatically register them and this Algorithm with the CondSvc

Scan through all outputHandles, and if they're WriteCondHandles, register them with the CondSvc

Reimplemented from AthCommonDataStore< AthCommonMsg< Algorithm > >.

Reimplemented in AthAnalysisAlgorithm, AthFilterAlgorithm, AthHistogramAlgorithm, and PyAthena::Alg.

Definition at line 66 of file AthAlgorithm.cxx.

                                       {
  StatusCode sc=AthCommonDataStore<AthCommonMsg<Algorithm>>::sysInitialize();
 
  if (sc.isFailure()) {
    return sc;
  }
  ServiceHandle<ICondSvc> cs("CondSvc",name());
  for (auto h : outputHandles()) {
    if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
      // do this inside the loop so we don't create the CondSvc until needed
      if ( cs.retrieve().isFailure() ) {
        ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
        return StatusCode::SUCCESS;
      }
      if (cs->regHandle(this,*h).isFailure()) {
        sc = StatusCode::FAILURE;
        ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
                      << " with CondSvc");
      }
    }
  }
  return sc;
}

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Algorithm > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

◆ updateVHKA()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::updateVHKA ( Gaudi::Details::PropertyBase & )

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

Member Data Documentation

◆ m_actualIntPerXing

float DumpAllSystematics::m_actualIntPerXing {}

private

Definition at line 53 of file dumpAllSystematics.h.

53{};

◆ m_averageIntPerXing

float DumpAllSystematics::m_averageIntPerXing {}

private

Definition at line 54 of file dumpAllSystematics.h.

54{};

◆ m_cl_E

float DumpAllSystematics::m_cl_E {}

private

Definition at line 73 of file dumpAllSystematics.h.

73{};

◆ m_cl_eta

float DumpAllSystematics::m_cl_eta {}

private

Definition at line 67 of file dumpAllSystematics.h.

67{};

◆ m_cl_etaCalo

float DumpAllSystematics::m_cl_etaCalo {}

private

Definition at line 68 of file dumpAllSystematics.h.

68{};

◆ m_cl_phi

float DumpAllSystematics::m_cl_phi {}

private

Definition at line 66 of file dumpAllSystematics.h.

66{};

◆ m_cl_rawcl_Es0

float DumpAllSystematics::m_cl_rawcl_Es0 {}

private

Definition at line 69 of file dumpAllSystematics.h.

69{};

◆ m_cl_rawcl_Es1

float DumpAllSystematics::m_cl_rawcl_Es1 {}

private

Definition at line 70 of file dumpAllSystematics.h.

70{};

◆ m_cl_rawcl_Es2

float DumpAllSystematics::m_cl_rawcl_Es2 {}

private

Definition at line 71 of file dumpAllSystematics.h.

71{};

◆ m_cl_rawcl_Es3

float DumpAllSystematics::m_cl_rawcl_Es3 {}

private

Definition at line 72 of file dumpAllSystematics.h.

72{};

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_EgammaCalibrationAndSmearingTools

ToolHandleArray<CP::IEgammaCalibrationAndSmearingTool> DumpAllSystematics::m_EgammaCalibrationAndSmearingTools

private

Definition at line 84 of file dumpAllSystematics.h.

◆ m_energy_variations

std::vector<std::vector<float> > DumpAllSystematics::m_energy_variations

private

Definition at line 81 of file dumpAllSystematics.h.

◆ m_energy_variations_sum_down

std::vector<float> DumpAllSystematics::m_energy_variations_sum_down

private

Definition at line 80 of file dumpAllSystematics.h.

◆ m_energy_variations_sum_up

std::vector<float> DumpAllSystematics::m_energy_variations_sum_up

private

Definition at line 79 of file dumpAllSystematics.h.

◆ m_EventNumber

unsigned long long DumpAllSystematics::m_EventNumber {}

private

Definition at line 50 of file dumpAllSystematics.h.

50{};

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_extendedExtraObjects

DataObjIDColl AthAlgorithm::m_extendedExtraObjects

privateinherited

Definition at line 79 of file AthAlgorithm.h.

◆ m_instance_index

int DumpAllSystematics::m_instance_index {}

private

Definition at line 52 of file dumpAllSystematics.h.

52{};

◆ m_keep_one

bool DumpAllSystematics::m_keep_one

Definition at line 34 of file dumpAllSystematics.h.

◆ m_nominal_E

std::vector<float> DumpAllSystematics::m_nominal_E

private

Definition at line 78 of file dumpAllSystematics.h.

◆ m_npv

int DumpAllSystematics::m_npv {}

private

Definition at line 64 of file dumpAllSystematics.h.

64{};

◆ m_particle_name

std::string DumpAllSystematics::m_particle_name

Definition at line 32 of file dumpAllSystematics.h.

◆ m_particle_type

ParticleType DumpAllSystematics::m_particle_type = ParticleType::ELECTRON

private

Definition at line 42 of file dumpAllSystematics.h.

◆ m_ph_convFlag

int DumpAllSystematics::m_ph_convFlag {}

private

Definition at line 75 of file dumpAllSystematics.h.

75{};

◆ m_ph_Rconv

float DumpAllSystematics::m_ph_Rconv {}

private

Definition at line 74 of file dumpAllSystematics.h.

74{};

◆ m_reco_container_name

std::string DumpAllSystematics::m_reco_container_name

Definition at line 33 of file dumpAllSystematics.h.

◆ m_RunNumber

uint32_t DumpAllSystematics::m_RunNumber {}

private

Definition at line 51 of file dumpAllSystematics.h.

51{};

◆ m_tree

TTree* DumpAllSystematics::m_tree {}

private

Definition at line 44 of file dumpAllSystematics.h.

44{};

◆ m_truth_E

float DumpAllSystematics::m_truth_E {}

private

Definition at line 58 of file dumpAllSystematics.h.

58{};

◆ m_truth_eta

float DumpAllSystematics::m_truth_eta {}

private

Definition at line 57 of file dumpAllSystematics.h.

57{};

◆ m_truth_isConv

bool DumpAllSystematics::m_truth_isConv {}

private

Definition at line 62 of file dumpAllSystematics.h.

62{};

◆ m_truth_matched

bool DumpAllSystematics::m_truth_matched {}

private

Definition at line 61 of file dumpAllSystematics.h.

61{};

◆ m_truth_parent_pdgId

int DumpAllSystematics::m_truth_parent_pdgId {}

private

Definition at line 60 of file dumpAllSystematics.h.

60{};

◆ m_truth_pdgId

int DumpAllSystematics::m_truth_pdgId {}

private

Definition at line 59 of file dumpAllSystematics.h.

59{};

◆ m_truth_phi

float DumpAllSystematics::m_truth_phi {}

private

Definition at line 56 of file dumpAllSystematics.h.

56{};

◆ m_truth_pt

float DumpAllSystematics::m_truth_pt {}

private

Definition at line 55 of file dumpAllSystematics.h.

55{};

◆ m_truth_Rconv

float DumpAllSystematics::m_truth_Rconv {}

private

Definition at line 63 of file dumpAllSystematics.h.

63{};

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Algorithm > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< Algorithm > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

◆ m_wstot

float DumpAllSystematics::m_wstot {}

private

Definition at line 76 of file dumpAllSystematics.h.

76{};

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

Public Member Functions

Public Attributes

Protected Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ StoreGateSvc_t

Member Enumeration Documentation

◆ ParticleType

Constructor & Destructor Documentation

◆ DumpAllSystematics()

Member Function Documentation

◆ declareGaudiProperty()

◆ declareProperty()

◆ detStore()

◆ do_egamma()

◆ do_energy()

◆ do_truth()

◆ evtStore()

◆ execute()

◆ extraDeps_update_handler()

◆ extraOutputDeps()

◆ finalize()

◆ initialize()

◆ inputHandles()

◆ msg()

◆ msgLvl()

◆ outputHandles()

◆ renounce()

◆ renounceArray()

◆ sysInitialize()

◆ sysStart()

◆ updateVHKA()

Member Data Documentation

◆ m_actualIntPerXing

◆ m_averageIntPerXing

◆ m_cl_E

◆ m_cl_eta

◆ m_cl_etaCalo

◆ m_cl_phi

◆ m_cl_rawcl_Es0

◆ m_cl_rawcl_Es1

◆ m_cl_rawcl_Es2

◆ m_cl_rawcl_Es3

◆ m_detStore

◆ m_EgammaCalibrationAndSmearingTools

◆ m_energy_variations

◆ m_energy_variations_sum_down

◆ m_energy_variations_sum_up

◆ m_EventNumber

◆ m_evtStore

◆ m_extendedExtraObjects

◆ m_instance_index

◆ m_keep_one

◆ m_nominal_E

◆ m_npv

◆ m_particle_name

◆ m_particle_type

◆ m_ph_convFlag

◆ m_ph_Rconv

◆ m_reco_container_name

◆ m_RunNumber

◆ m_tree

◆ m_truth_E

◆ m_truth_eta

◆ m_truth_isConv

◆ m_truth_matched

◆ m_truth_parent_pdgId

◆ m_truth_pdgId

◆ m_truth_phi

◆ m_truth_pt

◆ m_truth_Rconv

◆ m_varHandleArraysDeclared

◆ m_vhka

◆ m_wstot