LArFCalSamplingFraction Class Reference

#include <LArFCalSamplingFraction.h>

Inheritance diagram for LArFCalSamplingFraction:

Collaboration diagram for LArFCalSamplingFraction:

Public Member Functions
	LArFCalSamplingFraction (const std::string &name, ISvcLocator *pSvcLocator)
	Constructor.
	~LArFCalSamplingFraction ()
	Destructor.
virtual StatusCode	initialize () override
	Initialize.
virtual StatusCode	finalize () override
	Finalize.
virtual StatusCode	execute () override
	Execute (event by event)
virtual StatusCode	initEvent ()
	Init event.
StatusCode	doFCal ()
	The main FCal analysis method.
void	TruthImpactPosition (const HepMC::GenEvent *e)
	Calculate truth impact position.
void	FCalCalibAnalysis (const std::string &name, const CaloCalibrationHit *CalibHit)
	FCal Analysis with Calibration Hits on Added by JPA, June 2005.
void	FCalClusterCenter (const LArHitContainer *container, const CaloDetDescrManager *caloMgr)
	Calculate FCal cluster center.
void	FCalHitCenter (const LArHitContainer *container, const CaloDetDescrManager *caloMgr)
	Calculate FCal hit center.
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.
StatusCode	doCalib ()
	Calibration hit analysis.
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

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
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()
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

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.
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)
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default)
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

Definition at line 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.

{}

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()

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

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()

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 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()

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.

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.

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

m_cell1_E

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

private

Definition at line 141 of file LArFCalSamplingFraction.h.

{}; // Energy in cells

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.

{}; // Energy of generated particle

m_eventInfoKey

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

private

Definition at line 69 of file LArFCalSamplingFraction.h.

{this, "EventInfoKey", "EventInfo"};

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.

{}; // Energy in individual FCal modules

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.

{}; // hit indices of cells

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.

{}; // hit positions of cells

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.

{}; // Number of cells hit

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.

{};  // particle id

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.

{}; // Momentum of generated particle

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.

{}; // Total energy

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.

{}; // Energy in all FCal

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.

{}; // eta value of generated particle

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.

{}; // x-position for vertex generated particle (beam)

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.

{}; // Center of cluster in x (FCal1, c of g)

m_x_cc2

double LArFCalSamplingFraction::m_x_cc2 {}

private

Definition at line 117 of file LArFCalSamplingFraction.h.

{}; // Center of cluster in x (FCal2, c of g)

m_x_cc3

double LArFCalSamplingFraction::m_x_cc3 {}

private

Definition at line 120 of file LArFCalSamplingFraction.h.

{}; // Center of cluster in x (FCal3, c of g)

m_x_mc_cc1

double LArFCalSamplingFraction::m_x_mc_cc1 {}

private

Definition at line 105 of file LArFCalSamplingFraction.h.

{}; // Center of cluster in x (FCal1, extrapolated)

m_x_mc_cc2

double LArFCalSamplingFraction::m_x_mc_cc2 {}

private

Definition at line 108 of file LArFCalSamplingFraction.h.

{}; // Center of cluster in x (FCal2, extrapolated)

m_x_mc_cc3

double LArFCalSamplingFraction::m_x_mc_cc3 {}

private

Definition at line 111 of file LArFCalSamplingFraction.h.

{}; // Center of cluster in x (FCal3, extrapolated)

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:

• LArFCalSamplingFraction.h
• LArFCalSamplingFraction.cxx