#include <LArFCalSamplingFraction.h>

Inheritance diagram for LArFCalSamplingFraction:

Collaboration diagram for LArFCalSamplingFraction:

Public Member Functions
	LArFCalSamplingFraction (const std::string &name, ISvcLocator *pSvcLocator)
	Constructor. More...

	~LArFCalSamplingFraction ()
	Destructor. More...

virtual StatusCode	initialize () override
	Initialize. More...

virtual StatusCode	finalize () override
	Finalize. More...

virtual StatusCode	execute () override
	Execute (event by event) More...

virtual StatusCode	initEvent ()
	Init event. More...

StatusCode	doFCal ()
	The main FCal analysis method. More...

void	TruthImpactPosition (const HepMC::GenEvent *e)
	Calculate truth impact position. More...

void	FCalCalibAnalysis (const std::string &name, const CaloCalibrationHit *CalibHit)
	FCal Analysis with Calibration Hits on Added by JPA, June 2005. More...

void	FCalClusterCenter (const LArHitContainer container, const CaloDetDescrManager caloMgr)
	Calculate FCal cluster center. More...

void	FCalHitCenter (const LArHitContainer container, const CaloDetDescrManager caloMgr)
	Calculate FCal hit center. More...

void	FillCellInfo (const CaloDetDescrElement caloDDE, double energy, std::vector< double > cell_E, std::vector< double > hit_x, std::vector< double > hit_y, std::vector< double > hit_ieta, std::vector< double > hit_iphi, int &NCell)
	Fill FCal cell information. More...

StatusCode	doCalib ()
	Calibration hit analysis. More...

virtual StatusCode	sysInitialize () override
	Override sysInitialize. More...

virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies. More...

ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard `StoreGateSvc` (event store) Returns (kind of) a pointer to the `StoreGateSvc`. More...

const ServiceHandle< StoreGateSvc > &	evtStore () const
	The standard `StoreGateSvc` (event store) Returns (kind of) a pointer to the `StoreGateSvc`. More...

const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard `StoreGateSvc/DetectorStore` Returns (kind of) a pointer to the `StoreGateSvc`. More...

virtual StatusCode	sysStart () override
	Handle START transition. More...

virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles. More...

virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles. More...

Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T > &t)

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc="none")
	Declare a new Gaudi property. More...

void	updateVHKA (Gaudi::Details::PropertyBase &)

MsgStream &	msg () const

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

bool	msgLvl (const MSG::Level lvl) const

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution More...

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. More...

Private Types
typedef std::map< std::string, const CaloCalibrationHitContainer * >	m_calibHitMap_t

typedef m_calibHitMap_t::iterator	m_calibHitMap_ptr_t

typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
StatusCode	addEventInfo ()
	methods called by execute() More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
	specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
	specialization for handling Gaudi::Property<SG::VarHandleBase> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
	specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...

Private Attributes
SG::ReadHandleKey< xAOD::EventInfo >	m_eventInfoKey {this, "EventInfoKey", "EventInfo"}

SG::ReadCondHandleKey< CaloDetDescrManager >	m_caloMgrKey

TTree *	m_tree_AS {}
	Athena-Aware Ntuple (AAN) variables - branches of the AAN TTree. More...

unsigned int	m_runNumber {}

unsigned int	m_eventNumber {}

unsigned int	m_eventTime {}

unsigned int	m_lumiBlock {}

unsigned int	m_bCID {}

double	m_eventWeight {}

double	m_vertx {}

double	m_verty {}

double	m_vertz {}

double	m_vertex_eta {}

double	m_vertex_phi {}

double	m_pt {}

double	m_px {}

double	m_py {}

double	m_pz {}

double	m_E {}

int	m_NCell1 {}

int	m_NCell2 {}

int	m_NCell3 {}

double	m_x_mc_cc1 {}

double	m_y_mc_cc1 {}

double	m_x_mc_cc2 {}

double	m_y_mc_cc2 {}

double	m_x_mc_cc3 {}

double	m_y_mc_cc3 {}

double	m_x_cc1 {}

double	m_y_cc1 {}

double	m_x_cc2 {}

double	m_y_cc2 {}

double	m_x_cc3 {}

double	m_y_cc3 {}

std::vector< int > *	m_pdg_id {}

std::vector< double > *	m_hit_x1 {}

std::vector< double > *	m_hit_y1 {}

std::vector< double > *	m_hit_x2 {}

std::vector< double > *	m_hit_y2 {}

std::vector< double > *	m_hit_x3 {}

std::vector< double > *	m_hit_y3 {}

std::vector< double > *	m_hit_ieta1 {}

std::vector< double > *	m_hit_iphi1 {}

std::vector< double > *	m_hit_ieta2 {}

std::vector< double > *	m_hit_iphi2 {}

std::vector< double > *	m_hit_ieta3 {}

std::vector< double > *	m_hit_iphi3 {}

std::vector< double > *	m_cell1_E {}

std::vector< double > *	m_cell2_E {}

std::vector< double > *	m_cell3_E {}

double	m_FCal1_SumE {}

double	m_FCal2_SumE {}

double	m_FCal3_SumE {}

double	m_TCScint_E {}

double	m_TCIron_E {}

double	m_totalFCalEnergy {}

int	m_numHitsFCal {}

double	m_totalCalibrationEnergy {}

double	m_totalEmEnergy {}

double	m_totalNonEmEnergy {}

double	m_totalInvisibleEnergy {}

double	m_totalEscapedEnergy {}

double	m_totalActiveEnergy {}

double	m_totalInactiveEnergy {}

double	m_totalDeadMaterialEnergy {}

int	m_numHitsActive {}

int	m_numHitsInactive {}

int	m_numHitsDead {}

double	m_totalFCalCalibrationEnergy {}

double	m_totalFCal1CalibrationEnergy {}

double	m_totalFCal2CalibrationEnergy {}

double	m_totalFCal3CalibrationEnergy {}

double	m_FCalActive {}

double	m_FCalInactive {}

double	m_FCalDead {}

double	m_FCalActiveEm {}

double	m_FCalActiveNonEm {}

double	m_FCalActiveInvisible {}

double	m_FCalActiveEscaped {}

double	m_FCalEm {}

double	m_FCal1Em {}

double	m_FCal2Em {}

double	m_FCal3Em {}

double	m_FCalNonEm {}

double	m_FCal1NonEm {}

double	m_FCal2NonEm {}

double	m_FCal3NonEm {}

double	m_FCalInvisible {}

double	m_FCal1Invisible {}

double	m_FCal2Invisible {}

double	m_FCal3Invisible {}

double	m_FCalEscaped {}

double	m_FCal1Escaped {}

double	m_FCal2Escaped {}

double	m_FCal3Escaped {}

double	m_PhysTotE {}

double	m_FCal1Active {}

double	m_FCal2Active {}

double	m_FCal3Active {}

double	m_FCal1Inactive {}

double	m_FCal2Inactive {}

double	m_FCal3Inactive {}

const CaloDM_ID *	m_caloDmID {}

const CaloCell_ID *	m_caloCellID {}

const LArFCAL_ID *	m_larFCalID {}

bool	m_calibrationRun

m_calibHitMap_t	m_calibHitMap

double	m_cx1

double	m_cx2

double	m_cx3

double	m_cy1

double	m_cy2

double	m_cy3

DataObjIDColl	m_extendedExtraObjects

StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default) More...

StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default) More...

std::vector< SG::VarHandleKeyArray * >	m_vhka

bool	m_varHandleArraysDeclared

Detailed Description

Definition at line 40 of file LArFCalSamplingFraction.h.

Member Typedef Documentation

◆ m_calibHitMap_ptr_t

typedef m_calibHitMap_t::iterator LArFCalSamplingFraction::m_calibHitMap_ptr_t

private

Definition at line 220 of file LArFCalSamplingFraction.h.

◆ m_calibHitMap_t

typedef std::map<std::string, const CaloCalibrationHitContainer *> LArFCalSamplingFraction::m_calibHitMap_t

private

Definition at line 219 of file LArFCalSamplingFraction.h.

◆ StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ LArFCalSamplingFraction()

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

Constructor.

Definition at line 52 of file LArFCalSamplingFraction.cxx.

     : AthAlgorithm(name, pSvcLocator),
       m_calibrationRun(false),
       m_cx1(0.0), m_cx2(0.0), m_cx3(0.0),
       m_cy1(0.0), m_cy2(0.0), m_cy3(0.0)
 {
     declareProperty("Calibration", m_calibrationRun);
 }

◆ ~LArFCalSamplingFraction()

LArFCalSamplingFraction::~LArFCalSamplingFraction ( )

Destructor.

Definition at line 65 of file LArFCalSamplingFraction.cxx.

65 {}

Member Function Documentation

◆ addEventInfo()

StatusCode LArFCalSamplingFraction::addEventInfo ( )

private

methods called by execute()

Definition at line 989 of file LArFCalSamplingFraction.cxx.

 {
     ATH_MSG_DEBUG("in addEventInfo()");
  
     // This code has been taken from AnalysisExamples/VFitZmmOnAOD
     // I have the actual EventNumber, but skipped the sequential count of event #
  
     // Get EventInfo for run and event number
     SG::ReadHandle<xAOD::EventInfo> eventInfo(m_eventInfoKey,getContext());
     ATH_CHECK(eventInfo.isValid());
     m_runNumber = eventInfo->runNumber();
     m_eventNumber = eventInfo->eventNumber();
  
     ATH_MSG_DEBUG("event " << m_eventNumber);
  
     m_eventTime = eventInfo->timeStamp();
     m_lumiBlock = eventInfo->lumiBlock();
     m_bCID = eventInfo->bcid();
     m_eventWeight = eventInfo->mcEventWeight();
  
     return StatusCode::SUCCESS;
 }

◆ declareGaudiProperty() [1/4]

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

inlineprivateinherited

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

Definition at line 170 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty	(	Gaudi::Property< T > &	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());
  
   }

◆ declareGaudiProperty() [3/4]

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

inlineprivateinherited

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

Definition at line 184 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty	(	Gaudi::Property< T > &	t,
		const SG::NotHandleType &
	)

inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

   {
     return PBASE::declareProperty(t);
   }

◆ declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty	(	const std::string &	name,
		SG::VarHandleBase &	hndl,
		const std::string &	doc,
		const SG::VarHandleType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

   {
     this->declare(hndl.vhKey());
     hndl.vhKey().setOwner(this);
  
     return PBASE::declareProperty(name,hndl,doc);
   }

◆ declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty	(	const std::string &	name,
		SG::VarHandleKey &	hndl,
		const std::string &	doc,
		const SG::VarHandleKeyType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

   {
     this->declare(hndl);
     hndl.setOwner(this);
  
     return PBASE::declareProperty(name,hndl,doc);
   }

◆ declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty	(	const std::string &	name,
		SG::VarHandleKeyArray &	hndArr,
		const std::string &	doc,
		const SG::VarHandleKeyArrayType &
	)

inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

   {
  
     // std::ostringstream ost;
     // ost << Algorithm::name() << " VHKA declareProp: " << name 
     //     << " size: " << hndArr.keys().size() 
     //     << " mode: " << hndArr.mode() 
     //     << "  vhka size: " << m_vhka.size()
     //     << "\n";
     // debug() << ost.str() << endmsg;
  
     hndArr.setOwner(this);
     m_vhka.push_back(&hndArr);
  
     Gaudi::Details::PropertyBase* p =  PBASE::declareProperty(name, hndArr, doc);
     if (p != 0) {
       p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
     } else {
       ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray " 
                     << name);
     }
  
     return p;
  
   }

◆ declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty	(	const std::string &	name,
		T &	property,
		const std::string &	doc,
		const SG::NotHandleType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

   {
     return PBASE::declareProperty(name, property, doc);
   }

◆ declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty	(	const std::string &	name,
		T &	property,
		const std::string &	doc = `"none"`
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

   {
     typedef typename SG::HandleClassifier<T>::type htype;
     return declareProperty (name, property, doc, htype());
   }

◆ declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( Gaudi::Property< T > & 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; }

◆ doCalib()

StatusCode LArFCalSamplingFraction::doCalib ( )

Calibration hit analysis.

Definition at line 556 of file LArFCalSamplingFraction.cxx.

 {
     StatusCode sc;
  
     ATH_MSG_DEBUG("Starting FCal Calibration Analysis");
  
     // Get the calibration hit containers (if any)
     for (auto& kv : m_calibHitMap)
     {
         std::string name = kv.first;
         const CaloCalibrationHitContainer *container{};
         sc = evtStore()->retrieve(container, name);
  
         if (sc.isFailure() || container == 0) {
             ATH_MSG_ERROR("CaloCalibrationHit container was not found");
             m_numHitsActive = 0;
             m_numHitsInactive = 0;
             m_numHitsDead = 0;
             kv.second = 0;
  
             return StatusCode::FAILURE;
         }
  
         ATH_MSG_DEBUG("CaloCalibrationHit container successfully retrieved");
  
         kv.second = container;
     }
  
     // Get the number of hits in each container
     // (The braces let us re-use the name 'container')
     {
         const CaloCalibrationHitContainer *container = m_calibHitMap["LArCalibrationHitActive"];
  
         if (container != 0)
             m_numHitsActive = container->Size();
         else
             m_numHitsActive = 0;
     }
     {
         const CaloCalibrationHitContainer *container = m_calibHitMap["LArCalibrationHitInactive"];
  
         if (container != 0)
             m_numHitsInactive = container->Size();
         else
             m_numHitsInactive = 0;
     }
     {
         const CaloCalibrationHitContainer *container = m_calibHitMap["LArCalibrationHitDeadMaterial"];
  
         if (container != 0)
             m_numHitsDead = container->Size();
         else
             m_numHitsDead = 0;
     }
  
     // Loop over all the hit containers, inspecting each hit within the collection
     for (const auto& kv : m_calibHitMap)
     {
         std::string name = kv.first;
         const CaloCalibrationHitContainer *container = kv.second;
  
         // Skip rest of loop if it's a null container.
         if (container == 0)
             continue;
  
         // Loop over calibration hits in container
         for (const CaloCalibrationHit* calibhit : *container) {
  
             Identifier identifier = calibhit->cellID();
             double energy = calibhit->energyTotal();
  
             // Accumulate energy sums. Use the ID helpers to determine in which
             // detector the hit took place.
  
             m_totalCalibrationEnergy += energy;
             m_totalEmEnergy += calibhit->energyEM();
             m_totalNonEmEnergy += calibhit->energyNonEM();
             m_totalInvisibleEnergy += calibhit->energyInvisible();
             m_totalEscapedEnergy += calibhit->energyEscaped();
  
             if (name == "LArCalibrationHitActive")
                 m_totalActiveEnergy += energy;
  
             if (name == "LArCalibrationHitInactive")
                 m_totalInactiveEnergy += energy;
  
             if (name == "LArCalibrationHitDeadMaterial") {
                 m_totalDeadMaterialEnergy += energy;
  
                 if (m_caloDmID->is_lar(identifier) && (m_caloDmID->sampling(identifier) == 3) && (m_caloDmID->dmat(identifier) == 1))
                     m_FCalDead += energy;
             }
  
             if (m_caloCellID->is_lar_fcal(identifier))
                 FCalCalibAnalysis(name, calibhit);
  
         } // End loop over calibration hits in container
     } // End loop over containers
  
     // Execution completed
  
     ATH_MSG_DEBUG("doCalib() completed successfully");
     return sc;
 }

◆ doFCal()

StatusCode LArFCalSamplingFraction::doFCal ( )

The main FCal analysis method.

Definition at line 804 of file LArFCalSamplingFraction.cxx.

 {
     ATH_MSG_INFO("Starting main FCal analysis");
  
     ATH_MSG_DEBUG("LArFCalSamplingFraction parameters are:");
     ATH_MSG_DEBUG("Calibration: " << m_calibrationRun);
  
     StatusCode sc;
  
     // ACCESSING EVENT INFORMATION
     // Get the basic event information (run number, event number).
     SG::ReadHandle<xAOD::EventInfo> eventInfo(m_eventInfoKey,getContext());
     ATH_CHECK(eventInfo.isValid());
     m_runNumber = eventInfo->runNumber();
     m_eventNumber = eventInfo->eventNumber();
  
     ATH_MSG_INFO("Run " << m_runNumber << ", event " << m_eventNumber);
  
     // How to access MC Truth information:
     const McEventCollection *mcEventCollection{};
     sc = evtStore()->retrieve(mcEventCollection, "TruthEvent");
  
     if (sc.isSuccess()) {
         // There can potentially be more than one MC event in the collection.
         McEventCollection::const_iterator mcEvent;
         for (const HepMC::GenEvent * mcEvent : *mcEventCollection) {
           TruthImpactPosition(mcEvent);
         }
     } // retrieved MC event collection
     else {
         ATH_MSG_DEBUG("Run " << m_runNumber << ", event " << m_eventNumber
                       << ": could not fetch MC event collection");
     }
  
     // Accessing Hits
     // Regular hits
     std::string FCalContainerName = "LArHitFCAL";
     const LArHitContainer *container = 0;
     sc = evtStore()->retrieve(container, FCalContainerName);
  
     if (sc.isFailure() || container == 0) {
         ATH_MSG_ERROR("LArHitFCAL container was not found");
         m_numHitsFCal = 0;
         return StatusCode::FAILURE;
     }
  
     ATH_MSG_DEBUG("LArHitFCAL container successfully retrieved");
  
     SG::ReadCondHandle<CaloDetDescrManager> caloMgrHandle{m_caloMgrKey};
     ATH_CHECK(caloMgrHandle.isValid());
     const CaloDetDescrManager* caloMgr = *caloMgrHandle;
  
  
     // Get the number of hits in the LArHitFCAL container
     m_numHitsFCal = container->size();
     ATH_MSG_INFO("NumHitsFCal = " << m_numHitsFCal);
  
     if (m_numHitsFCal > 0) {
         // Calculate the center of gravity
       FCalHitCenter(container,caloMgr);
       FCalClusterCenter(container,caloMgr);
     }
  
     // Loop over hits in container
     for (const LArHit* hit : *container) {
  
         // Added by JPA to get particle id for each hit
       const McEventCollection *mcEventCollection{};
         sc = evtStore()->retrieve(mcEventCollection, "TruthEvent");
  
         if (sc.isSuccess()) {
             // There can potentially be more than one MC event in the collection
             McEventCollection::const_iterator mcEvent;
  
             for (const HepMC::GenEvent * mcEvent : *mcEventCollection)
               {
                 // There may be many particles per event
                 for (auto theParticle: *mcEvent)
                   {
                     m_pdg_id->push_back(theParticle->pdg_id());
                   }
               }
         } // retrieved MC event collection
  
         // End JPA particle id
  
     const CaloDetDescrElement* caloDDE = caloMgr->get_element(hit->cellID());
     if(!caloDDE->is_lar_fcal()) {
       ATH_MSG_ERROR("LArHit does not belong to FCAL");
         }
  
         double energy = hit->energy();
         int module_index = caloDDE->getLayer();
         m_totalFCalEnergy += energy;
  
         if (module_index == 1) {
             m_FCal1_SumE += energy;
             FillCellInfo(caloDDE, energy, m_cell1_E, m_hit_x1, m_hit_y1, m_hit_ieta1, m_hit_iphi1, m_NCell1);
         }
         else if (module_index == 2) {
             m_FCal2_SumE += energy;
             FillCellInfo(caloDDE, energy, m_cell2_E, m_hit_x2, m_hit_y2, m_hit_ieta2, m_hit_iphi2, m_NCell2);
         }
         else if (module_index == 3) {
             m_FCal3_SumE += energy;
             FillCellInfo(caloDDE, energy, m_cell3_E, m_hit_x3, m_hit_y3, m_hit_ieta3, m_hit_iphi3, m_NCell3);
         }
     } // End loop over hits in container
  
     // Calibration hit analysis.
     if (m_calibrationRun)
         CHECK(doCalib());
  
     ATH_MSG_DEBUG("doFCal() completed successfully");
  
     return StatusCode::SUCCESS;
 }

◆ evtStore() [1/2]

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; }

◆ evtStore() [2/2]

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

inlineinherited

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

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ execute()

StatusCode LArFCalSamplingFraction::execute ( )

overridevirtual

Execute (event by event)

Definition at line 962 of file LArFCalSamplingFraction.cxx.

 {
     ATH_MSG_DEBUG(" in execute()");
  
     m_eventNumber++;
  
     // Initialize first before processing each event
     StatusCode sc = initEvent();
  
     if (sc.isFailure())
         ATH_MSG_WARNING("initEvent failed. Continue");
  
     sc = doFCal();
  
     sc = addEventInfo();
  
     if (sc.isFailure()) {
         ATH_MSG_WARNING("Failure in getEventInfo() ");
         return StatusCode::SUCCESS;
     }
  
     m_tree_AS->Fill();
  
     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();
 }

◆ FCalCalibAnalysis()

void LArFCalSamplingFraction::FCalCalibAnalysis	(	const std::string &	name,
		const CaloCalibrationHit *	CalibHit
	)

FCal Analysis with Calibration Hits on Added by JPA, June 2005.

Definition at line 666 of file LArFCalSamplingFraction.cxx.

 {
     Identifier id = CalibHit->cellID();
     double energy = CalibHit->energyTotal();
  
     m_totalFCalCalibrationEnergy += energy;
     m_FCalEm += CalibHit->energyEM();
     m_FCalNonEm += CalibHit->energyNonEM();
     m_FCalInvisible += CalibHit->energyInvisible();
     m_FCalEscaped += CalibHit->energyEscaped();
  
     if (m_larFCalID->module(id) == 1) {
         // FCal1
         m_totalFCal1CalibrationEnergy += energy;
         m_FCal1Em += CalibHit->energyEM();
         m_FCal1NonEm += CalibHit->energyNonEM();
         m_FCal1Invisible += CalibHit->energyInvisible();
         m_FCal1Escaped += CalibHit->energyEscaped();
     }
     else if (m_larFCalID->module(id) == 2) {
         // FCal2
         m_totalFCal2CalibrationEnergy += energy;
         m_FCal2Em += CalibHit->energyEM();
         m_FCal2NonEm += CalibHit->energyNonEM();
         m_FCal2Invisible += CalibHit->energyInvisible();
         m_FCal2Escaped += CalibHit->energyEscaped();
     }
     else if (m_larFCalID->module(id) == 3) {
         // FCal3
         m_totalFCal3CalibrationEnergy += energy;
         m_FCal3Em += CalibHit->energyEM();
         m_FCal3NonEm += CalibHit->energyNonEM();
         m_FCal3Invisible += CalibHit->energyInvisible();
         m_FCal3Escaped += CalibHit->energyEscaped();
     }
  
     if (name == "LArCalibrationHitActive") {
         m_FCalActive += energy;
         m_FCalActiveEm += CalibHit->energyEM();
         m_FCalActiveNonEm += CalibHit->energyNonEM();
         m_FCalActiveInvisible += CalibHit->energyInvisible();
         m_FCalActiveEscaped += CalibHit->energyEscaped();
  
         if (m_larFCalID->module(id) == 1)
             m_FCal1Active += energy;
  
         if (m_larFCalID->module(id) == 2)
             m_FCal2Active += energy;
  
         if (m_larFCalID->module(id) == 3)
             m_FCal3Active += energy;
     }
  
     if (name == "LArCalibrationHitInactive") {
         m_FCalInactive += energy;
  
         if (m_larFCalID->module(id) == 1)
             m_FCal1Inactive += energy;
  
         if (m_larFCalID->module(id) == 2)
             m_FCal2Inactive += energy;
  
         if (m_larFCalID->module(id) == 3)
             m_FCal3Inactive += energy;
     }
 }

◆ FCalClusterCenter()

void LArFCalSamplingFraction::FCalClusterCenter	(	const LArHitContainer *	container,
		const CaloDetDescrManager *	caloMgr
	)

Calculate FCal cluster center.

Definition at line 469 of file LArFCalSamplingFraction.cxx.

 {
     float xNumer1 = 0.0, xNumer2 = 0.0, xNumer3 = 0.0;
     float yNumer1 = 0.0, yNumer2 = 0.0, yNumer3 = 0.0;
     float Denom1 = 0.0, Denom2 = 0.0, Denom3 = 0.0;
  
     double subClusterSize = 30.0;  // [mm]
     double thisCG_R = 0.0;
  
     // Loop over hits in container
     for (const LArHit* hit : *container) {
  
       const CaloDetDescrElement* caloDDE = caloMgr->get_element(hit->cellID());
       if(!caloDDE->is_lar_fcal()) {
     ATH_MSG_WARNING("Hit in LarHitContainer is not a GeoFCalHit");
     continue;
       }
  
       double energy = hit->energy();
  
       int module_index = caloDDE->getLayer();
  
       double x = caloDDE->x();
       double y = caloDDE->y();
  
  
         // Determine center of cluster
         if (module_index == 1) {
             // FCal1
             double x_subcheck1 = m_cx1 - x;
             double y_subcheck1 = m_cy1 - y;
             thisCG_R = sqrt(x_subcheck1 * x_subcheck1 + y_subcheck1 * y_subcheck1);
  
             if (thisCG_R <= subClusterSize) {
                 xNumer1 += x * energy;
                 yNumer1 += y * energy;
                 Denom1 += energy;
             }
         }
         else if (module_index == 2) {
             // FCal2
             double x_subcheck2 = m_cx2 - x;
             double y_subcheck2 = m_cy2 - y;
             thisCG_R = sqrt(x_subcheck2 * x_subcheck2 + y_subcheck2 * y_subcheck2);
  
             if (thisCG_R <= subClusterSize) {
                 xNumer2 += x * energy;
                 yNumer2 += y * energy;
                 Denom2 += energy;
             }
         }
         else if (module_index == 3) {
             // FCal3
             double x_subcheck3 = m_cx3 - x;
             double y_subcheck3 = m_cy3 - y;
             thisCG_R = sqrt(x_subcheck3 * x_subcheck3 + y_subcheck3 * y_subcheck3);
  
             if (thisCG_R <= subClusterSize) {
                 xNumer3 += x * energy;
                 yNumer3 += y * energy;
                 Denom3 += energy;
             }
         }
  
     } // End loop over hits in container
  
     if (fabs(Denom1) > 0.0) {
         m_x_cc1 = xNumer1 / Denom1;
         m_y_cc1 = yNumer1 / Denom1;
     }
  
     if (fabs(Denom2) > 0.0) {
         m_x_cc2 = xNumer2 / Denom2;
         m_y_cc2 = yNumer2 / Denom2;
     }
  
     if (fabs(Denom3) > 0.0) {
         m_x_cc3 = xNumer3 / Denom3;
         m_y_cc3 = yNumer3 / Denom3;
     }
 }

◆ FCalHitCenter()

void LArFCalSamplingFraction::FCalHitCenter	(	const LArHitContainer *	container,
		const CaloDetDescrManager *	caloMgr
	)

Calculate FCal hit center.

Definition at line 413 of file LArFCalSamplingFraction.cxx.

 {
     double max1 = 0.0;
     double max2 = 0.0;
     double max3 = 0.0;
  
     // Loop over hits in container
     for (const LArHit* hit : *container) {
  
       const CaloDetDescrElement* caloDDE = caloMgr->get_element(hit->cellID());
       if(!caloDDE->is_lar_fcal()) {
     ATH_MSG_WARNING("Hit in LarHitContainer does not belong to FCAL");
     continue;
       }
  
       double energy = hit->energy();
  
       int module_index = caloDDE->getLayer();
  
       double x = caloDDE->x();
       double y = caloDDE->y();
  
         // Determine the center of the cluster for each FCal module
         if (module_index == 1) {
             // FCal1
             if (max1 < energy) {
                 max1 = energy;
                 m_cx1 = x;
                 m_cy1 = y;
             }
         }
         else if (module_index == 2) {
             // FCal2
             if (max2 < energy) {
                 max2 = energy;
                 m_cx2 = x;
                 m_cy2 = y;
             }
         }
         else if (module_index == 3) {
             // FCal3
             if (max3 < energy) {
                 max3 = energy;
                 m_cx3 = x;
                 m_cy3 = y;
             }
         }
  
     } // End loop over hits in container
 }

◆ FillCellInfo()

void LArFCalSamplingFraction::FillCellInfo	(	const CaloDetDescrElement *	caloDDE,
		double	energy,
		std::vector< double > *	cell_E,
		std::vector< double > *	hit_x,
		std::vector< double > *	hit_y,
		std::vector< double > *	hit_ieta,
		std::vector< double > *	hit_iphi,
		int &	NCell
	)

Fill FCal cell information.

Definition at line 926 of file LArFCalSamplingFraction.cxx.

 {
     const double hitx = caloDDE->x(); //tile->getX();
     const double hity = caloDDE->y(); //tile->getY();
     const double hiteta = 7;                               //tile->getIndexI();
     const double hitphi = 7;                               //tile->getIndexJ();
  
     bool cellHit = true;
  
     if (NCell != 0) {
         for (int icell = 0; icell < NCell; icell++) {
             if ((hitx == hit_x->at(icell)) && (hity == hit_y->at(icell))) {
                 cellHit = false;
                 cell_E->at(icell) += energy;
                 break;
             }
         }
     }
  
     if (cellHit) {
         cell_E->push_back(energy);
         hit_x->push_back(hitx);
         hit_y->push_back(hity);
         hit_ieta->push_back(hiteta);
         hit_iphi->push_back(hitphi);
         NCell += 1;
     }
 }

◆ finalize()

StatusCode LArFCalSamplingFraction::finalize ( )

overridevirtual

Finalize.

delete any memory allocation from the heap

Definition at line 268 of file LArFCalSamplingFraction.cxx.

 {
     return StatusCode::SUCCESS;
 }

◆ initEvent()

StatusCode LArFCalSamplingFraction::initEvent ( )

virtual

Init event.

clear CBNT members

For Athena-Aware NTuple

Definition at line 278 of file LArFCalSamplingFraction.cxx.

 {
  
     ATH_MSG_INFO("Initializing event, clearing variables");
  
     m_vertx = 0; // x-position for vertex generated particle (beam)
     m_verty = 0;
     m_vertz = 0;
  
     m_vertex_eta = 0; // eta value of generated particle
     m_vertex_phi = 0;
  
     m_pt = 0; // Momentum of generated particle
     m_px = 0;
     m_py = 0;
     m_pz = 0;
  
     m_E = 0; // Energy of generated particle
  
     m_NCell1 = 0; // Number of cells hit
     m_NCell2 = 0;
     m_NCell3 = 0;
  
     m_x_mc_cc1 = 0; // Center of cluster in x (FCal1, extrapolated)
     m_y_mc_cc1 = 0;
  
     m_x_mc_cc2 = 0; // Center of cluster in x (FCal2, extrapolated)
     m_y_mc_cc2 = 0;
  
     m_x_mc_cc3 = 0; // Center of cluster in x (FCal3, extrapolated)
     m_y_mc_cc3 = 0;
  
     m_x_cc1 = 0; // Center of cluster in x (FCal1, c of g)
     m_y_cc1 = 0;
  
     m_x_cc2 = 0; // Center of cluster in x (FCal2, c of g)
     m_y_cc2 = 0;
  
     m_x_cc3 = 0; // Center of cluster in x (FCal3, c of g)
     m_y_cc3 = 0;
  
     m_pdg_id->clear(); // particle id
  
     m_hit_x1->clear(); // hit positions of cells
     m_hit_y1->clear();
  
     m_hit_x2->clear();
     m_hit_y2->clear();
  
     m_hit_x3->clear();
     m_hit_y3->clear();
  
     m_hit_ieta1->clear(); // hit indices of cells
     m_hit_iphi1->clear();
     m_hit_ieta2->clear();
     m_hit_iphi2->clear();
     m_hit_ieta3->clear();
     m_hit_iphi3->clear();
  
     m_cell1_E->clear(); // Energy in cells
     m_cell2_E->clear();
     m_cell3_E->clear();
  
     m_FCal1_SumE = 0; // Energy in individual FCal modules
     m_FCal2_SumE = 0;
     m_FCal3_SumE = 0;
     m_TCScint_E = 0;
     m_TCIron_E = 0;
  
     m_totalFCalEnergy = 0;
     m_numHitsFCal = 0;
  
     m_totalCalibrationEnergy = 0; // Total energy
  
     // Physic Processes
     m_totalEmEnergy = 0;
     m_totalNonEmEnergy = 0;
     m_totalInvisibleEnergy = 0;
     m_totalEscapedEnergy = 0;
  
     // Energy deposited in different material categories
     m_totalActiveEnergy = 0;
     m_totalInactiveEnergy = 0;
     m_totalDeadMaterialEnergy = 0;
  
     // Number of hits in different material categories
     m_numHitsActive = 0;
     m_numHitsInactive = 0;
     m_numHitsDead = 0;
  
     // Total energy deposited in the different FCal Modules
     m_totalFCalCalibrationEnergy = 0; // Energy in all FCal
     m_totalFCal1CalibrationEnergy = 0;
     m_totalFCal2CalibrationEnergy = 0;
     m_totalFCal3CalibrationEnergy = 0;
  
     m_FCalActive = 0;
     m_FCalInactive = 0;
     m_FCalDead = 0;
     m_FCalActiveEm = 0;
     m_FCalActiveNonEm = 0;
     m_FCalActiveInvisible = 0;
     m_FCalActiveEscaped = 0;
     m_FCalEm = 0;
     m_FCal1Em = 0;
     m_FCal2Em = 0;
     m_FCal3Em = 0;
     m_FCalNonEm = 0;
     m_FCal1NonEm = 0;
     m_FCal2NonEm = 0;
     m_FCal3NonEm = 0;
     m_FCalInvisible = 0;
     m_FCal1Invisible = 0;
     m_FCal2Invisible = 0;
     m_FCal3Invisible = 0;
     m_FCalEscaped = 0;
     m_FCal1Escaped = 0;
     m_FCal2Escaped = 0;
     m_FCal3Escaped = 0;
     m_PhysTotE = 0;
     m_FCal1Active = 0;
     m_FCal2Active = 0;
     m_FCal3Active = 0;
     m_FCal1Inactive = 0;
     m_FCal2Inactive = 0;
     m_FCal3Inactive = 0;
  
     return StatusCode::SUCCESS;
 }

◆ initialize()

StatusCode LArFCalSamplingFraction::initialize ( )

overridevirtual

Initialize.

Get a handle on the analysis tools
Set up output TTree

Definition at line 73 of file LArFCalSamplingFraction.cxx.

 {
     ATH_MSG_INFO("Initializing LArFCalSamplingFraction");
  
     // Get a handle on the NTuple and histogramming service
     ServiceHandle<ITHistSvc> histSvc("THistSvc", name());
     CHECK(histSvc.retrieve());
     ATH_MSG_DEBUG(" retrieved THistSvc");
  
     const CaloIdManager *caloIdManager = nullptr;
     ATH_CHECK(detStore()->retrieve(caloIdManager));
  
     // Use just for now for Calibration... change later to GeoCalibHit
     m_larFCalID = caloIdManager->getFCAL_ID();
  
     if (m_larFCalID == 0)
         throw GaudiException("Invalid LAr FCAL ID helper", "LArHitAnalysis", StatusCode::FAILURE);
  
     // Use for now... soon change to GeoCalibHit
     m_caloCellID = caloIdManager->getCaloCell_ID();
  
     if (m_caloCellID == 0)
         throw GaudiException("Invalid Calo Cell ID helper", "LArHitAnalysis", StatusCode::FAILURE);
  
     ATH_CHECK(m_caloMgrKey.initialize());
     ATH_CHECK(m_eventInfoKey.initialize());
  
     m_pdg_id = new std::vector<int>; // particle id
  
     m_hit_x1 = new std::vector<double>; // hit positions of cells
     m_hit_y1 = new std::vector<double>;
  
     m_hit_x2 = new std::vector<double>;
     m_hit_y2 = new std::vector<double>;
  
     m_hit_x3 = new std::vector<double>;
     m_hit_y3 = new std::vector<double>;
  
     m_hit_ieta1 = new std::vector<double>; // hit indices of cells
     m_hit_iphi1 = new std::vector<double>;
     m_hit_ieta2 = new std::vector<double>;
     m_hit_iphi2 = new std::vector<double>;
     m_hit_ieta3 = new std::vector<double>;
     m_hit_iphi3 = new std::vector<double>;
  
     m_cell1_E = new std::vector<double>; // Energy in cells
     m_cell2_E = new std::vector<double>;
     m_cell3_E = new std::vector<double>;
  
     // Now add branches and leaves to the AAN tree
     m_tree_AS = new TTree("tree_AS", "TTree of AnalysisSkleton");
  
     // Event info
     m_tree_AS->Branch("Run", &m_runNumber, "Run/I");             // run number
     m_tree_AS->Branch("Event", &m_eventNumber, "Event/I");       // event number
     m_tree_AS->Branch("Time", &m_eventTime, "Time/I");           // time stamp
     m_tree_AS->Branch("LumiBlock", &m_lumiBlock, "LumiBlock/I"); // lumi block num
     m_tree_AS->Branch("BCID", &m_bCID, "BCID/I");                // bunch crossing ID
     m_tree_AS->Branch("Weight", &m_eventWeight, "Weight/D");     // weight
  
     // FCal-specific and other variables
     m_tree_AS->Branch("EFCal", &m_totalFCalEnergy, "EFCal/D");
     m_tree_AS->Branch("NHitsFCal", &m_numHitsFCal, "NhitsFCal/I");
  
     m_tree_AS->Branch("Vertex_Eta", &m_vertex_eta, "Vertex_Eta/D");
     m_tree_AS->Branch("Vertex_Phi", &m_vertex_phi, "Vertex_Phi/D");
  
     m_tree_AS->Branch("Pt", &m_pt, "Pt/D");
     m_tree_AS->Branch("px", &m_px, "px/D");
     m_tree_AS->Branch("py", &m_py, "py/D");
     m_tree_AS->Branch("pz", &m_pz, "pz/D");
     m_tree_AS->Branch("E", &m_E, "E/D");
  
     m_tree_AS->Branch("VertexX", &m_vertx, "VertexX/D");
     m_tree_AS->Branch("VertexY", &m_verty, "VertexY/D");
     m_tree_AS->Branch("VertexZ", &m_vertz, "VertexZ/D");
  
     m_tree_AS->Branch("MC_CCX1", &m_x_mc_cc1, "MC_CCX1/D");
     m_tree_AS->Branch("MC_CCY1", &m_y_mc_cc1, "MC_CCY1/D");
  
     m_tree_AS->Branch("MC_CCX2", &m_x_mc_cc2, "MC_CCX2/D");
     m_tree_AS->Branch("MC_CCY2", &m_y_mc_cc2, "MC_CCY2/D");
  
     m_tree_AS->Branch("MC_CCX3", &m_x_mc_cc3, "MC_CCX3/D");
     m_tree_AS->Branch("MC_CCY3", &m_y_mc_cc3, "MC_CCY3/D");
  
     m_tree_AS->Branch("CCX1", &m_x_cc1, "CCX1/D");
     m_tree_AS->Branch("CCY1", &m_y_cc1, "CCY1/D");
  
     m_tree_AS->Branch("CCX2", &m_x_cc2, "CCX2/D");
     m_tree_AS->Branch("CCY2", &m_y_cc2, "CCY2/D");
  
     m_tree_AS->Branch("CCX3", &m_x_cc3, "CCX3/D");
     m_tree_AS->Branch("CCY3", &m_y_cc3, "CCY3/D");
  
     m_tree_AS->Branch("NCell_1", &m_NCell1, "NCell1_1/I");
     m_tree_AS->Branch("NCell_2", &m_NCell2, "NCell1_2/I");
     m_tree_AS->Branch("NCell_3", &m_NCell3, "NCell1_3/I");
  
     m_tree_AS->Branch("ParticleID", &m_pdg_id);
  
     m_tree_AS->Branch("Hit_X1", &m_hit_x1);
     m_tree_AS->Branch("Hit_Y1", &m_hit_y1);
  
     m_tree_AS->Branch("Hit_X2", &m_hit_x2);
     m_tree_AS->Branch("Hit_Y2", &m_hit_y2);
  
     m_tree_AS->Branch("Hit_X3", &m_hit_x3);
     m_tree_AS->Branch("Hit_Y3", &m_hit_y3);
  
     m_tree_AS->Branch("Hit_eta1", &m_hit_ieta1);
     m_tree_AS->Branch("Hit_phi1", &m_hit_iphi1);
     m_tree_AS->Branch("Hit_eta2", &m_hit_ieta2);
     m_tree_AS->Branch("Hit_phi2", &m_hit_iphi2);
     m_tree_AS->Branch("Hit_eta3", &m_hit_ieta3);
     m_tree_AS->Branch("Hit_phi3", &m_hit_iphi3);
  
     m_tree_AS->Branch("Cell1_E", &m_cell1_E);
     m_tree_AS->Branch("Cell2_E", &m_cell2_E);
     m_tree_AS->Branch("Cell3_E", &m_cell3_E);
  
     m_tree_AS->Branch("FCal1_E", &m_FCal1_SumE, "FCal1_E/D");
     m_tree_AS->Branch("FCal2_E", &m_FCal2_SumE, "FCal2_E/D");
     m_tree_AS->Branch("FCal3_E", &m_FCal3_SumE, "FCal3_E/D");
  
     if (m_calibrationRun) {
         m_caloDmID = caloIdManager->getDM_ID();
  
         if (m_caloDmID == 0)
             throw GaudiException("Invalid Calo DM ID helper", "LArFCalTB_MC_CBNT_AA", StatusCode::FAILURE);
  
         // Define the hit containers that we'll analyze in this program.
         // For now, initialize the pointers to the containers to NULL (zero).
         m_calibHitMap["LArCalibrationHitActive"] = 0;
         m_calibHitMap["LArCalibrationHitInactive"] = 0;
         m_calibHitMap["LArCalibrationHitDeadMaterial"] = 0;
  
         m_tree_AS->Branch("Calib_TotalEnergy", &m_totalCalibrationEnergy, "Calib_TotalEnergy/D");
         m_tree_AS->Branch("Calib_TotalEm", &m_totalEmEnergy, "Calib_TotalEm/D");
         m_tree_AS->Branch("Calib_TotalNonEm", &m_totalNonEmEnergy, "Calib_TotalNonEm/D");
         m_tree_AS->Branch("Calib_TotalInvisible", &m_totalInvisibleEnergy, "Calib_TotalInvisible/D");
         m_tree_AS->Branch("Calib_TotalEscaped", &m_totalEscapedEnergy, "Calib_TotalEscaped/D");
         m_tree_AS->Branch("Calib_FCalEnergy", &m_totalFCalCalibrationEnergy, "Calib_FCalEnergy/D");
         m_tree_AS->Branch("Calib_TotalActive", &m_totalActiveEnergy, "Calib_TotalActive/D");
         m_tree_AS->Branch("Calib_TotalInactive", &m_totalInactiveEnergy, "Calib_TotalInactive/D");
         m_tree_AS->Branch("Calib_DeadEnergy", &m_totalDeadMaterialEnergy, "Calib_DeadEnergy/D");
         m_tree_AS->Branch("Calib_NHitsInactive", &m_numHitsInactive, "Calib_NHitsInactive/I");
         m_tree_AS->Branch("Calib_NHitsDead", &m_numHitsDead, "Calib_NHitsDead/I");
         m_tree_AS->Branch("Calib_FCal1Energy", &m_totalFCal1CalibrationEnergy, "Calib_FCal1Energy/D");
         m_tree_AS->Branch("Calib_FCal2Energy", &m_totalFCal2CalibrationEnergy, "Calib_FCal2Energy/D");
         m_tree_AS->Branch("Calib_FCal3Energy", &m_totalFCal3CalibrationEnergy, "Calib_FCal3Energy/D");
  
         m_tree_AS->Branch("Calib_FCalActive", &m_FCalActive, "Calib_FCalActive/D");
         m_tree_AS->Branch("Calib_FCalInactive", &m_FCalInactive, "Calib_FCalInactive/D");
         m_tree_AS->Branch("Calib_FCalDead", &m_FCalDead, "Calib_FCalDead/D");
         m_tree_AS->Branch("Calib_FCalEm", &m_FCalEm, "Calib_FCalEm/D");
         m_tree_AS->Branch("Calib_FCal1Em", &m_FCal1Em, "Calib_FCal1Em/D");
         m_tree_AS->Branch("Calib_FCal2Em", &m_FCal2Em, "Calib_FCal2Em/D");
         m_tree_AS->Branch("Calib_FCal3Em", &m_FCal3Em, "Calib_FCal3Em/D");
         m_tree_AS->Branch("Calib_FCalNonEm", &m_FCalNonEm, "Calib_FCalNonEm/D");
         m_tree_AS->Branch("Calib_FCal1NonEm", &m_FCal1NonEm, "Calib_FCal1NonEm/D");
         m_tree_AS->Branch("Calib_FCal2NonEm", &m_FCal2NonEm, "Calib_FCal2NonEm/D");
         m_tree_AS->Branch("Calib_FCal3NonEm", &m_FCal3NonEm, "Calib_FCal3NonEm/D");
         m_tree_AS->Branch("Calib_FCalInvisible", &m_FCalInvisible, "Calib_FCalInvisible/D");
         m_tree_AS->Branch("Calib_FCal1Invisible", &m_FCal1Invisible, "Calib_FCal1Invisible/D");
         m_tree_AS->Branch("Calib_FCal2Invisible", &m_FCal2Invisible, "Calib_FCal2Invisible/D");
         m_tree_AS->Branch("Calib_FCal3Invisible", &m_FCal3Invisible, "Calib_FCal3Invisible/D");
         m_tree_AS->Branch("Calib_FCalEscaped", &m_FCalEscaped, "Calib_FCalEscaped/D");
         m_tree_AS->Branch("Calib_FCal1Escaped", &m_FCal1Escaped, "Calib_FCal1Escaped/D");
         m_tree_AS->Branch("Calib_FCal2Escaped", &m_FCal2Escaped, "Calib_FCal2Escaped/D");
         m_tree_AS->Branch("Calib_FCal3Escaped", &m_FCal3Escaped, "Calib_FCal3Escaped/D");
         m_tree_AS->Branch("Calib_FCal1Active", &m_FCal1Active, "Calib_FCal1Active/D");
         m_tree_AS->Branch("Calib_FCal2Active", &m_FCal2Active, "Calib_FCal2Active/D");
         m_tree_AS->Branch("Calib_FCal3Active", &m_FCal3Active, "Calib_FCal3Active/D");
         m_tree_AS->Branch("Calib_FCal1Inactive", &m_FCal1Inactive, "Calib_FCal1Inactive/D");
         m_tree_AS->Branch("Calib_FCal2Inactive", &m_FCal2Inactive, "Calib_FCal2Inactive/D");
         m_tree_AS->Branch("Calib_FCal3Inactive", &m_FCal3Inactive, "Calib_FCal3Inactive/D");
         m_tree_AS->Branch("Calib_FCalActiveEm", &m_FCalActiveEm, "Calib_FCalActiveEm/D");
         m_tree_AS->Branch("Calib_FCalActiveNonEm", &m_FCalActiveNonEm, "Calib_FCalActiveNonEm/D");
         m_tree_AS->Branch("Calib_FCalActiveInvisible", &m_FCalActiveInvisible, "Calib_FCalActiveInvisible/D");
         m_tree_AS->Branch("Calib_FCalActiveEscaped", &m_FCalActiveEscaped, "Calib_FCalActiveEscaped/D");
     }
  
     CHECK(histSvc->regTree("/AANT/tree_AS", m_tree_AS));
  
     m_eventNumber = 0;
  
     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() [1/2]

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                 {
     return this->msgStream();
   }

◆ msg() [2/2]

MsgStream& AthCommonMsg< Algorithm >::msg ( const MSG::Level lvl ) const

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                   {
     return this->msgStream(lvl);
   }

◆ 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, PyAthena::Alg, and AthHistogramAlgorithm.

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.

◆ TruthImpactPosition()

void LArFCalSamplingFraction::TruthImpactPosition ( const HepMC::GenEvent * e )

Calculate truth impact position.

Definition at line 738 of file LArFCalSamplingFraction.cxx.

 {
   for (const auto& theParticle: *e)
     {
         // Note: old GenParticles used HepLorentzVectors, now they use HepMC::FourVectors
  
         // Get the kinematic variables
         const HepMC::FourVector& HMCmom = theParticle->momentum();
         CLHEP::HepLorentzVector momentum(CLHEP::Hep3Vector(HMCmom.px(), HMCmom.py(), HMCmom.pz()), HMCmom.e());
  
         HepMC::FourVector HMC3vec(0.0,0.0,0.0,0.0);
         if (theParticle->production_vertex()) HMC3vec = theParticle->production_vertex()->position();
         HepGeom::Point3D<double> origin = HepGeom::Point3D<double>(HMC3vec.x(), HMC3vec.y(), HMC3vec.z());
  
         // Put VEta and VPhi into the Ntuple
         m_vertex_phi = momentum.vect().phi();
         m_vertex_eta = -log(tan(momentum.vect().theta() / 2));
  
         if (!finite(m_vertex_eta))
             m_vertex_eta = 0;
  
         m_pt = momentum.vect().perp();
  
         m_px = momentum.px();
         m_py = momentum.py();
         m_pz = momentum.pz();
  
         m_E = momentum.e();
  
         m_vertx = theParticle->production_vertex()->position().x();
         m_verty = theParticle->production_vertex()->position().y();
         m_vertz = theParticle->production_vertex()->position().z();
  
         // Must get x-offset depending on TB position. The 90.0 mm is from the
         // initial x-offset of FCal in cryostat. The -15.0 mm is from the
         // initial y-offset of FCal in cryostat. The second number changes
         // between different positions (these numbers will be in database soon)
  
         std::string nickname;
         double xoffset = 0;
         double sinangle = 0;
         double yoffset = 0;
         const double z1 = -32668.5 * CLHEP::mm; // This is 4668.5 (z=0 to FCal1 Face) + 28000 (B9 to z=0)
         const double z2 = -33128.3 * CLHEP::mm; // This is 5128.3 (z=0 to FCal1 Face) + 28000 (B9 to z=0)
         const double z3 = -33602.8 * CLHEP::mm; // This is 5602.8 (z=0 to FCal1 Face) + 28000 (B9 to z=0)
  
         double shift2 = sinangle * (5128.3 - 4668.5) * CLHEP::mm;
         double shift3 = sinangle * (5602.8 - 4668.5) * CLHEP::mm;
  
         // Accounts for rotation of Fcal + cryostat.
         m_x_mc_cc1 = origin.x() + m_px * z1 / m_pz + xoffset;
         m_y_mc_cc1 = origin.y() + m_py * z1 / m_pz + yoffset;
  
         m_x_mc_cc2 = origin.x() + m_px * z2 / m_pz + shift2 + xoffset;
         m_y_mc_cc2 = origin.y() + m_py * z2 / m_pz + yoffset;
  
         m_x_mc_cc3 = origin.x() + m_px * z3 / m_pz + shift3 + xoffset;
         m_y_mc_cc3 = origin.y() + m_py * z3 / m_pz + yoffset;
  
     } // particles
 }

◆ 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_bCID

unsigned int LArFCalSamplingFraction::m_bCID {}

private

Definition at line 83 of file LArFCalSamplingFraction.h.

◆ m_calibHitMap

m_calibHitMap_t LArFCalSamplingFraction::m_calibHitMap

private

Definition at line 221 of file LArFCalSamplingFraction.h.

◆ m_calibrationRun

bool LArFCalSamplingFraction::m_calibrationRun

private

Definition at line 215 of file LArFCalSamplingFraction.h.

◆ m_caloCellID

const CaloCell_ID* LArFCalSamplingFraction::m_caloCellID {}

private

Definition at line 211 of file LArFCalSamplingFraction.h.

◆ m_caloDmID

const CaloDM_ID* LArFCalSamplingFraction::m_caloDmID {}

private

Definition at line 210 of file LArFCalSamplingFraction.h.

◆ m_caloMgrKey

SG::ReadCondHandleKey<CaloDetDescrManager> LArFCalSamplingFraction::m_caloMgrKey

private

Initial value:

{ this
    , "CaloDetDescrManager"
    , "CaloDetDescrManager"
    , "SG Key for CaloDetDescrManager in the Condition Store" }

Definition at line 71 of file LArFCalSamplingFraction.h.

◆ m_cell1_E

std::vector<double>* LArFCalSamplingFraction::m_cell1_E {}

private

Definition at line 141 of file LArFCalSamplingFraction.h.

◆ m_cell2_E

std::vector<double>* LArFCalSamplingFraction::m_cell2_E {}

private

Definition at line 142 of file LArFCalSamplingFraction.h.

◆ m_cell3_E

std::vector<double>* LArFCalSamplingFraction::m_cell3_E {}

private

Definition at line 143 of file LArFCalSamplingFraction.h.

◆ m_cx1

double LArFCalSamplingFraction::m_cx1

private

Definition at line 224 of file LArFCalSamplingFraction.h.

◆ m_cx2

double LArFCalSamplingFraction::m_cx2

private

Definition at line 224 of file LArFCalSamplingFraction.h.

◆ m_cx3

double LArFCalSamplingFraction::m_cx3

private

Definition at line 224 of file LArFCalSamplingFraction.h.

◆ m_cy1

double LArFCalSamplingFraction::m_cy1

private

Definition at line 225 of file LArFCalSamplingFraction.h.

◆ m_cy2

double LArFCalSamplingFraction::m_cy2

private

Definition at line 225 of file LArFCalSamplingFraction.h.

◆ m_cy3

double LArFCalSamplingFraction::m_cy3

private

Definition at line 225 of file LArFCalSamplingFraction.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_E

double LArFCalSamplingFraction::m_E {}

private

Definition at line 99 of file LArFCalSamplingFraction.h.

◆ m_eventInfoKey

SG::ReadHandleKey<xAOD::EventInfo> LArFCalSamplingFraction::m_eventInfoKey {this, "EventInfoKey", "EventInfo"}

private

Definition at line 69 of file LArFCalSamplingFraction.h.

◆ m_eventNumber

unsigned int LArFCalSamplingFraction::m_eventNumber {}

private

Definition at line 80 of file LArFCalSamplingFraction.h.

◆ m_eventTime

unsigned int LArFCalSamplingFraction::m_eventTime {}

private

Definition at line 81 of file LArFCalSamplingFraction.h.

◆ m_eventWeight

double LArFCalSamplingFraction::m_eventWeight {}

private

Definition at line 84 of file LArFCalSamplingFraction.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_FCal1_SumE

double LArFCalSamplingFraction::m_FCal1_SumE {}

private

Definition at line 145 of file LArFCalSamplingFraction.h.

◆ m_FCal1Active

double LArFCalSamplingFraction::m_FCal1Active {}

private

Definition at line 203 of file LArFCalSamplingFraction.h.

◆ m_FCal1Em

double LArFCalSamplingFraction::m_FCal1Em {}

private

Definition at line 187 of file LArFCalSamplingFraction.h.

◆ m_FCal1Escaped

double LArFCalSamplingFraction::m_FCal1Escaped {}

private

Definition at line 199 of file LArFCalSamplingFraction.h.

◆ m_FCal1Inactive

double LArFCalSamplingFraction::m_FCal1Inactive {}

private

Definition at line 206 of file LArFCalSamplingFraction.h.

◆ m_FCal1Invisible

double LArFCalSamplingFraction::m_FCal1Invisible {}

private

Definition at line 195 of file LArFCalSamplingFraction.h.

◆ m_FCal1NonEm

double LArFCalSamplingFraction::m_FCal1NonEm {}

private

Definition at line 191 of file LArFCalSamplingFraction.h.

◆ m_FCal2_SumE

double LArFCalSamplingFraction::m_FCal2_SumE {}

private

Definition at line 146 of file LArFCalSamplingFraction.h.

◆ m_FCal2Active

double LArFCalSamplingFraction::m_FCal2Active {}

private

Definition at line 204 of file LArFCalSamplingFraction.h.

◆ m_FCal2Em

double LArFCalSamplingFraction::m_FCal2Em {}

private

Definition at line 188 of file LArFCalSamplingFraction.h.

◆ m_FCal2Escaped

double LArFCalSamplingFraction::m_FCal2Escaped {}

private

Definition at line 200 of file LArFCalSamplingFraction.h.

◆ m_FCal2Inactive

double LArFCalSamplingFraction::m_FCal2Inactive {}

private

Definition at line 207 of file LArFCalSamplingFraction.h.

◆ m_FCal2Invisible

double LArFCalSamplingFraction::m_FCal2Invisible {}

private

Definition at line 196 of file LArFCalSamplingFraction.h.

◆ m_FCal2NonEm

double LArFCalSamplingFraction::m_FCal2NonEm {}

private

Definition at line 192 of file LArFCalSamplingFraction.h.

◆ m_FCal3_SumE

double LArFCalSamplingFraction::m_FCal3_SumE {}

private

Definition at line 147 of file LArFCalSamplingFraction.h.

◆ m_FCal3Active

double LArFCalSamplingFraction::m_FCal3Active {}

private

Definition at line 205 of file LArFCalSamplingFraction.h.

◆ m_FCal3Em

double LArFCalSamplingFraction::m_FCal3Em {}

private

Definition at line 189 of file LArFCalSamplingFraction.h.

◆ m_FCal3Escaped

double LArFCalSamplingFraction::m_FCal3Escaped {}

private

Definition at line 201 of file LArFCalSamplingFraction.h.

◆ m_FCal3Inactive

double LArFCalSamplingFraction::m_FCal3Inactive {}

private

Definition at line 208 of file LArFCalSamplingFraction.h.

◆ m_FCal3Invisible

double LArFCalSamplingFraction::m_FCal3Invisible {}

private

Definition at line 197 of file LArFCalSamplingFraction.h.

◆ m_FCal3NonEm

double LArFCalSamplingFraction::m_FCal3NonEm {}

private

Definition at line 193 of file LArFCalSamplingFraction.h.

◆ m_FCalActive

double LArFCalSamplingFraction::m_FCalActive {}

private

Definition at line 179 of file LArFCalSamplingFraction.h.

◆ m_FCalActiveEm

double LArFCalSamplingFraction::m_FCalActiveEm {}

private

Definition at line 182 of file LArFCalSamplingFraction.h.

◆ m_FCalActiveEscaped

double LArFCalSamplingFraction::m_FCalActiveEscaped {}

private

Definition at line 185 of file LArFCalSamplingFraction.h.

◆ m_FCalActiveInvisible

double LArFCalSamplingFraction::m_FCalActiveInvisible {}

private

Definition at line 184 of file LArFCalSamplingFraction.h.

◆ m_FCalActiveNonEm

double LArFCalSamplingFraction::m_FCalActiveNonEm {}

private

Definition at line 183 of file LArFCalSamplingFraction.h.

◆ m_FCalDead

double LArFCalSamplingFraction::m_FCalDead {}

private

Definition at line 181 of file LArFCalSamplingFraction.h.

◆ m_FCalEm

double LArFCalSamplingFraction::m_FCalEm {}

private

Definition at line 186 of file LArFCalSamplingFraction.h.

◆ m_FCalEscaped

double LArFCalSamplingFraction::m_FCalEscaped {}

private

Definition at line 198 of file LArFCalSamplingFraction.h.

◆ m_FCalInactive

double LArFCalSamplingFraction::m_FCalInactive {}

private

Definition at line 180 of file LArFCalSamplingFraction.h.

◆ m_FCalInvisible

double LArFCalSamplingFraction::m_FCalInvisible {}

private

Definition at line 194 of file LArFCalSamplingFraction.h.

◆ m_FCalNonEm

double LArFCalSamplingFraction::m_FCalNonEm {}

private

Definition at line 190 of file LArFCalSamplingFraction.h.

◆ m_hit_ieta1

std::vector<double>* LArFCalSamplingFraction::m_hit_ieta1 {}

private

Definition at line 134 of file LArFCalSamplingFraction.h.

◆ m_hit_ieta2

std::vector<double>* LArFCalSamplingFraction::m_hit_ieta2 {}

private

Definition at line 136 of file LArFCalSamplingFraction.h.

◆ m_hit_ieta3

std::vector<double>* LArFCalSamplingFraction::m_hit_ieta3 {}

private

Definition at line 138 of file LArFCalSamplingFraction.h.

◆ m_hit_iphi1

std::vector<double>* LArFCalSamplingFraction::m_hit_iphi1 {}

private

Definition at line 135 of file LArFCalSamplingFraction.h.

◆ m_hit_iphi2

std::vector<double>* LArFCalSamplingFraction::m_hit_iphi2 {}

private

Definition at line 137 of file LArFCalSamplingFraction.h.

◆ m_hit_iphi3

std::vector<double>* LArFCalSamplingFraction::m_hit_iphi3 {}

private

Definition at line 139 of file LArFCalSamplingFraction.h.

◆ m_hit_x1

std::vector<double>* LArFCalSamplingFraction::m_hit_x1 {}

private

Definition at line 125 of file LArFCalSamplingFraction.h.

◆ m_hit_x2

std::vector<double>* LArFCalSamplingFraction::m_hit_x2 {}

private

Definition at line 128 of file LArFCalSamplingFraction.h.

◆ m_hit_x3

std::vector<double>* LArFCalSamplingFraction::m_hit_x3 {}

private

Definition at line 131 of file LArFCalSamplingFraction.h.

◆ m_hit_y1

std::vector<double>* LArFCalSamplingFraction::m_hit_y1 {}

private

Definition at line 126 of file LArFCalSamplingFraction.h.

◆ m_hit_y2

std::vector<double>* LArFCalSamplingFraction::m_hit_y2 {}

private

Definition at line 129 of file LArFCalSamplingFraction.h.

◆ m_hit_y3

std::vector<double>* LArFCalSamplingFraction::m_hit_y3 {}

private

Definition at line 132 of file LArFCalSamplingFraction.h.

◆ m_larFCalID

const LArFCAL_ID* LArFCalSamplingFraction::m_larFCalID {}

private

Definition at line 212 of file LArFCalSamplingFraction.h.

◆ m_lumiBlock

unsigned int LArFCalSamplingFraction::m_lumiBlock {}

private

Definition at line 82 of file LArFCalSamplingFraction.h.

◆ m_NCell1

int LArFCalSamplingFraction::m_NCell1 {}

private

Definition at line 101 of file LArFCalSamplingFraction.h.

◆ m_NCell2

int LArFCalSamplingFraction::m_NCell2 {}

private

Definition at line 102 of file LArFCalSamplingFraction.h.

◆ m_NCell3

int LArFCalSamplingFraction::m_NCell3 {}

private

Definition at line 103 of file LArFCalSamplingFraction.h.

◆ m_numHitsActive

int LArFCalSamplingFraction::m_numHitsActive {}

private

Definition at line 169 of file LArFCalSamplingFraction.h.

◆ m_numHitsDead

int LArFCalSamplingFraction::m_numHitsDead {}

private

Definition at line 171 of file LArFCalSamplingFraction.h.

◆ m_numHitsFCal

int LArFCalSamplingFraction::m_numHitsFCal {}

private

Definition at line 152 of file LArFCalSamplingFraction.h.

◆ m_numHitsInactive

int LArFCalSamplingFraction::m_numHitsInactive {}

private

Definition at line 170 of file LArFCalSamplingFraction.h.

◆ m_pdg_id

std::vector<int>* LArFCalSamplingFraction::m_pdg_id {}

private

Definition at line 123 of file LArFCalSamplingFraction.h.

◆ m_PhysTotE

double LArFCalSamplingFraction::m_PhysTotE {}

private

Definition at line 202 of file LArFCalSamplingFraction.h.

◆ m_pt

double LArFCalSamplingFraction::m_pt {}

private

Definition at line 94 of file LArFCalSamplingFraction.h.

◆ m_px

double LArFCalSamplingFraction::m_px {}

private

Definition at line 95 of file LArFCalSamplingFraction.h.

◆ m_py

double LArFCalSamplingFraction::m_py {}

private

Definition at line 96 of file LArFCalSamplingFraction.h.

◆ m_pz

double LArFCalSamplingFraction::m_pz {}

private

Definition at line 97 of file LArFCalSamplingFraction.h.

◆ m_runNumber

unsigned int LArFCalSamplingFraction::m_runNumber {}

private

Definition at line 79 of file LArFCalSamplingFraction.h.

◆ m_TCIron_E

double LArFCalSamplingFraction::m_TCIron_E {}

private

Definition at line 149 of file LArFCalSamplingFraction.h.

◆ m_TCScint_E

double LArFCalSamplingFraction::m_TCScint_E {}

private

Definition at line 148 of file LArFCalSamplingFraction.h.

◆ m_totalActiveEnergy

double LArFCalSamplingFraction::m_totalActiveEnergy {}

private

Definition at line 164 of file LArFCalSamplingFraction.h.

◆ m_totalCalibrationEnergy

double LArFCalSamplingFraction::m_totalCalibrationEnergy {}

private

Definition at line 155 of file LArFCalSamplingFraction.h.

◆ m_totalDeadMaterialEnergy

double LArFCalSamplingFraction::m_totalDeadMaterialEnergy {}

private

Definition at line 166 of file LArFCalSamplingFraction.h.

◆ m_totalEmEnergy

double LArFCalSamplingFraction::m_totalEmEnergy {}

private

Definition at line 158 of file LArFCalSamplingFraction.h.

◆ m_totalEscapedEnergy

double LArFCalSamplingFraction::m_totalEscapedEnergy {}

private

Definition at line 161 of file LArFCalSamplingFraction.h.

◆ m_totalFCal1CalibrationEnergy

double LArFCalSamplingFraction::m_totalFCal1CalibrationEnergy {}

private

Definition at line 175 of file LArFCalSamplingFraction.h.

◆ m_totalFCal2CalibrationEnergy

double LArFCalSamplingFraction::m_totalFCal2CalibrationEnergy {}

private

Definition at line 176 of file LArFCalSamplingFraction.h.

◆ m_totalFCal3CalibrationEnergy

double LArFCalSamplingFraction::m_totalFCal3CalibrationEnergy {}

private

Definition at line 177 of file LArFCalSamplingFraction.h.

◆ m_totalFCalCalibrationEnergy

double LArFCalSamplingFraction::m_totalFCalCalibrationEnergy {}

private

Definition at line 174 of file LArFCalSamplingFraction.h.

◆ m_totalFCalEnergy

double LArFCalSamplingFraction::m_totalFCalEnergy {}

private

Definition at line 151 of file LArFCalSamplingFraction.h.

◆ m_totalInactiveEnergy

double LArFCalSamplingFraction::m_totalInactiveEnergy {}

private

Definition at line 165 of file LArFCalSamplingFraction.h.

◆ m_totalInvisibleEnergy

double LArFCalSamplingFraction::m_totalInvisibleEnergy {}

private

Definition at line 160 of file LArFCalSamplingFraction.h.

◆ m_totalNonEmEnergy

double LArFCalSamplingFraction::m_totalNonEmEnergy {}

private

Definition at line 159 of file LArFCalSamplingFraction.h.

◆ m_tree_AS

TTree* LArFCalSamplingFraction::m_tree_AS {}

private

Athena-Aware Ntuple (AAN) variables - branches of the AAN TTree.

Definition at line 77 of file LArFCalSamplingFraction.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Algorithm > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vertex_eta

double LArFCalSamplingFraction::m_vertex_eta {}

private

Definition at line 91 of file LArFCalSamplingFraction.h.

◆ m_vertex_phi

double LArFCalSamplingFraction::m_vertex_phi {}

private

Definition at line 92 of file LArFCalSamplingFraction.h.

◆ m_vertx

double LArFCalSamplingFraction::m_vertx {}

private

Definition at line 87 of file LArFCalSamplingFraction.h.

◆ m_verty

double LArFCalSamplingFraction::m_verty {}

private

Definition at line 88 of file LArFCalSamplingFraction.h.

◆ m_vertz

double LArFCalSamplingFraction::m_vertz {}

private

Definition at line 89 of file LArFCalSamplingFraction.h.

◆ m_vhka

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

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

◆ m_x_cc1

double LArFCalSamplingFraction::m_x_cc1 {}

private

Definition at line 114 of file LArFCalSamplingFraction.h.

◆ m_x_cc2

double LArFCalSamplingFraction::m_x_cc2 {}

private

Definition at line 117 of file LArFCalSamplingFraction.h.

◆ m_x_cc3

double LArFCalSamplingFraction::m_x_cc3 {}

private

Definition at line 120 of file LArFCalSamplingFraction.h.

◆ m_x_mc_cc1

double LArFCalSamplingFraction::m_x_mc_cc1 {}

private

Definition at line 105 of file LArFCalSamplingFraction.h.

◆ m_x_mc_cc2

double LArFCalSamplingFraction::m_x_mc_cc2 {}

private

Definition at line 108 of file LArFCalSamplingFraction.h.

◆ m_x_mc_cc3

double LArFCalSamplingFraction::m_x_mc_cc3 {}

private

Definition at line 111 of file LArFCalSamplingFraction.h.

◆ m_y_cc1

double LArFCalSamplingFraction::m_y_cc1 {}

private

Definition at line 115 of file LArFCalSamplingFraction.h.

◆ m_y_cc2

double LArFCalSamplingFraction::m_y_cc2 {}

private

Definition at line 118 of file LArFCalSamplingFraction.h.

◆ m_y_cc3

double LArFCalSamplingFraction::m_y_cc3 {}

private

Definition at line 121 of file LArFCalSamplingFraction.h.

◆ m_y_mc_cc1

double LArFCalSamplingFraction::m_y_mc_cc1 {}

private

Definition at line 106 of file LArFCalSamplingFraction.h.

◆ m_y_mc_cc2

double LArFCalSamplingFraction::m_y_mc_cc2 {}

private

Definition at line 109 of file LArFCalSamplingFraction.h.

◆ m_y_mc_cc3

double LArFCalSamplingFraction::m_y_mc_cc3 {}

private

Definition at line 112 of file LArFCalSamplingFraction.h.

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

Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ m_calibHitMap_ptr_t

◆ m_calibHitMap_t

◆ StoreGateSvc_t

Constructor & Destructor Documentation

◆ LArFCalSamplingFraction()

◆ ~LArFCalSamplingFraction()

Member Function Documentation

◆ addEventInfo()

◆ declareGaudiProperty() [1/4]

◆ declareGaudiProperty() [2/4]

◆ declareGaudiProperty() [3/4]

◆ declareGaudiProperty() [4/4]

◆ declareProperty() [1/6]

◆ declareProperty() [2/6]

◆ declareProperty() [3/6]

◆ declareProperty() [4/6]

◆ declareProperty() [5/6]

◆ declareProperty() [6/6]

◆ detStore()

◆ doCalib()

◆ doFCal()

◆ evtStore() [1/2]

◆ evtStore() [2/2]

◆ execute()

◆ extraDeps_update_handler()

◆ extraOutputDeps()

◆ FCalCalibAnalysis()

◆ FCalClusterCenter()

◆ FCalHitCenter()

◆ FillCellInfo()

◆ finalize()

◆ initEvent()

◆ initialize()

◆ inputHandles()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msgLvl()

◆ outputHandles()

◆ renounce()

◆ renounceArray()

◆ sysInitialize()

◆ sysStart()

◆ TruthImpactPosition()

◆ updateVHKA()

Member Data Documentation

◆ m_bCID

◆ m_calibHitMap

◆ m_calibrationRun

◆ m_caloCellID

◆ m_caloDmID

◆ m_caloMgrKey

◆ m_cell1_E

◆ m_cell2_E

◆ m_cell3_E

◆ m_cx1

◆ m_cx2

◆ m_cx3

◆ m_cy1

◆ m_cy2

◆ m_cy3

◆ m_detStore

◆ m_E

◆ m_eventInfoKey

◆ m_eventNumber

◆ m_eventTime

◆ m_eventWeight

◆ m_evtStore

◆ m_extendedExtraObjects

◆ m_FCal1_SumE

◆ m_FCal1Active

◆ m_FCal1Em

◆ m_FCal1Escaped

◆ m_FCal1Inactive