GetLCSinglePionsPerf Class Reference

Top algorithm to get local hadronic calibration performance plots for single pions. More...

#include <GetLCSinglePionsPerf.h>

Inheritance diagram for GetLCSinglePionsPerf:

Public Member Functions
	GetLCSinglePionsPerf (const std::string &name, ISvcLocator *pSvcLocator)
virtual	~GetLCSinglePionsPerf ()
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

Static Public Member Functions
static double	angle_mollier_factor (double x)

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	keys_topo { kTOPO_EM , kTOPO_W , kTOPO_OOC , kTOPO }
enum	keys_tagged { kTAGEM , kTAGHAD , kTAGUNK , kTAG }
enum	keys_momsums {   kMOM_CLS0 , kMOM_CLS1 , kMOM_CLS2 , kMOM_SUMCLS ,   kMOM_MISS , kMOM_MCENER }
enum	keys_norm_level { kLEVEL_PARTICLE , kLEVEL_CALIBHIT , kLEVEL_CALIBHIT_IDEAL }
typedef std::pair< std::string, xAOD::CaloCluster::MomentType >	moment_name_pair
typedef std::vector< moment_name_pair >	moment_name_vector
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
int	fill_reco (const xAOD::CaloClusterContainer &clusColl, const EventContext &ctx)
int	fill_moments (const xAOD::CaloClusterContainer &clusColl, const EventContext &ctx)
int	fill_calibhits (const xAOD::CaloClusterContainer &clusColl, const EventContext &ctx)
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
const AtlasDetectorID *	m_id_helper
const CaloCell_ID *	m_calo_id
const CaloDmDescrManager *	m_caloDmDescrManager
SG::ReadHandleKey< xAOD::CaloClusterContainer >	m_clusterBasicCollName
SG::ReadHandleKeyArray< xAOD::CaloClusterContainer >	m_clusterCollNames
std::string	m_outputFileName
TFile *	m_outputFile
SG::ReadHandleKeyArray< CaloCalibrationHitContainer >	m_CalibrationHitContainerNames
SG::ReadHandleKeyArray< CaloCalibrationHitContainer >	m_DMCalibrationHitContainerNames
moment_name_vector	m_validMoments
double	m_distance_cut
int	m_netabin
float	m_etamin
float	m_etamax
float	m_deta
int	m_nphibin
float	m_phimin
float	m_phimax
float	m_dphi
int	m_nlogenerbin
float	m_logenermin
float	m_logenermax
int	m_nlogenerbin2
float	m_dlogener
int	m_nnormtype
int	m_ncluscoll
int	m_ntagcases
int	m_nmoments
int	m_nmomsums
float	m_truthPiEngFraction
bool	m_doEngRecOverTruth
bool	m_doEngTag
bool	m_doEngRecSpect
bool	m_doEngNoiseClus
bool	m_doClusMoments
bool	m_doRecoEfficiency
bool	m_useRecoEfficiency
bool	m_useGoodClus
bool	m_doCalibHitsValidation
bool	m_usePionClusters
std::vector< std::vector< std::vector< TProfile * > > >	m_engRecOverTruth_vs_eta
std::vector< std::vector< std::vector< TProfile * > > >	m_engRecOverTruth_vs_ebeam
std::vector< std::vector< TProfile * > >	m_engTag_vs_eta
std::vector< std::vector< TProfile * > >	m_engTag_vs_ebeam
std::vector< std::vector< std::vector< TH1F * > > >	m_engRecSpect
std::vector< std::vector< TH1F * > >	m_engPionSpect
std::vector< std::vector< TH1F * > >	m_engNoiseClusSpect
std::vector< TProfile * >	m_engNoiseClus_vs_eta
std::vector< std::vector< std::vector< TProfile * > > >	m_clusMoment_vs_eta
std::vector< std::vector< std::vector< TProfile * > > >	m_clusMoment_vs_ebeam
std::vector< TH1F * >	m_RecoEfficiency_vs_eta [2]
std::vector< TH1F * >	m_RecoEfficiency_vs_ebeam [2]
std::vector< TProfile * >	m_SumCalibHitOverEbeam_vs_eta
std::vector< TProfile * >	m_DefaultCalculatorOverEbeam_vs_eta
std::vector< TProfile * >	m_SumCalibHitAssignedOverEbeam_vs_eta
std::vector< TProfile2D * >	m_SumCalibHitAssignedOverEbeam_vs_etaphi
double	m_mc_ener
double	m_mc_eta
double	m_mc_phi
int	m_mc_etabin
int	m_mc_enerbin
int	m_mc_phibin
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

Top algorithm to get local hadronic calibration performance plots for single pions.

Version

$Id: GetLCSinglePionsPerf.h,v 1.1 2009-07-01 14:36:01 pospelov Exp $

Author

Gennady Pospelov guenn.nosp@m.adi..nosp@m.pospe.nosp@m.lov@.nosp@m.cern..nosp@m.ch

Date

1-July-2009

Definition at line 37 of file GetLCSinglePionsPerf.h.

Member Typedef Documentation

moment_name_pair

typedef std::pair<std::string,xAOD::CaloCluster::MomentType> GetLCSinglePionsPerf::moment_name_pair

private

Definition at line 50 of file GetLCSinglePionsPerf.h.

moment_name_vector

typedef std::vector<moment_name_pair> GetLCSinglePionsPerf::moment_name_vector

private

Definition at line 51 of file GetLCSinglePionsPerf.h.

StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Member Enumeration Documentation

keys_momsums

enum GetLCSinglePionsPerf::keys_momsums

private

Enumerator
kMOM_CLS0
kMOM_CLS1
kMOM_CLS2
kMOM_SUMCLS
kMOM_MISS
kMOM_MCENER

Definition at line 55 of file GetLCSinglePionsPerf.h.

{kMOM_CLS0, kMOM_CLS1, kMOM_CLS2, kMOM_SUMCLS, kMOM_MISS, kMOM_MCENER};

keys_norm_level

enum GetLCSinglePionsPerf::keys_norm_level

private

Enumerator
kLEVEL_PARTICLE
kLEVEL_CALIBHIT
kLEVEL_CALIBHIT_IDEAL

Definition at line 56 of file GetLCSinglePionsPerf.h.

{kLEVEL_PARTICLE, kLEVEL_CALIBHIT, kLEVEL_CALIBHIT_IDEAL };

keys_tagged

enum GetLCSinglePionsPerf::keys_tagged

private

Enumerator
kTAGEM
kTAGHAD
kTAGUNK
kTAG

Definition at line 54 of file GetLCSinglePionsPerf.h.

{kTAGEM, kTAGHAD, kTAGUNK, kTAG};

keys_topo

enum GetLCSinglePionsPerf::keys_topo

private

Enumerator
kTOPO_EM
kTOPO_W
kTOPO_OOC
kTOPO

Definition at line 53 of file GetLCSinglePionsPerf.h.

{kTOPO_EM, kTOPO_W, kTOPO_OOC, kTOPO};

Constructor & Destructor Documentation

GetLCSinglePionsPerf()

GetLCSinglePionsPerf::GetLCSinglePionsPerf	(	const std::string &	name,
		ISvcLocator *	pSvcLocator )

Definition at line 59 of file GetLCSinglePionsPerf.cxx.

  : AthAlgorithm(name, pSvcLocator),
    m_id_helper(nullptr),
    m_calo_id(nullptr),
    m_caloDmDescrManager(nullptr),
    m_outputFileName("CheckSinglePionsReco.root"),
    m_outputFile(nullptr),
    m_distance_cut(1.5),
    m_netabin(25), m_etamin(0.0), m_etamax(5.0),
    m_deta(0),
    m_nphibin(1), m_phimin(-M_PI), m_phimax(M_PI),
    m_dphi(0),
    m_nlogenerbin(22), m_logenermin(2.0), m_logenermax(6.4),
    m_nlogenerbin2(3),
    m_dlogener(0),
    m_nnormtype(3),
    m_ncluscoll(4),
    m_ntagcases(3),
    m_nmoments(0),
    m_nmomsums(6),
    m_truthPiEngFraction(0.1),
    m_doEngRecOverTruth(true),
    m_doEngTag(true),
    m_doEngRecSpect(true),
    m_doEngNoiseClus(true),
    m_doClusMoments(true),
    m_doRecoEfficiency(true),
    m_useRecoEfficiency(false),
    m_useGoodClus(false),
    m_doCalibHitsValidation(true),
    m_mc_ener(0),
    m_mc_eta(0),
    m_mc_phi(0),
    m_mc_etabin(0),
    m_mc_enerbin(0),
    m_mc_phibin(0)
{
  // collection name where cluster always have moments
  declareProperty("ClusterBasicCollName",m_clusterBasicCollName);
 
  // collections names after different correction steps
  declareProperty("ClusterCollectionNames",m_clusterCollNames);
 
  // distance cut for clusters to calcuate engReco
  declareProperty("DistanceCut",m_distance_cut);
 
  // Name of output file to save histograms in
  declareProperty("OutputFileName",m_outputFileName);
 
  // Names of CalibrationHitContainers to use
  declareProperty("CalibrationHitContainerNames",m_CalibrationHitContainerNames); 
  declareProperty("DMCalibrationHitContainerNames",m_DMCalibrationHitContainerNames);
 
  // to create different types of validation histograms
  declareProperty("doEngRecOverTruth",m_doEngRecOverTruth);
  declareProperty("doEngTag",m_doEngTag);
  declareProperty("doEngRecSpect",m_doEngRecSpect);
  declareProperty("doEngNoiseClus",m_doEngNoiseClus);
  declareProperty("doClusMoments",m_doClusMoments);
  declareProperty("doRecoEfficiency",m_doRecoEfficiency);
  declareProperty("useRecoEfficiency",m_useRecoEfficiency);
  declareProperty("useGoodClus",m_useGoodClus);
 
  declareProperty("etamin",m_etamin);
  declareProperty("etamax",m_etamax);
  declareProperty("netabin",m_netabin);
 
  declareProperty("phimin",m_phimin);
  declareProperty("phimax",m_phimax);
  declareProperty("nphibin",m_nphibin);
 
  declareProperty("logenermin",m_logenermin);
  declareProperty("logenermax",m_logenermax);
  declareProperty("nlogenerbin",m_nlogenerbin);
 
  declareProperty("doCalibHitsValidation",m_doCalibHitsValidation);
//   Only use clusters that contain at least m_truthPiEngFraction % of the true pion energy
  declareProperty("usePionClustersOnly",m_usePionClusters);
 
  // dead material identifier description manager  
  m_caloDmDescrManager = CaloDmDescrManager::instance();
 
  m_validMoments.resize(0);
  m_validMoments.push_back(moment_name_pair(std::string("ENG_CALIB_TOT"),xAOD::CaloCluster::ENG_CALIB_TOT));
  m_validMoments.push_back(moment_name_pair(std::string("ENG_CALIB_OUT_L"),xAOD::CaloCluster::ENG_CALIB_OUT_L));
  m_validMoments.push_back(moment_name_pair(std::string("ENG_CALIB_DEAD_TOT"),xAOD::CaloCluster::ENG_CALIB_DEAD_TOT));
  m_validMoments.push_back(moment_name_pair(std::string("ENG_CALIB_DEAD_EMB0"),xAOD::CaloCluster::ENG_CALIB_DEAD_EMB0));
  m_validMoments.push_back(moment_name_pair(std::string("ENG_CALIB_DEAD_TILE0"),xAOD::CaloCluster::ENG_CALIB_DEAD_TILE0));
  m_validMoments.push_back(moment_name_pair(std::string("ENG_CALIB_DEAD_TILEG3"),xAOD::CaloCluster::ENG_CALIB_DEAD_TILEG3));
  m_validMoments.push_back(moment_name_pair(std::string("ENG_CALIB_DEAD_EME0"),xAOD::CaloCluster::ENG_CALIB_DEAD_EME0));
  m_validMoments.push_back(moment_name_pair(std::string("ENG_CALIB_DEAD_HEC0"),xAOD::CaloCluster::ENG_CALIB_DEAD_HEC0));
  m_validMoments.push_back(moment_name_pair(std::string("ENG_CALIB_DEAD_FCAL"),xAOD::CaloCluster::ENG_CALIB_DEAD_FCAL));
  m_validMoments.push_back(moment_name_pair(std::string("ENG_CALIB_DEAD_LEAKAGE"),xAOD::CaloCluster::ENG_CALIB_DEAD_LEAKAGE));
  m_validMoments.push_back(moment_name_pair(std::string("ENG_CALIB_DEAD_UNCLASS"),xAOD::CaloCluster::ENG_CALIB_DEAD_UNCLASS));
 
  m_nmoments = m_validMoments.size();
 
}

~GetLCSinglePionsPerf()

GetLCSinglePionsPerf::~GetLCSinglePionsPerf ( )

virtual

Definition at line 163 of file GetLCSinglePionsPerf.cxx.

{
 
}

Member Function Documentation

angle_mollier_factor()

double GetLCSinglePionsPerf::angle_mollier_factor ( double x )

static

Definition at line 1296 of file GetLCSinglePionsPerf.cxx.

{
  double eta = fabs(x);
  double ff;
  if(eta<1.6){
    ff = atan(5.0*1.7/(200.0*cosh(eta)));
  }else if(eta<3.2){
    ff = atan(5.0*1.6/(420./tanh(eta)));
  }else{
    ff = atan(5.0*0.95/(505./tanh(eta)));
  }
  return ff*(1./atan(5.0*1.7/200.0));
}

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.

{ return m_detStore; }

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.

{ return m_evtStore; }

execute()

StatusCode GetLCSinglePionsPerf::execute ( )

virtual

Definition at line 654 of file GetLCSinglePionsPerf.cxx.

{
  const EventContext& ctx = getContext();
 
  /* ********************************************
  reading particles
  ******************************************** */
  const McEventCollection* truthEvent=nullptr;
  ATH_CHECK( evtStore()->retrieve(truthEvent, "TruthEvent") );
 
  if( truthEvent->at(0)->particles_empty() ){
    ATH_MSG_ERROR( "No particles in McEventCollection" );
    return StatusCode::FAILURE;
  }
  HepMC::ConstGenParticlePtr gen{nullptr};
  for (auto p: *truthEvent->at(0)) {
    if (MC::isGenStable(p)) {
      if (std::abs(p->pdg_id()) == MC::PIPLUS ||
          std::abs(p->pdg_id()) == MC::PI0) {
        gen = std::move(p);
        break;
      }
    }
  }
  if(!gen){
     ATH_MSG_ERROR( "No final stable pion in McEventCollection" );
     return StatusCode::FAILURE;
  }
  m_mc_eta = gen->momentum().pseudoRapidity();
  m_mc_phi = gen->momentum().phi();
  m_mc_ener = gen->momentum().e();
 
  // energy and eta bins for particle
  m_mc_enerbin = int( (log10(m_mc_ener) - m_logenermin)/m_dlogener);
  m_mc_etabin = int((fabs(m_mc_eta)-m_etamin)/m_deta);
  m_mc_phibin = int((m_mc_phi-m_phimin)/m_dphi);
 
  if(m_mc_etabin <0 || m_mc_etabin >= m_netabin || m_mc_enerbin <0 || m_mc_enerbin >= m_nlogenerbin || m_mc_phibin !=0) return StatusCode::SUCCESS;
 
  SG::ReadHandle<xAOD::CaloClusterContainer> clusColl (m_clusterBasicCollName, ctx);
  if(clusColl->empty())  {
    ATH_MSG_WARNING( "Empty ClusterContainer "  <<  m_clusterBasicCollName  );
    return StatusCode::SUCCESS;
  }
 
  // check that we have at least one meaningfull cluster
  if(m_doRecoEfficiency) {
    bool PionWasReconstructed = false;
    float engClusCalibThs = 1.0*MeV;
    HepLorentzVector hlv_pion(1,0,0,1);
    hlv_pion.setREtaPhi(1./cosh(m_mc_eta),m_mc_eta,m_mc_phi);
    for (const xAOD::CaloCluster* theCluster : *clusColl) {
      double mx_calib_tot;
      if( !theCluster->retrieveMoment( xAOD::CaloCluster::ENG_CALIB_TOT, mx_calib_tot) ) {
        ATH_MSG_ERROR( "Moment ENG_CALIB_TOT is absent"   );
      }
      double mx_dens, mx_center_lambda;
      if (!theCluster->retrieveMoment(xAOD::CaloCluster::CENTER_LAMBDA, mx_center_lambda))
        mx_center_lambda = 0;
      if (!theCluster->retrieveMoment(xAOD::CaloCluster::FIRST_ENG_DENS, mx_dens))
        mx_dens = 0;
 
      HepLorentzVector hlv_cls(1,0,0,1);
      hlv_cls.setREtaPhi(1./cosh(theCluster->eta()), theCluster->eta(), theCluster->phi());
      double r = hlv_pion.angle(hlv_cls.vect());
      if(r < m_distance_cut*angle_mollier_factor(m_mc_eta) 
        && mx_calib_tot > engClusCalibThs
        && theCluster->size() > 1
        && mx_dens > 0
        && mx_center_lambda != 0.0 ) {
        PionWasReconstructed = true;
        break;
      }
    }
    if(PionWasReconstructed){
      m_RecoEfficiency_vs_ebeam[0][m_mc_etabin]->Fill(m_mc_ener);
      m_RecoEfficiency_vs_eta[0][m_mc_enerbin]->Fill(m_mc_eta);
    }
    m_RecoEfficiency_vs_ebeam[1][m_mc_etabin]->Fill(m_mc_ener);
    m_RecoEfficiency_vs_eta[1][m_mc_enerbin]->Fill(m_mc_eta);
    if(m_useRecoEfficiency && !PionWasReconstructed) return StatusCode::SUCCESS;
  }
 
  if(m_doEngRecSpect) {
    m_engPionSpect[m_mc_enerbin][m_mc_etabin]->Fill(m_mc_ener);
  }
 
  if(m_doEngRecOverTruth || m_doEngTag || m_doEngRecSpect || m_doEngNoiseClus){
    fill_reco (*clusColl, ctx);
  }
 
  if(m_doClusMoments) {
    fill_moments (*clusColl, ctx);
  }
 
  if(m_doCalibHitsValidation) {
    fill_calibhits (*clusColl, ctx);
  }
 
  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();
}

fill_calibhits()

int GetLCSinglePionsPerf::fill_calibhits ( const xAOD::CaloClusterContainer & clusColl, const EventContext & ctx )

private

Definition at line 1175 of file GetLCSinglePionsPerf.cxx.

{
  /* ********************************************
  reading calibration containers
  ******************************************** */
  std::vector<const CaloCalibrationHitContainer *> v_cchc;
  for (const SG::ReadHandleKey<CaloCalibrationHitContainer>& k : m_CalibrationHitContainerNames) {
    SG::ReadHandle<CaloCalibrationHitContainer> cchc (k, ctx);
    v_cchc.push_back(cchc.cptr());
  }
 
  std::vector<const CaloCalibrationHitContainer *> v_dmcchc;
  for (const SG::ReadHandleKey<CaloCalibrationHitContainer>& k : m_DMCalibrationHitContainerNames) {
    SG::ReadHandle<CaloCalibrationHitContainer> cchc (k, ctx);
    v_dmcchc.push_back(cchc.cptr());
  }
 
  // calculate total calibration energy int active+inactive hits
  double engCalibTot = 0.0;
  for (const CaloCalibrationHitContainer* cchc : v_cchc) {
    //loop over cells in calibration container
    for (const CaloCalibrationHit* hit : *cchc) {
      Identifier myId = hit->cellID();
      if(!myId.is_valid()) {
        ATH_MSG_ERROR("Error! Bad identifier " << myId << " in container '" << cchc->Name() << "',"
        << " AtlasDetectorID says '" << m_id_helper->show_to_string(myId) << "'");
        continue;
      }
      if(!m_id_helper->is_lar(myId) && !m_id_helper->is_tile(myId)) {
        ATH_MSG_ERROR("Error! Bad identifier (nor lar or tile) " << myId << " in container '" << cchc->Name() << "',"
        << " AtlasDetectorID says '" << m_id_helper->show_to_string(myId) << "'");
        continue;
      }
      engCalibTot += hit->energyTotal();
    }
  }
 
  // calibration energy in dead material
  double engCalibDeadTot = 0.0;
  double engDefaultCalculator = 0.0;
  for (const CaloCalibrationHitContainer* dmcchc : v_dmcchc) {
    //loop over cells in calibration container
    for (const CaloCalibrationHit* hit : *dmcchc) {
      Identifier myId = hit->cellID();
      if(!myId.is_valid()) {
        ATH_MSG_ERROR("GetLCSinglePionsPerf::fill_moments() -> Error! Bad dead material identifier " << myId << " in container '" << dmcchc->Name() << "',"
        << " AtlasDetectorID says '" << m_id_helper->show_to_string(myId) << "'");
        continue;
      }
      if(!m_id_helper->is_lar_dm(myId) && !m_id_helper->is_tile_dm(myId)) {
        ATH_MSG_ERROR("GetLCSinglePionsPerf::fill_moments() -> Error! Bad dead material identifier (nor lar_dm or tile_dm) " << myId << " in container '" << dmcchc->Name() << "',"
        << " AtlasDetectorID says '" << m_id_helper->show_to_string(myId) << "'");
        continue;
      }
      engCalibDeadTot += hit->energyTotal();
      //
      CaloDmDescrElement* myCDDE(nullptr);
      myCDDE = m_caloDmDescrManager->get_element(myId);
      if( !myCDDE ) {
        ATH_MSG_ERROR("GetLCSinglePionsPerf::fill_moments() -> Error! Absent DM description element!");
        continue;
      }
      int nDmArea = m_caloDmDescrManager->get_dm_area(myId);
      if(nDmArea == CaloDmDescrArea::DMA_DEFCALC)  engDefaultCalculator += hit->energyTotal();
    }
  }
 
  // calibration energy assigned to one or another cluster
  // retrieving cluster moments
  double engCalibAssigned = 0.0;
  double engClusSumCalibPresOnly = 0.0;
  for (const xAOD::CaloCluster* theCluster : clusColl) {
    double mx_calib_tot, mx_calib_ooc, mx_calib_dm;
//     if( !theCluster->retrieveMoment(xAOD::CaloCluster::ENG_CALIB_TOT, mx_calib_tot)
//          || !theCluster->retrieveMoment(xAOD::CaloCluster::ENG_CALIB_OUT_L, mx_calib_ooc)
//          || !theCluster->retrieveMoment(xAOD::CaloCluster::ENG_CALIB_DEAD_TOT mx_calib_dm)){
//       ATH_MSG_ERROR("One of the moment ENG_CALIB_TOT, ENG_CALIB_OUT_L, ENG_CALIB_DEAD_TOT is absent");
//     }
    if( !theCluster->retrieveMoment(xAOD::CaloCluster::ENG_CALIB_TOT, mx_calib_tot) ){
      ATH_MSG_WARNING("Moment ENG_CALIB_TOT is absent");
    }
    if( !theCluster->retrieveMoment(xAOD::CaloCluster::ENG_CALIB_OUT_L, mx_calib_ooc) ){
      ATH_MSG_WARNING("Moment ENG_CALIB_OUT_L is absent" );
    }
    if( !theCluster->retrieveMoment(xAOD::CaloCluster::ENG_CALIB_DEAD_TOT, mx_calib_dm) ){
      ATH_MSG_WARNING("Moment ENG_CALIB_DEAD_TOT is absent");
    }
    engCalibAssigned += (mx_calib_tot + mx_calib_ooc + mx_calib_dm);
 
    double mx_calib_emb0, mx_calib_eme0, mx_calib_tileg3;
    if( !theCluster->retrieveMoment(xAOD::CaloCluster::ENG_CALIB_EMB0, mx_calib_emb0)
         || !theCluster->retrieveMoment(xAOD::CaloCluster::ENG_CALIB_EME0, mx_calib_eme0)
         || !theCluster->retrieveMoment(xAOD::CaloCluster::ENG_CALIB_TILEG3, mx_calib_tileg3)){
      ATH_MSG_WARNING("One of the moment ENG_CALIB_EMB0, ENG_CALIB_EME0, ENG_CALIB_TILEG3 is absent");
    }else{
      engClusSumCalibPresOnly += (mx_calib_emb0+mx_calib_eme0+mx_calib_tileg3);
    }
 
  } // iClus
  // energy in presamplers is included already in the dead material
  engCalibAssigned -= engClusSumCalibPresOnly;
 
  int n_enerbin = int( (log10(m_mc_ener) - m_logenermin)/ ((m_logenermax - m_logenermin)/m_nlogenerbin2));
  // sum of moments assigned to clusters wrt total sum of moment
  m_SumCalibHitOverEbeam_vs_eta[n_enerbin]->Fill(m_mc_eta, (engCalibTot+engCalibDeadTot)/m_mc_ener);
//   m_SumCalibHitOverEbeam_vs_ebeam[m_mc_etabin]->Fill(m_mc_ener, (engCalibTot+engCalibDeadTot)/m_mc_ener);
  m_SumCalibHitAssignedOverEbeam_vs_eta[n_enerbin]->Fill(m_mc_eta, engCalibAssigned/m_mc_ener);
  m_SumCalibHitAssignedOverEbeam_vs_etaphi[n_enerbin]->Fill(m_mc_eta, m_mc_phi, engCalibAssigned/m_mc_ener);
 
  m_DefaultCalculatorOverEbeam_vs_eta[n_enerbin]->Fill(m_mc_eta, engDefaultCalculator/m_mc_ener);
//   m_DefaultCalculatorOverEbeam_vs_ebeam[m_mc_etabin]->Fill(m_mc_ener, engDefaultCalculator/m_mc_ener);
 
  return 0;
}

fill_moments()

int GetLCSinglePionsPerf::fill_moments ( const xAOD::CaloClusterContainer & clusColl, const EventContext & ctx )

private

Definition at line 952 of file GetLCSinglePionsPerf.cxx.

{
  ATH_MSG_DEBUG("GetLCSinglePionsPerf::fill_moments got cont. size: "<<clusColl.size()); 
  /* ********************************************
  reading calibration containers
  ******************************************** */
  std::vector<const CaloCalibrationHitContainer *> v_cchc;
  for (const SG::ReadHandleKey<CaloCalibrationHitContainer>& k : m_CalibrationHitContainerNames) {
    SG::ReadHandle<CaloCalibrationHitContainer> cchc (k, ctx);
    v_cchc.push_back(cchc.cptr());
  }
 
  std::vector<const CaloCalibrationHitContainer *> v_dmcchc;
  for (const SG::ReadHandleKey<CaloCalibrationHitContainer>& k : m_DMCalibrationHitContainerNames) {
    SG::ReadHandle<CaloCalibrationHitContainer> cchc (k, ctx);
    v_dmcchc.push_back(cchc.cptr());
  }
 
  // calculate total calibration energy int active+inactive hits
  double engCalibTot = 0.0;
  std::vector<double > engCalibTotSmp;
  engCalibTotSmp.resize(CaloSampling::Unknown, 0.0);
  for (const CaloCalibrationHitContainer* cchc : v_cchc) {
    //loop over cells in calibration container
    for (const CaloCalibrationHit* hit : *cchc) {
      Identifier myId = hit->cellID();
      if(!myId.is_valid()) {
        ATH_MSG_WARNING("Error! Bad identifier " << myId << " in container '" << cchc->Name() << "',"
        << " AtlasDetectorID says '" << m_id_helper->show_to_string(myId) << "'");
        continue;
      }
      if(!m_id_helper->is_lar(myId) && !m_id_helper->is_tile(myId)) {
        ATH_MSG_WARNING("Error! Bad identifier (nor lar or tile) " << myId << " in container '" << cchc->Name() << "',"
        << " AtlasDetectorID says '" << m_id_helper->show_to_string(myId) << "'");
        continue;
      }
 
      CaloSampling::CaloSample nsmp = CaloSampling::CaloSample(m_calo_id->calo_sample(myId));
      engCalibTot += hit->energyTotal();
      engCalibTotSmp[nsmp] += hit->energyTotal();
    }
  }
 
 
  double engCalibDeadTot = 0.0;
  std::vector<double > engCalibDeadTotInArea;
  engCalibDeadTotInArea.resize(CaloDmDescrArea::DMA_MAX,0.0);
  for (const CaloCalibrationHitContainer* dmcchc : v_dmcchc) {
    //loop over cells in calibration container
    for (const CaloCalibrationHit* hit : *dmcchc) {
      Identifier myId = hit->cellID();
      if(!myId.is_valid()) {
        ATH_MSG_ERROR("GetLCSinglePionsPerf::fill_moments() -> Error! Bad dead material identifier " << myId << " in container '" << dmcchc->Name() << "',"
        << " AtlasDetectorID says '" << m_id_helper->show_to_string(myId) << "'");
        continue;
      }
      if(!m_id_helper->is_lar_dm(myId) && !m_id_helper->is_tile_dm(myId)) {
        ATH_MSG_ERROR("GetLCSinglePionsPerf::fill_moments() -> Error! Bad dead material identifier (nor lar_dm or tile_dm) " << myId << " in container '" << dmcchc->Name() << "',"
        << " AtlasDetectorID says '" << m_id_helper->show_to_string(myId) << "'");
        continue;
      }
      engCalibDeadTot += hit->energyTotal();
      //
      CaloDmDescrElement* myCDDE(nullptr);
      myCDDE = m_caloDmDescrManager->get_element(myId);
      if( !myCDDE ) {
        ATH_MSG_ERROR("GetLCSinglePionsPerf::fill_moments() -> Error! Absent DM description element!");
        continue;
      }
      int nDmArea = m_caloDmDescrManager->get_dm_area(myId);
      engCalibDeadTotInArea[nDmArea] += hit->energyTotal();
      engCalibDeadTotInArea[CaloDmDescrArea::DMA_ALL] += hit->energyTotal();
    }
  }
//   double engCalibDeadTotWithPres = engCalibDeadTot + engCalibTotSmp[CaloSampling::PreSamplerB]
//         + engCalibTotSmp[CaloSampling::PreSamplerE]
//         + engCalibTotSmp[CaloSampling::TileGap3];
 
  /* ********************************************
  reading clusters moments
  ******************************************** */
  double  engClusSumCalib(0);
  double  engClusSumCalibPresOnly(0);
  std::vector<std::vector<double > > clsMoments; // [iClus][m_nmoments]
  clsMoments.resize(clusColl.size());
  std::vector<double > clsMomentsSum; // [m_nmoments]
  clsMomentsSum.resize(m_nmoments,0.0);
 
  // retrieving cluster moments
  unsigned int iClus = -1;
  for (const xAOD::CaloCluster* theCluster : clusColl) {
    ++iClus;
    clsMoments[iClus].resize(m_validMoments.size(),0.0);
    int iMoment=0;
    for(moment_name_vector::const_iterator im=m_validMoments.begin(); im!=m_validMoments.end(); ++im, ++iMoment){
      double mx;
      if( theCluster->retrieveMoment((*im).second, mx) ) {
        clsMoments[iClus][iMoment] = mx;
      }else{
        ATH_MSG_ERROR("GetLCSinglePionsPerf::fill_moments() -> Error! Can't retrieve moment " << (*im).first << " " << (*im).second);
      }
      clsMomentsSum[iMoment] += clsMoments[iClus][iMoment];
    }
    double mx;
    if(theCluster->retrieveMoment( xAOD::CaloCluster::ENG_CALIB_TOT, mx ) ){
      engClusSumCalib += mx;
    }else{
      ATH_MSG_ERROR("GetLCSinglePionsPerf::fill_moments() -> Error! Can't retrieve moment xAOD::CaloCluster::ENG_CALIB_TOT ");
    }
    double mx_calib_emb0, mx_calib_eme0, mx_calib_tileg3;
    if( !theCluster->retrieveMoment(xAOD::CaloCluster::ENG_CALIB_EMB0, mx_calib_emb0)
         || !theCluster->retrieveMoment(xAOD::CaloCluster::ENG_CALIB_EME0, mx_calib_eme0)
         || !theCluster->retrieveMoment(xAOD::CaloCluster::ENG_CALIB_TILEG3, mx_calib_tileg3)){
      ATH_MSG_WARNING("One of the moment ENG_CALIB_EMB0, ENG_CALIB_EME0, ENG_CALIB_TILEG3 is absent");
    }else{
      engClusSumCalibPresOnly += (mx_calib_emb0+mx_calib_eme0+mx_calib_tileg3);
    }
  } // iClus
 
  double engCalibDeadTotWithPres = engCalibDeadTot + engClusSumCalibPresOnly;
 
  // DM energy before barrel presampler, inside it, and between presampler and strips
  double eng_calib_dead_emb0 = engCalibDeadTotInArea[CaloDmDescrArea::DMA_EMB0]
        + engCalibDeadTotInArea[CaloDmDescrArea::DMA_EMB1]
        + engCalibTotSmp[CaloSampling::PreSamplerB];
  // DM energy between barrel and tile
  double eng_calib_dead_tile0 = engCalibDeadTotInArea[CaloDmDescrArea::DMA_EMB3_TILE0];
  // DM energy before scintillator and inside scintillator
  double eng_calib_dead_tileg3 = engCalibDeadTotInArea[CaloDmDescrArea::DMA_SCN]
        + engCalibTotSmp[CaloSampling::TileGap3];
  // DM energy beforee endcap presampler, inside it and between presampler and strips
  double eng_calib_dead_eme0 = engCalibDeadTotInArea[CaloDmDescrArea::DMA_EME0]
        + engCalibDeadTotInArea[CaloDmDescrArea::DMA_EME12]
        + engCalibTotSmp[CaloSampling::PreSamplerE];
  // DM energy between emec and hec
  double eng_calib_dead_hec0 = engCalibDeadTotInArea[CaloDmDescrArea::DMA_EME3_HEC0];
  // DM energy before FCAL and between HEC and FCAL
  double eng_calib_dead_fcal = engCalibDeadTotInArea[CaloDmDescrArea::DMA_FCAL0]
        + engCalibDeadTotInArea[CaloDmDescrArea::DMA_HEC_FCAL];
  // DM leakage behind the calorimeter
  double eng_calib_dead_leakage = engCalibDeadTotInArea[CaloDmDescrArea::DMA_LEAK];
  // the rest of DM energy which remains unclassified
  double eng_calib_dead_unclass = engCalibDeadTotWithPres - eng_calib_dead_emb0 - eng_calib_dead_tile0
        - eng_calib_dead_tileg3 - eng_calib_dead_eme0 - eng_calib_dead_hec0 - eng_calib_dead_fcal
        - eng_calib_dead_leakage;
 
  // filling histograms
  int iMoment=0;
  for(moment_name_vector::const_iterator im=m_validMoments.begin(); im!=m_validMoments.end(); ++im, ++iMoment){
    double xnorm = 0.0;
    switch ( (*im).second ) {
      case xAOD::CaloCluster::ENG_CALIB_TOT:
        xnorm = clsMomentsSum[iMoment];
        break;
      case xAOD::CaloCluster::ENG_CALIB_OUT_T:
        xnorm = engCalibTot - engClusSumCalib;
        break;
      case xAOD::CaloCluster::ENG_CALIB_OUT_L:
        xnorm = engCalibTot - engClusSumCalib;
        break;
      case xAOD::CaloCluster::ENG_CALIB_OUT_M:
        xnorm = engCalibTot - engClusSumCalib;
        break;
      case xAOD::CaloCluster::ENG_CALIB_DEAD_TOT:
        xnorm = engCalibDeadTotWithPres;
        break;
      case xAOD::CaloCluster::ENG_CALIB_DEAD_EMB0:
        xnorm = eng_calib_dead_emb0;
        break;
      case xAOD::CaloCluster::ENG_CALIB_DEAD_TILE0:
        xnorm = eng_calib_dead_tile0;
        break;
      case xAOD::CaloCluster::ENG_CALIB_DEAD_TILEG3:
        xnorm = eng_calib_dead_tileg3;
        break;
      case xAOD::CaloCluster::ENG_CALIB_DEAD_EME0:
        xnorm = eng_calib_dead_eme0;
        break;
      case xAOD::CaloCluster::ENG_CALIB_DEAD_HEC0:
        xnorm = eng_calib_dead_hec0;
        break;
      case xAOD::CaloCluster::ENG_CALIB_DEAD_FCAL:
        xnorm = eng_calib_dead_fcal;
        break;
      case xAOD::CaloCluster::ENG_CALIB_DEAD_LEAKAGE:
        xnorm = eng_calib_dead_leakage;
        break;
      case xAOD::CaloCluster::ENG_CALIB_DEAD_UNCLASS:
        xnorm = eng_calib_dead_unclass;
        break;
      default:
        ATH_MSG_ERROR("GetLCSinglePionsPerf::fill_moments() -> Error! Not implemented for " << (*im).first << " " << (*im).second);
        break;
    }
    if(m_doClusMoments && xnorm > m_mc_ener*0.0001 && xnorm > 0) {
      // moments assigned to first 3 maximum clusters
      const double inv_xnorm = 1. / xnorm;
      for(unsigned int i_cls=0; i_cls<clusColl.size(); i_cls++){
        m_clusMoment_vs_eta[iMoment][i_cls][m_mc_enerbin]->Fill(m_mc_eta, clsMoments[i_cls][iMoment]*inv_xnorm);
        m_clusMoment_vs_ebeam[iMoment][i_cls][m_mc_etabin]->Fill(m_mc_ener, clsMoments[i_cls][iMoment]*inv_xnorm);
      if(i_cls>=2) break;
      }
      // sum of moments assigned to clusters wrt total sum of moment
      m_clusMoment_vs_eta[iMoment][kMOM_SUMCLS][m_mc_enerbin]->Fill(m_mc_eta, clsMomentsSum[iMoment]/xnorm);
      m_clusMoment_vs_ebeam[iMoment][kMOM_SUMCLS][m_mc_etabin]->Fill(m_mc_ener, clsMomentsSum[iMoment]/xnorm);
      // unassigned energy wrt pion energy
      m_clusMoment_vs_eta[iMoment][kMOM_MISS][m_mc_enerbin]->Fill(m_mc_eta, (xnorm-clsMomentsSum[iMoment])/m_mc_ener);
      m_clusMoment_vs_ebeam[iMoment][kMOM_MISS][m_mc_etabin]->Fill(m_mc_ener, (xnorm-clsMomentsSum[iMoment])/m_mc_ener);
      // unassigned energy wrt pion energy
      m_clusMoment_vs_eta[iMoment][kMOM_MCENER][m_mc_enerbin]->Fill(m_mc_eta, xnorm/m_mc_ener);
      m_clusMoment_vs_ebeam[iMoment][kMOM_MCENER][m_mc_etabin]->Fill(m_mc_ener, xnorm/m_mc_ener);
    }
  } // i_mom
 
  return 0;
}

fill_reco()

int GetLCSinglePionsPerf::fill_reco ( const xAOD::CaloClusterContainer & clusColl, const EventContext & ctx )

private

Definition at line 763 of file GetLCSinglePionsPerf.cxx.

{
  /* ********************************************
  reading cluster collections for each calibration level
  ******************************************** */
  std::vector<const xAOD::CaloClusterContainer *> clusCollVector;
  for (const SG::ReadHandleKey<xAOD::CaloClusterContainer> & k : m_clusterCollNames) {
    SG::ReadHandle<xAOD::CaloClusterContainer> pColl (k, ctx);
    clusCollVector.push_back(pColl.cptr());
  }
 
  HepLorentzVector hlv_pion(1,0,0,1);
  hlv_pion.setREtaPhi(1./cosh(m_mc_eta),m_mc_eta,m_mc_phi);
 
  std::vector<double > engClusSum; // for 4 collections
  engClusSum.resize(m_ncluscoll, 0.0);
  std::vector<double > engClusSumPresOnly; // for 4 collections
  engClusSumPresOnly.resize(m_ncluscoll, 0.0);
 
  double  engClusSumCalib(0);
  double  engClusSumCalibPresOnly(0);
  double  engClusSumTrueOOC(0);
  double  engClusSumTrueDM(0);
  std::vector<double> engClusSumCalibTagged;
  engClusSumCalibTagged.resize(m_ntagcases, 0.0);
 
  int nGoodClus = 0;
  unsigned int iClus = -1;
  for (const xAOD::CaloCluster* theCluster : clusColl) {
    ++iClus;
    double mx_calib_tot;
    if( !theCluster->retrieveMoment( xAOD::CaloCluster::ENG_CALIB_TOT, mx_calib_tot) ) {
      ATH_MSG_ERROR( "Moment ENG_CALIB_TOT is absent"   );
    }
    double mx_calib_emb0 = 0;
    double mx_calib_eme0 = 0;
    double mx_calib_tileg3 = 0;
    if( !theCluster->retrieveMoment(xAOD::CaloCluster::ENG_CALIB_EMB0, mx_calib_emb0)
         || !theCluster->retrieveMoment(xAOD::CaloCluster::ENG_CALIB_EME0, mx_calib_eme0)
         || !theCluster->retrieveMoment(xAOD::CaloCluster::ENG_CALIB_TILEG3, mx_calib_tileg3)){
      ATH_MSG_ERROR( "One of the moment ENG_CALIB_EMB0, ENG_CALIB_EME0, ENG_CALIB_TILEG3 is absent"   );
    }
    double mx_calib_out = 0;
    double mx_calib_dead_tot = 0;
    if( !theCluster->retrieveMoment(xAOD::CaloCluster::ENG_CALIB_OUT_L, mx_calib_out)
        || !theCluster->retrieveMoment(xAOD::CaloCluster::ENG_CALIB_DEAD_TOT, mx_calib_dead_tot) ){
      ATH_MSG_ERROR( "One of the moment ENG_CALIB_OUT_L, ENG_CALIB_DEAD_TOT is absent"   );
    }
 
    double mx_dens, mx_center_lambda;
    if (!theCluster->retrieveMoment(xAOD::CaloCluster::CENTER_LAMBDA, mx_center_lambda))
      mx_center_lambda = 0;
    if (!theCluster->retrieveMoment(xAOD::CaloCluster::FIRST_ENG_DENS, mx_dens))
      mx_dens = 0;
    
    bool clusIsGood(true);//Fabian
    if(m_useGoodClus){ 
      if(theCluster->size() <= 1 || mx_dens <=0 || mx_center_lambda ==0 || ( m_usePionClusters && mx_calib_tot <= m_truthPiEngFraction * m_mc_ener )) {
        clusIsGood = false;
      }
    }
 
    HepLorentzVector hlv_cls(1,0,0,1);
    hlv_cls.setREtaPhi(1./cosh(theCluster->eta()), theCluster->eta(), theCluster->phi());
    double r = hlv_pion.angle(hlv_cls.vect());
 
    if((!m_usePionClusters && r < m_distance_cut*angle_mollier_factor(m_mc_eta)) ||
       ( ( m_usePionClusters && r < m_distance_cut*angle_mollier_factor(m_mc_eta)) && clusIsGood ) ) {
 
      theCluster = clusCollVector[kTOPO]->at(iClus); // this collection has RecoStatus
      CaloRecoStatus recoStatus = theCluster->recoStatus();
 
      if(recoStatus.checkStatus(CaloRecoStatus::TAGGEDEM) ) {
        engClusSumCalibTagged[kTAGEM] += mx_calib_tot;
      }else if(recoStatus.checkStatus(CaloRecoStatus::TAGGEDHAD) ) {
        engClusSumCalibTagged[kTAGHAD] += mx_calib_tot;
      }else if(recoStatus.checkStatus(CaloRecoStatus::TAGGEDUNKNOWN) ) {
        engClusSumCalibTagged[kTAGUNK] += mx_calib_tot;
      }else{
        ATH_MSG_ERROR("CheckSinglePionsReco::execute() -> Error! Unkown classification status " << recoStatus.getStatusWord());
      }
 
      if(clusIsGood){
        nGoodClus++;
        engClusSumCalib += mx_calib_tot;
        engClusSumCalibPresOnly += (mx_calib_emb0+mx_calib_eme0+mx_calib_tileg3);
        engClusSumTrueOOC += mx_calib_out;
        engClusSumTrueDM += mx_calib_dead_tot;
        for(int i_coll=0; i_coll<m_ncluscoll; i_coll++){
          theCluster = clusCollVector[i_coll]->at(iClus);
          engClusSum[i_coll] += theCluster->e();
          engClusSumPresOnly[i_coll] += (theCluster->eSample(CaloSampling::PreSamplerB)+theCluster->eSample(CaloSampling::PreSamplerE)+theCluster->eSample(CaloSampling::TileGap3));
        }
      }
 
    }else{
      if(m_doEngNoiseClus){
        // to save noise clusters
        for(int i_coll=0; i_coll<m_ncluscoll; i_coll++){
          theCluster = clusCollVector[i_coll]->at(iClus);
          m_engNoiseClusSpect[i_coll][m_mc_etabin]->Fill(theCluster->e());
          m_engNoiseClus_vs_eta[i_coll]->Fill(theCluster->eta(), theCluster->e());
        }
      } // m_doEngNoiseClus
    } // r
    // xxx
  } // iclus
 
  if(nGoodClus == 0) return 0;
 
  /* ********************************************
  filling histograms for ereco over truth after each step of calibration
  ******************************************** */
  if(m_doEngRecOverTruth){
    for(int i_coll=0; i_coll<m_ncluscoll; i_coll++) {
      // with respect to the initial pion energy
      int i_norm = 0;
      double enom = engClusSum[i_coll];
      if(i_coll != kTOPO) {
        enom = enom - engClusSumPresOnly[i_coll];
      }
      if(m_mc_ener != 0.0) {
        m_engRecOverTruth_vs_eta[i_coll][i_norm][m_mc_enerbin]->Fill(m_mc_eta, enom/m_mc_ener);
        m_engRecOverTruth_vs_ebeam[i_coll][i_norm][m_mc_etabin]->Fill(m_mc_ener, enom/m_mc_ener);
      }
      // with respect to the calibration level
      i_norm = 1;
      double edenom = engClusSumCalib - engClusSumCalibPresOnly; // for em or had
      if(i_coll == kTOPO_OOC){ // ooc
        edenom += engClusSumTrueOOC;
      }else if(i_coll == kTOPO){ // dm
        edenom += (engClusSumTrueOOC + engClusSumTrueDM);
      }
      if(edenom != 0.0) {
        m_engRecOverTruth_vs_eta[i_coll][i_norm][m_mc_enerbin]->Fill(m_mc_eta, enom/edenom);
        m_engRecOverTruth_vs_ebeam[i_coll][i_norm][m_mc_etabin]->Fill(m_mc_ener, enom/edenom);
      }
      // with respect to the calibration level with "ideal" previous step
      i_norm = 2;
      enom = engClusSum[i_coll] - engClusSumPresOnly[i_coll];
      if(i_coll == kTOPO_OOC){ // ooc
        double engClusSumRecoOOC = engClusSum[kTOPO_OOC] - engClusSum[kTOPO_W];
        enom = engClusSumCalib - engClusSumCalibPresOnly + engClusSumRecoOOC;
      }else if(i_coll == kTOPO){ // dm
        double engClusSumRecoDM = engClusSum[kTOPO] - (engClusSum[kTOPO_OOC]-engClusSumPresOnly[kTOPO_OOC]);
        enom = (engClusSumCalib - engClusSumCalibPresOnly) + engClusSumTrueOOC + engClusSumRecoDM;
      }
      if(edenom != 0.0) {
        m_engRecOverTruth_vs_eta[i_coll][i_norm][m_mc_enerbin]->Fill(m_mc_eta, enom/edenom);
        m_engRecOverTruth_vs_ebeam[i_coll][i_norm][m_mc_etabin]->Fill(m_mc_ener, enom/edenom);
      }
    } // i_coll
  } // m_doEngRecOverTruth
 
  /* ********************************************
  filling histograms with classification results
  ******************************************** */
  if(m_doEngTag) {
    if(engClusSumCalib!=0.0) {
      const double inv_engClusSumCalib = 1. / engClusSumCalib;
      for(int i_tag=0; i_tag<m_ntagcases; i_tag++) {
        m_engTag_vs_eta[i_tag][m_mc_enerbin]->Fill(m_mc_eta, engClusSumCalibTagged[i_tag]*inv_engClusSumCalib);
        m_engTag_vs_ebeam[i_tag][m_mc_etabin]->Fill(m_mc_ener, engClusSumCalibTagged[i_tag]*inv_engClusSumCalib);
      }
    }
  } // m_doEngTag
 
  /* ********************************************
  filling histograms for reco energy spectras
  ******************************************** */
  if(m_doEngRecSpect && m_mc_ener > 0){
    for(int i_coll=0; i_coll<m_ncluscoll; i_coll++){
      double enom = engClusSum[i_coll];
      if(i_coll != kTOPO) {
        enom = enom - engClusSumPresOnly[i_coll];
      }
      m_engRecSpect[i_coll][m_mc_enerbin][m_mc_etabin]->Fill(enom/m_mc_ener);
    }
  } // m_doEngRecSpect
 
  return 0;
}

finalize()

StatusCode GetLCSinglePionsPerf::finalize ( )

virtual

Definition at line 481 of file GetLCSinglePionsPerf.cxx.

{
  ATH_MSG_INFO( "Writing out histograms"  );
 
  // ereco over truth after each step of calibration
  if(m_doEngRecOverTruth) {
    m_outputFile->cd();
    m_outputFile->mkdir("engRecOverTruth");
    m_outputFile->cd("engRecOverTruth");
    for(int i_coll=0; i_coll<m_ncluscoll; i_coll++){
      for(int i_norm=0; i_norm<m_nnormtype; i_norm++){
        for(int i_ener=0; i_ener<m_nlogenerbin; i_ener++){
          if(m_engRecOverTruth_vs_eta[i_coll][i_norm][i_ener]) m_engRecOverTruth_vs_eta[i_coll][i_norm][i_ener]->Write();
        } // i_ener
      } // i_norm
    } // i_coll
    //
    for(int i_coll=0; i_coll<m_ncluscoll; i_coll++){
      for(int i_norm=0; i_norm<m_nnormtype; i_norm++){
        for(int i_eta=0; i_eta<m_netabin; i_eta++) {
          if(m_engRecOverTruth_vs_ebeam[i_coll][i_norm][i_eta]) m_engRecOverTruth_vs_ebeam[i_coll][i_norm][i_eta]->Write();
        } // i_eta
      } // i_norm
    } // i_coll
  } // m_doEngRecOverTruth
 
  // classification performance
  if(m_doEngTag) {
    m_outputFile->cd();
    m_outputFile->mkdir("engTag");
    m_outputFile->cd("engTag");
    for(int i_tag=0; i_tag<m_ntagcases; i_tag++) {
      for(int i_ener=0; i_ener<m_nlogenerbin; i_ener++){
        if(m_engTag_vs_eta[i_tag][i_ener]) m_engTag_vs_eta[i_tag][i_ener]->Write();
      } // i_ener
    } // i_tag
    // as a function of pion energy for several eta bins
    for(int i_tag=0; i_tag<m_ntagcases; i_tag++){
      for(int i_eta=0; i_eta<m_netabin; i_eta++) {
        if(m_engTag_vs_ebeam[i_tag][i_eta]) m_engTag_vs_ebeam[i_tag][i_eta]->Write();
      }
    }
  } // m_doEngTag
 
  // reco energy spactras
  if(m_doEngRecSpect) {
    m_outputFile->cd();
    m_outputFile->mkdir("engRecSpect");
    m_outputFile->cd("engRecSpect");
    for(int i_coll=0; i_coll<m_ncluscoll; i_coll++){
      for(int i_ener=0; i_ener<m_nlogenerbin; i_ener++){
        for(int i_eta=0; i_eta<m_netabin; i_eta++){
          if(m_engRecSpect[i_coll][i_ener][i_eta]) m_engRecSpect[i_coll][i_ener][i_eta]->Write();
        } // i_eta
      } // i_ener
    } // i_coll
    // pione energy spectra
    for(int i_ener=0; i_ener<m_nlogenerbin; i_ener++){
      for(int i_eta=0; i_eta<m_netabin; i_eta++){
        if(m_engPionSpect[i_ener][i_eta]) m_engPionSpect[i_ener][i_eta]->Write();
      } // i_eta
    } // i_ener
  } // m_doEngRecSpect
 
  // noise clusters spectra
  if(m_doEngNoiseClus) {
    m_outputFile->cd();
    m_outputFile->mkdir("engNoiseClus");
    m_outputFile->cd("engNoiseClus");
    for(int i_coll=0; i_coll<m_ncluscoll; i_coll++){
      for(int i_eta=0; i_eta<m_netabin; i_eta++){
        if(m_engNoiseClusSpect[i_coll][i_eta]) m_engNoiseClusSpect[i_coll][i_eta]->Write();
      } // i_eta
    } // i_coll
    // average noise
    for(int i_coll=0; i_coll<m_ncluscoll; i_coll++){
      if(m_engNoiseClus_vs_eta[i_coll]) m_engNoiseClus_vs_eta[i_coll] -> Write();
    }
  } // m_doEngRecSpect
 
  if(m_doClusMoments) {
    m_outputFile->cd();
    m_outputFile->mkdir("clusMoment");
    m_outputFile->cd("clusMoment");
    for(int i_mom=0; i_mom<m_nmoments; i_mom++){
      for(int i_sum=0; i_sum<m_nmomsums; i_sum++){
        for(int i_ener=0; i_ener<m_nlogenerbin; i_ener++){
          if(m_clusMoment_vs_eta[i_mom][i_sum][i_ener]) m_clusMoment_vs_eta[i_mom][i_sum][i_ener]->Write();
        } // i_ener
      } // i_sum
    } // i_mom
    for(int i_mom=0; i_mom<m_nmoments; i_mom++){
      for(int i_sum=0; i_sum<m_nmomsums; i_sum++){
        for(int i_eta=0; i_eta<m_netabin; i_eta++){
          if(m_clusMoment_vs_ebeam[i_mom][i_sum][i_eta]) m_clusMoment_vs_ebeam[i_mom][i_sum][i_eta]->Write();
        } // i_eta
      } // i_sum
    } // i_mom
 
  } // m_doClusMoments
 
  if(m_doRecoEfficiency) {
    m_outputFile->cd();
    m_outputFile->mkdir("RecoEff");
    m_outputFile->cd("RecoEff");
    for(int i_ener=0; i_ener<m_nlogenerbin; i_ener++){
      if(m_RecoEfficiency_vs_eta[0][i_ener] && m_RecoEfficiency_vs_eta[1][i_ener]) {
        m_RecoEfficiency_vs_eta[0][i_ener]->Write();
        m_RecoEfficiency_vs_eta[1][i_ener]->Write();
      }
    } // i_eta
    for(int i_eta=0; i_eta<m_netabin; i_eta++){
      if(m_RecoEfficiency_vs_ebeam[0][i_eta] && m_RecoEfficiency_vs_ebeam[1][i_eta]) {
        m_RecoEfficiency_vs_ebeam[0][i_eta]->Write();
        m_RecoEfficiency_vs_ebeam[1][i_eta]->Write();
      }
    } // i_eta
  } // m_doRecoEfficiency
 
  /* **************************************************************************
  histograms to check calibration hits machinery
  *************************************************************************** */
  if(m_doCalibHitsValidation) {
    m_outputFile->cd();
    m_outputFile->mkdir("CalibHitsValidation");
    m_outputFile->cd("CalibHitsValidation");
    for(int i_ener=0; i_ener<m_nlogenerbin2; i_ener++){
      if(m_SumCalibHitOverEbeam_vs_eta[i_ener]) m_SumCalibHitOverEbeam_vs_eta[i_ener]->Write();
      if(m_DefaultCalculatorOverEbeam_vs_eta[i_ener]) m_DefaultCalculatorOverEbeam_vs_eta[i_ener]->Write();
      if(m_SumCalibHitAssignedOverEbeam_vs_eta[i_ener]) m_SumCalibHitAssignedOverEbeam_vs_eta[i_ener]->Write();
      if(m_SumCalibHitAssignedOverEbeam_vs_etaphi[i_ener]) m_SumCalibHitAssignedOverEbeam_vs_etaphi[i_ener]->Write();
    } // i_ener
//     for(int i_eta=0; i_eta<m_netabin; i_eta++){
//       if(m_SumCalibHitOverEbeam_vs_ebeam[i_eta]) m_SumCalibHitOverEbeam_vs_ebeam[i_eta]->Write();
// //       if(m_DefaultCalculatorOverEbeam_vs_ebeam[i_eta]) m_DefaultCalculatorOverEbeam_vs_ebeam[i_eta]->Write();
//     } // i_eta
 
  } // m_doCalibHitsValidation
 
  /* ********************************************
  writing tree with histogram parameters
  ******************************************** */
  m_outputFile->cd();
  m_outputFile->mkdir("Parameters");
  m_outputFile->cd("Parameters");
  TTree *tree = new TTree("ParamTree","ParamTree");
  tree->Branch("m_netabin",&m_netabin,"m_netabin/I");
  tree->Branch("m_etamin",&m_etamin,"m_etamin/F");
  tree->Branch("m_etamax",&m_etamax,"m_etamax/F");
  tree->Branch("m_nphibin",&m_nphibin,"m_nphibin/I");
  tree->Branch("m_phimin",&m_phimin,"m_phimin/F");
  tree->Branch("m_phimax",&m_phimax,"m_phimax/F");
  tree->Branch("m_nlogenerbin",&m_nlogenerbin,"m_nlogenerbin/I");
  tree->Branch("m_logenermin",&m_logenermin,"m_logenermin/F");
  tree->Branch("m_logenermax",&m_logenermax,"m_logenermax/F");
  tree->Branch("m_nnormtype",&m_nnormtype,"m_nnormtype/I");
  tree->Branch("m_ncluscoll",&m_ncluscoll,"m_ncluscoll/I");
  tree->Branch("m_ntagcases",&m_ntagcases,"m_ntagcases/I");
  tree->Branch("m_nmoments",&m_nmoments,"m_nmoments/I");
  tree->Branch("m_nmomsums",&m_nmomsums,"m_nmomsums/I");
  tree->Fill();
  tree->Write();
 
  m_outputFile->Close();
 
  return StatusCode::SUCCESS;
}

initialize()

StatusCode GetLCSinglePionsPerf::initialize ( )

virtual

Definition at line 173 of file GetLCSinglePionsPerf.cxx.

{
  ATH_CHECK( detStore()->retrieve(m_calo_id,"CaloCell_ID") );
  ATH_CHECK( detStore()->retrieve(m_id_helper) );
 
 
  m_deta = (m_etamax - m_etamin)/m_netabin;
  m_dphi = (m_phimax - m_phimin)/m_nphibin;
  m_dlogener = (m_logenermax - m_logenermin)/m_nlogenerbin;
 
  m_outputFile = new TFile(m_outputFileName.c_str(),"RECREATE");
  m_outputFile->cd();
 
  // defining histograms
  char hname[256];
  float h_eta_min = -5.0;
  float h_eta_max=5.0;
  int h_nch_eta = 50;
  if(m_etamin != 0.0) {
    h_eta_min = m_etamin;
    h_eta_max = m_etamax;
  }
  const int n_logener_bins = m_nlogenerbin*2;
  double *xbins = new double[n_logener_bins+1];
  const double inv_n_logener_bins = 1. / static_cast<double> (n_logener_bins);
  for(int i_bin=0; i_bin<=n_logener_bins; i_bin++) {
    xbins[i_bin] = pow(10,m_logenermin+i_bin*(m_logenermax-m_logenermin)*inv_n_logener_bins);
  }
  m_ncluscoll = m_clusterCollNames.size();
 
  /* **************************************************************************
  histograms to check classification performance
  *************************************************************************** */
  if(m_doEngTag) {
    // as a function of pion eta for several energy bins
    m_engTag_vs_eta.resize(m_ntagcases);
    for(int i_tag=0; i_tag<m_ntagcases; i_tag++) {
      m_engTag_vs_eta[i_tag].resize(m_nlogenerbin, nullptr);
      for(int i_ener=0; i_ener<m_nlogenerbin; i_ener++){
        sprintf(hname, "hp_engTag_vs_eta_tag%d_ener%d",i_tag, i_ener);
        TProfile *hp = new TProfile(hname, hname, h_nch_eta, h_eta_min, h_eta_max);
        hp->GetXaxis()->SetTitle("#eta");
        hp->GetYaxis()->SetTitle("E_{class}/E_{tot}");
        m_engTag_vs_eta[i_tag][i_ener] = hp;
      } // i_ener
    } // i_tag
    // as a function of pion energy for several eta bins
    m_engTag_vs_ebeam.resize(m_ntagcases);
    for(int i_tag=0; i_tag<m_ntagcases; i_tag++){
      m_engTag_vs_ebeam[i_tag].resize(m_netabin, nullptr);
      for(int i_eta=0; i_eta<m_netabin; i_eta++) {
        sprintf(hname, "hp_engTag_vs_ebeam_tag%d_eta%d",i_tag, i_eta);
        TProfile *hp = new TProfile(hname, hname, n_logener_bins, xbins);
        hp->GetXaxis()->SetTitle("E_{#pi}, MeV");
        hp->GetYaxis()->SetTitle("E_{class}/E_{tot}");
        m_engTag_vs_ebeam[i_tag][i_eta] = hp;
      }
    }
  } // m_doEngTag
 
 
  /* **************************************************************************
  histograms to check reconstructed energy after each step of local hadronic 
  calibration, reco energy is defined as a sum of clusters energies within certain 
  angle around particle direction
  *************************************************************************** */
  if(m_doEngRecOverTruth) {
    // as a function of pion eta for several energy bins
    m_engRecOverTruth_vs_eta.resize(m_ncluscoll);
    for(int i_coll=0; i_coll<m_ncluscoll; i_coll++){
      m_engRecOverTruth_vs_eta[i_coll].resize(m_nnormtype);
      for(int i_norm=0; i_norm<m_nnormtype; i_norm++){
        m_engRecOverTruth_vs_eta[i_coll][i_norm].resize(m_nlogenerbin, nullptr);
        for(int i_ener=0; i_ener<m_nlogenerbin; i_ener++){
          double ylow(0), yup(0);
          if(i_norm != kLEVEL_PARTICLE) {
            ylow = 0.0;
            yup  = 100.0;
          }
          sprintf(hname, "hp_engRecOverTruth_vs_eta_coll%d_norm%d_ener%d",i_coll, i_norm, i_ener);
          TProfile *hp = new TProfile(hname, hname, h_nch_eta, h_eta_min, h_eta_max, ylow, yup);
          hp->GetXaxis()->SetTitle("#eta");
          if(i_norm==kLEVEL_PARTICLE) {
            hp->GetYaxis()->SetTitle("E_{reco}/E_{#pi}");
          }else{
            hp->GetYaxis()->SetTitle("E_{reco}/E_{calib}");
          }
          m_engRecOverTruth_vs_eta[i_coll][i_norm][i_ener] = hp;
        } // i_ener
      } // i_norm
    } // i_coll
    // as a function of pion energy for several eta bins
    m_engRecOverTruth_vs_ebeam.resize(m_ncluscoll);
    for(int i_coll=0; i_coll<m_ncluscoll; i_coll++){
      m_engRecOverTruth_vs_ebeam[i_coll].resize(m_nnormtype);
      for(int i_norm=0; i_norm<m_nnormtype; i_norm++){
        m_engRecOverTruth_vs_ebeam[i_coll][i_norm].resize(m_netabin, nullptr);
        for(int i_eta=0; i_eta<m_netabin; i_eta++) {
          double ylow(0), yup(0);
          if(i_norm != kLEVEL_PARTICLE) {
            ylow = 0.0;
            yup  = 100.0;
          }
          sprintf(hname, "hp_m_engRecOverTruth_vs_ebeam_coll%d_norm%d_eta%d",i_coll, i_norm, i_eta);
          TProfile *hp = new TProfile(hname, hname, n_logener_bins, xbins, ylow, yup);
          hp->GetXaxis()->SetTitle("E_{#pi}, MeV");
          if(i_norm==kLEVEL_PARTICLE) {
            hp->GetYaxis()->SetTitle("E_{reco}/E_{#pi}");
          }else{
            hp->GetYaxis()->SetTitle("E_{reco}/E_{calib}");
          }
          m_engRecOverTruth_vs_ebeam[i_coll][i_norm][i_eta] = hp;
        } // i_eta
      } // i_norm
    } // i_coll
  } // m_doEngRecOverTruth
 
 
  /* **************************************************************************
  histograms to save reco and noise clusters energy spectras
  *************************************************************************** */
  if(m_doEngRecSpect) {
    m_engRecSpect.resize(m_ncluscoll);
    for(int i_coll=0; i_coll<m_ncluscoll; i_coll++){
      m_engRecSpect[i_coll].resize(m_nlogenerbin);
      for(int i_ener=0; i_ener<m_nlogenerbin; i_ener++){
        m_engRecSpect[i_coll][i_ener].resize(m_netabin, nullptr);
        for(int i_eta=0; i_eta<m_netabin; i_eta++){
          sprintf(hname, "hp_engRecSpect_coll%d_ener%d_eta%d",i_coll, i_ener, i_eta);
          TH1F *h1 = new TH1F(hname, hname, 110, -0.2, 2.0);
          h1->GetXaxis()->SetTitle("E_{reco}/E_{#pi}");
          m_engRecSpect[i_coll][i_ener][i_eta] = h1;
        } // i_eta
      } // i_ener
    } // i_coll
    // energy spectra of incident pions
    m_engPionSpect.resize(m_nlogenerbin);
    for(int i_ener=0; i_ener<m_nlogenerbin; i_ener++){
      m_engPionSpect[i_ener].resize(m_netabin, nullptr);
      for(int i_eta=0; i_eta<m_netabin; i_eta++){
        sprintf(hname, "hp_engPionSpect_ener%d_eta%d",i_ener, i_eta);
        double x1 = pow(10,m_logenermin+i_ener*m_dlogener);
        double x2 = pow(10,m_logenermin+(i_ener+1)*m_dlogener);
        TH1F *h1 = new TH1F(hname, hname, 20, x1, x2);
        h1->GetXaxis()->SetTitle("E_{#pi}, MeV");
        m_engPionSpect[i_ener][i_eta] = h1;
      } // i_eta
    } // i_ener
  } // m_doEngRecSpect
 
  /* **************************************************************************
  histograms to save noise clusters spectras
  *************************************************************************** */
  if(m_doEngNoiseClus) {
    // noise clusters spectras
    m_engNoiseClusSpect.resize(m_ncluscoll);
    for(int i_coll=0; i_coll<m_ncluscoll; i_coll++){
      m_engNoiseClusSpect[i_coll].resize(m_netabin, nullptr);
      for(int i_eta=0; i_eta<m_netabin; i_eta++){
        sprintf(hname, "hp_engNoiseClusSpect_coll%d_eta%d",i_coll, i_eta);
        TH1F *h1 = new TH1F(hname, hname, 100, -2000., 2000.);
        h1->GetXaxis()->SetTitle("E_{clus}, MeV");
        m_engNoiseClusSpect[i_coll][i_eta] = h1;
      } // i_eta
    } // i_coll
    // average
    m_engNoiseClus_vs_eta.resize(m_ncluscoll, nullptr);
    for(int i_coll=0; i_coll<m_ncluscoll; i_coll++){
      sprintf(hname, "hp_engNoiseClus_vs_eta_coll%d",i_coll);
      TProfile *hp = new TProfile(hname, hname, h_nch_eta, h_eta_min, h_eta_max);
      hp->GetXaxis()->SetTitle("#eta");
      hp->GetYaxis()->SetTitle("E_{clus}, MeV");
      m_engNoiseClus_vs_eta[i_coll] = hp;
      //hp->SetErrorOption("s");
    }
  } // m_doEngNoiseClus
 
  /* **************************************************************************
  histograms to save cluster moments
  *************************************************************************** */
  if(m_doClusMoments) {
    m_clusMoment_vs_eta.resize(m_nmoments);
    for(int i_mom=0; i_mom<m_nmoments; i_mom++){
      m_clusMoment_vs_eta[i_mom].resize(m_nmomsums);
      for(int i_sum=0; i_sum<m_nmomsums; i_sum++){
        m_clusMoment_vs_eta[i_mom][i_sum].resize(m_nlogenerbin, nullptr);
        for(int i_ener=0; i_ener<m_nlogenerbin; i_ener++){
          sprintf(hname, "hp_clusMoment_vs_eta_mom%d_sum%d_ener%d",i_mom, i_sum, i_ener);
          TProfile *hp = new TProfile(hname, hname, h_nch_eta, h_eta_min, h_eta_max);
          hp->GetXaxis()->SetTitle("#eta");
          hp->GetYaxis()->SetTitle("Mom_{cls}/Mom_{sum}");
          hp->SetTitle(m_validMoments[i_mom].first.c_str());
          m_clusMoment_vs_eta[i_mom][i_sum][i_ener] = hp;
        } // i_ener
      } // i_sum
    } // i_mom
 
    m_clusMoment_vs_ebeam.resize(m_nmoments);
    for(int i_mom=0; i_mom<m_nmoments; i_mom++){
      m_clusMoment_vs_ebeam[i_mom].resize(m_nmomsums);
      for(int i_sum=0; i_sum<m_nmomsums; i_sum++){
        m_clusMoment_vs_ebeam[i_mom][i_sum].resize(m_netabin, nullptr);
        for(int i_eta=0; i_eta<m_netabin; i_eta++){
          sprintf(hname, "hp_clusMoment_vs_ebeam_mom%d_sum%d_eta%d",i_mom, i_sum, i_eta);
          TProfile *hp = new TProfile(hname, hname, n_logener_bins, xbins);
          hp->GetXaxis()->SetTitle("E_{#pi}");
          hp->GetYaxis()->SetTitle("Mom_{cls}/Mom_{sum}");
          hp->SetTitle(m_validMoments[i_mom].first.c_str());
          m_clusMoment_vs_ebeam[i_mom][i_sum][i_eta] = hp;
        } // i_eta
      } // i_sum
    } // i_mom
 
  } // m_doClusMoments
 
 
  /* **************************************************************************
  histograms to save reconstruction efficiency
  *************************************************************************** */
  if(m_doRecoEfficiency) {
    // as a function of eta for several energy bins
    for(int i_eff=0; i_eff<2; i_eff++){ // 0-reconstructed, 1-all events
      m_RecoEfficiency_vs_eta[i_eff].resize(m_nlogenerbin, nullptr);
      for(int i_ener=0; i_ener<m_nlogenerbin; i_ener++){
        sprintf(hname, "hp_m_RecoEfficiency_eff%d_ener%d", i_eff, i_ener);
        TH1F *h1 = new TH1F(hname, hname,  h_nch_eta, h_eta_min, h_eta_max);
        h1->GetXaxis()->SetTitle("#eta");
        h1->GetYaxis()->SetTitle("Efficiency");
        m_RecoEfficiency_vs_eta[i_eff][i_ener] = h1;
      } // i_eta
    } // i_eff
    // as a function of energy for several eta bins
    for(int i_eff=0; i_eff<2; i_eff++){ // 0-reconstructed, 1-all events
      m_RecoEfficiency_vs_ebeam[i_eff].resize(m_netabin, nullptr);
      for(int i_eta=0; i_eta<m_netabin; i_eta++){
        sprintf(hname, "hp_m_RecoEfficiency_eff%d_eta%d", i_eff, i_eta);
        TH1F *h1 = new TH1F(hname, hname, n_logener_bins, xbins);
        h1->GetXaxis()->SetTitle("E_{#pi}, MeV");
        h1->GetYaxis()->SetTitle("Efficiency");
        m_RecoEfficiency_vs_ebeam[i_eff][i_eta] = h1;
      } // i_eta
    } // i_eff
  }
 
  /* **************************************************************************
  histograms to check calibration hits machinery
  *************************************************************************** */
  if(m_doCalibHitsValidation) {
    m_SumCalibHitOverEbeam_vs_eta.resize(m_nlogenerbin2, nullptr);
    m_DefaultCalculatorOverEbeam_vs_eta.resize(m_nlogenerbin2, nullptr);
    m_SumCalibHitAssignedOverEbeam_vs_eta.resize(m_nlogenerbin2, nullptr);
    m_SumCalibHitAssignedOverEbeam_vs_etaphi.resize(m_nlogenerbin2, nullptr);
    for(int i_ener=0; i_ener<m_nlogenerbin2; i_ener++){
      sprintf(hname, "hp_SumCalibHitOverEbeam_vs_eta_ener%d", i_ener);
      TProfile *hp = new TProfile(hname, hname, h_nch_eta, h_eta_min, h_eta_max);
      hp->GetXaxis()->SetTitle("#eta");
      hp->GetYaxis()->SetTitle("#sum E_{calib}/E_{#pi}");
      m_SumCalibHitOverEbeam_vs_eta[i_ener] = hp;
      sprintf(hname, "hp_DefaultCalculatorOverEbeam_vs_eta_ener%d", i_ener);
      hp = new TProfile(hname, hname, h_nch_eta, h_eta_min, h_eta_max);
      hp->GetXaxis()->SetTitle("#eta");
      hp->GetYaxis()->SetTitle("#sum E_{DefCalc}/E_{#pi}");
      m_DefaultCalculatorOverEbeam_vs_eta[i_ener] = hp;
      sprintf(hname, "hp_SumCalibHitAssignedOverEbeam_vs_eta_ener%d", i_ener);
      hp = new TProfile(hname, hname, h_nch_eta, h_eta_min, h_eta_max);
      hp->GetXaxis()->SetTitle("#eta");
      hp->GetYaxis()->SetTitle("#sum E_{assigned}/E_{#pi}");
      m_SumCalibHitAssignedOverEbeam_vs_eta[i_ener] = hp;
      sprintf(hname, "hp_SumCalibHitAssignedOverEbeam_vs_etaphi_ener%d", i_ener);
      TProfile2D *hp2 = new TProfile2D(hname, hname, 25, h_eta_min, h_eta_max, 25, -M_PI, M_PI);
      hp2->GetXaxis()->SetTitle("#eta");
      hp2->GetYaxis()->SetTitle("#phi");
      hp2->GetZaxis()->SetTitle("#sum E_{assigned}/E_{#pi}");
      m_SumCalibHitAssignedOverEbeam_vs_etaphi[i_ener] = hp2;
    } // i_ener
 
//     m_SumCalibHitOverEbeam_vs_ebeam.resize(m_netabin, 0);
// //     m_DefaultCalculatorOverEbeam_vs_ebeam.resize(m_netabin, 0);
//     for(int i_eta=0; i_eta<m_netabin; i_eta++){
//       sprintf(hname, "hp_SumCalibHitOverEbeam_vs_ebeam_eta%d", i_eta);
//       TProfile *hp = new TProfile(hname, hname,  n_logener_bins, xbins);
//       hp->GetXaxis()->SetTitle("#eta");
//       hp->GetYaxis()->SetTitle("#sum E_{calib}/E_{#pi}");
//       m_SumCalibHitOverEbeam_vs_ebeam[i_eta] = hp;
// //       sprintf(hname, "hp_DefaultCalculatorOverEbeam_vs_ebeam_eta%d", i_eta);
// //       hp = new TProfile(hname, hname,  n_logener_bins, xbins);
// //       hp->GetXaxis()->SetTitle("#eta");
// //       hp->GetYaxis()->SetTitle("#sum E_{DefCalc}/E_{#pi}");
// //       m_DefaultCalculatorOverEbeam_vs_ebeam[i_eta] = hp;
//     } // i_eta
  } // m_doCalibHitsValidation
 
 
  delete [] xbins;
 
  ATH_CHECK( m_clusterBasicCollName.initialize() );
  ATH_CHECK( m_clusterCollNames.initialize() );
  ATH_CHECK( m_CalibrationHitContainerNames.initialize() );
  ATH_CHECK( m_DMCalibrationHitContainerNames.initialize() );
 
  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_CalibrationHitContainerNames

SG::ReadHandleKeyArray<CaloCalibrationHitContainer> GetLCSinglePionsPerf::m_CalibrationHitContainerNames

private

Definition at line 66 of file GetLCSinglePionsPerf.h.

m_calo_id

const CaloCell_ID* GetLCSinglePionsPerf::m_calo_id

private

Definition at line 59 of file GetLCSinglePionsPerf.h.

m_caloDmDescrManager

const CaloDmDescrManager* GetLCSinglePionsPerf::m_caloDmDescrManager

private

Definition at line 60 of file GetLCSinglePionsPerf.h.

m_clusMoment_vs_ebeam

std::vector<std::vector<std::vector<TProfile *> > > GetLCSinglePionsPerf::m_clusMoment_vs_ebeam

private

Definition at line 119 of file GetLCSinglePionsPerf.h.

m_clusMoment_vs_eta

std::vector<std::vector<std::vector<TProfile *> > > GetLCSinglePionsPerf::m_clusMoment_vs_eta

private

Definition at line 118 of file GetLCSinglePionsPerf.h.

m_clusterBasicCollName

SG::ReadHandleKey<xAOD::CaloClusterContainer> GetLCSinglePionsPerf::m_clusterBasicCollName

private

Definition at line 62 of file GetLCSinglePionsPerf.h.

m_clusterCollNames

SG::ReadHandleKeyArray<xAOD::CaloClusterContainer> GetLCSinglePionsPerf::m_clusterCollNames

private

Definition at line 63 of file GetLCSinglePionsPerf.h.

m_DefaultCalculatorOverEbeam_vs_eta

std::vector<TProfile *> GetLCSinglePionsPerf::m_DefaultCalculatorOverEbeam_vs_eta

private

Definition at line 126 of file GetLCSinglePionsPerf.h.

m_deta

float GetLCSinglePionsPerf::m_deta

private

Definition at line 75 of file GetLCSinglePionsPerf.h.

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_distance_cut

double GetLCSinglePionsPerf::m_distance_cut

private

Definition at line 70 of file GetLCSinglePionsPerf.h.

m_dlogener

float GetLCSinglePionsPerf::m_dlogener

private

Definition at line 84 of file GetLCSinglePionsPerf.h.

m_DMCalibrationHitContainerNames

SG::ReadHandleKeyArray<CaloCalibrationHitContainer> GetLCSinglePionsPerf::m_DMCalibrationHitContainerNames

private

Definition at line 67 of file GetLCSinglePionsPerf.h.

m_doCalibHitsValidation

bool GetLCSinglePionsPerf::m_doCalibHitsValidation

private

Definition at line 101 of file GetLCSinglePionsPerf.h.

m_doClusMoments

bool GetLCSinglePionsPerf::m_doClusMoments

private

Definition at line 97 of file GetLCSinglePionsPerf.h.

m_doEngNoiseClus

bool GetLCSinglePionsPerf::m_doEngNoiseClus

private

Definition at line 96 of file GetLCSinglePionsPerf.h.

m_doEngRecOverTruth

bool GetLCSinglePionsPerf::m_doEngRecOverTruth

private

Definition at line 93 of file GetLCSinglePionsPerf.h.

m_doEngRecSpect

bool GetLCSinglePionsPerf::m_doEngRecSpect

private

Definition at line 95 of file GetLCSinglePionsPerf.h.

m_doEngTag

bool GetLCSinglePionsPerf::m_doEngTag

private

Definition at line 94 of file GetLCSinglePionsPerf.h.

m_doRecoEfficiency

bool GetLCSinglePionsPerf::m_doRecoEfficiency

private

Definition at line 98 of file GetLCSinglePionsPerf.h.

m_dphi

float GetLCSinglePionsPerf::m_dphi

private

Definition at line 79 of file GetLCSinglePionsPerf.h.

m_engNoiseClus_vs_eta

std::vector<TProfile *> GetLCSinglePionsPerf::m_engNoiseClus_vs_eta

private

Definition at line 116 of file GetLCSinglePionsPerf.h.

m_engNoiseClusSpect

std::vector<std::vector<TH1F *> > GetLCSinglePionsPerf::m_engNoiseClusSpect

private

Definition at line 115 of file GetLCSinglePionsPerf.h.

m_engPionSpect

std::vector<std::vector<TH1F *> > GetLCSinglePionsPerf::m_engPionSpect

private

Definition at line 113 of file GetLCSinglePionsPerf.h.

m_engRecOverTruth_vs_ebeam

std::vector<std::vector<std::vector<TProfile *> > > GetLCSinglePionsPerf::m_engRecOverTruth_vs_ebeam

private

Definition at line 106 of file GetLCSinglePionsPerf.h.

m_engRecOverTruth_vs_eta

std::vector<std::vector<std::vector<TProfile *> > > GetLCSinglePionsPerf::m_engRecOverTruth_vs_eta

private

Definition at line 105 of file GetLCSinglePionsPerf.h.

m_engRecSpect

std::vector<std::vector<std::vector<TH1F *> > > GetLCSinglePionsPerf::m_engRecSpect

private

Definition at line 111 of file GetLCSinglePionsPerf.h.

m_engTag_vs_ebeam

std::vector<std::vector<TProfile *> > GetLCSinglePionsPerf::m_engTag_vs_ebeam

private

Definition at line 109 of file GetLCSinglePionsPerf.h.

m_engTag_vs_eta

std::vector<std::vector<TProfile *> > GetLCSinglePionsPerf::m_engTag_vs_eta

private

Definition at line 108 of file GetLCSinglePionsPerf.h.

m_etamax

float GetLCSinglePionsPerf::m_etamax

private

Definition at line 74 of file GetLCSinglePionsPerf.h.

m_etamin

float GetLCSinglePionsPerf::m_etamin

private

Definition at line 73 of file GetLCSinglePionsPerf.h.

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_id_helper

const AtlasDetectorID* GetLCSinglePionsPerf::m_id_helper

private

Definition at line 58 of file GetLCSinglePionsPerf.h.

m_logenermax

float GetLCSinglePionsPerf::m_logenermax

private

Definition at line 82 of file GetLCSinglePionsPerf.h.

m_logenermin

float GetLCSinglePionsPerf::m_logenermin

private

Definition at line 81 of file GetLCSinglePionsPerf.h.

m_mc_ener

double GetLCSinglePionsPerf::m_mc_ener

private

Definition at line 131 of file GetLCSinglePionsPerf.h.

m_mc_enerbin

int GetLCSinglePionsPerf::m_mc_enerbin

private

Definition at line 135 of file GetLCSinglePionsPerf.h.

m_mc_eta

double GetLCSinglePionsPerf::m_mc_eta

private

Definition at line 132 of file GetLCSinglePionsPerf.h.

m_mc_etabin

int GetLCSinglePionsPerf::m_mc_etabin

private

Definition at line 134 of file GetLCSinglePionsPerf.h.

m_mc_phi

double GetLCSinglePionsPerf::m_mc_phi

private

Definition at line 133 of file GetLCSinglePionsPerf.h.

m_mc_phibin

int GetLCSinglePionsPerf::m_mc_phibin

private

Definition at line 136 of file GetLCSinglePionsPerf.h.

m_ncluscoll

int GetLCSinglePionsPerf::m_ncluscoll

private

Definition at line 86 of file GetLCSinglePionsPerf.h.

m_netabin

int GetLCSinglePionsPerf::m_netabin

private

Definition at line 72 of file GetLCSinglePionsPerf.h.

m_nlogenerbin

int GetLCSinglePionsPerf::m_nlogenerbin

private

Definition at line 80 of file GetLCSinglePionsPerf.h.

m_nlogenerbin2

int GetLCSinglePionsPerf::m_nlogenerbin2

private

Definition at line 83 of file GetLCSinglePionsPerf.h.

m_nmoments

int GetLCSinglePionsPerf::m_nmoments

private

Definition at line 88 of file GetLCSinglePionsPerf.h.

m_nmomsums

int GetLCSinglePionsPerf::m_nmomsums

private

Definition at line 89 of file GetLCSinglePionsPerf.h.

m_nnormtype

int GetLCSinglePionsPerf::m_nnormtype

private

Definition at line 85 of file GetLCSinglePionsPerf.h.

m_nphibin

int GetLCSinglePionsPerf::m_nphibin

private

Definition at line 76 of file GetLCSinglePionsPerf.h.

m_ntagcases

int GetLCSinglePionsPerf::m_ntagcases

private

Definition at line 87 of file GetLCSinglePionsPerf.h.

m_outputFile

TFile* GetLCSinglePionsPerf::m_outputFile

private

Definition at line 65 of file GetLCSinglePionsPerf.h.

m_outputFileName

std::string GetLCSinglePionsPerf::m_outputFileName

private

Definition at line 64 of file GetLCSinglePionsPerf.h.

m_phimax

float GetLCSinglePionsPerf::m_phimax

private

Definition at line 78 of file GetLCSinglePionsPerf.h.

m_phimin

float GetLCSinglePionsPerf::m_phimin

private

Definition at line 77 of file GetLCSinglePionsPerf.h.

m_RecoEfficiency_vs_ebeam

std::vector<TH1F *> GetLCSinglePionsPerf::m_RecoEfficiency_vs_ebeam[2]

private

Definition at line 122 of file GetLCSinglePionsPerf.h.

m_RecoEfficiency_vs_eta

std::vector<TH1F *> GetLCSinglePionsPerf::m_RecoEfficiency_vs_eta[2]

private

Definition at line 121 of file GetLCSinglePionsPerf.h.

m_SumCalibHitAssignedOverEbeam_vs_eta

std::vector<TProfile *> GetLCSinglePionsPerf::m_SumCalibHitAssignedOverEbeam_vs_eta

private

Definition at line 128 of file GetLCSinglePionsPerf.h.

m_SumCalibHitAssignedOverEbeam_vs_etaphi

std::vector<TProfile2D *> GetLCSinglePionsPerf::m_SumCalibHitAssignedOverEbeam_vs_etaphi

private

Definition at line 129 of file GetLCSinglePionsPerf.h.

m_SumCalibHitOverEbeam_vs_eta

std::vector<TProfile *> GetLCSinglePionsPerf::m_SumCalibHitOverEbeam_vs_eta

private

Definition at line 124 of file GetLCSinglePionsPerf.h.

m_truthPiEngFraction

float GetLCSinglePionsPerf::m_truthPiEngFraction

private

Definition at line 92 of file GetLCSinglePionsPerf.h.

m_useGoodClus

bool GetLCSinglePionsPerf::m_useGoodClus

private

Definition at line 100 of file GetLCSinglePionsPerf.h.

m_usePionClusters

bool GetLCSinglePionsPerf::m_usePionClusters

private

Definition at line 102 of file GetLCSinglePionsPerf.h.

m_useRecoEfficiency

bool GetLCSinglePionsPerf::m_useRecoEfficiency

private

Definition at line 99 of file GetLCSinglePionsPerf.h.

m_validMoments

moment_name_vector GetLCSinglePionsPerf::m_validMoments

private

Definition at line 68 of file GetLCSinglePionsPerf.h.

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.

---

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

• GetLCSinglePionsPerf.h
• GetLCSinglePionsPerf.cxx