LArFCalSamplingFraction.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef LAR_FCAL_SAMPLING_FRACTION_H
#define LAR_FCAL_SAMPLING_FRACTION_H
 
// C++ stdlib
#include <string>
 
// ATLAS Software
#include "AthenaBaseComps/AthAlgorithm.h"
#include "CLHEP/Units/SystemOfUnits.h"
#include "GaudiKernel/ITHistSvc.h"
#include "GaudiKernel/ObjectVector.h"
#include "GaudiKernel/ToolHandle.h"
#include "GeneratorObjects/McEventCollection.h"
#include "LArSimEvent/LArHit.h"
#include "LArSimEvent/LArHitContainer.h"
#include "StoreGate/StoreGateSvc.h"
#include "CaloDetDescr/CaloDetDescrManager.h"
#include "StoreGate/ReadHandleKey.h"
#include "StoreGate/ReadCondHandleKey.h"
#include "xAODEventInfo/EventInfo.h"
 
class JetCollection;
class ISvcLocator;
class StoreGateSvc;
class LArFCAL_ID;
class CaloDM_ID;
class CaloCell_ID;
class LArHitContainer;
class CaloDetDescrElement;
class CaloCalibrationHit;
class CaloCalibrationHitContainer;
class TCECollection;
class TCEnergies;
 
 
class LArFCalSamplingFraction : public AthAlgorithm
{
public:
    LArFCalSamplingFraction(const std::string &name, ISvcLocator *pSvcLocator);
    ~LArFCalSamplingFraction();
 
    virtual StatusCode initialize() override;
    virtual StatusCode finalize() override;
    virtual StatusCode execute() override;
    virtual StatusCode initEvent();
    StatusCode doFCal();
    void TruthImpactPosition(const HepMC::GenEvent *e);
 
    void FCalCalibAnalysis(const std::string& name, const CaloCalibrationHit *CalibHit);
    void FCalClusterCenter(const LArHitContainer *container, const CaloDetDescrManager* caloMgr);
    void FCalHitCenter(const LArHitContainer *container, const CaloDetDescrManager* caloMgr);
    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);
    StatusCode doCalib();
 
private:
 
    // To add event info to new ntuple (used to go by default in CollectionTree)
    StatusCode addEventInfo();
 
private:
    SG::ReadHandleKey<xAOD::EventInfo> m_eventInfoKey{this, "EventInfoKey", "EventInfo"};
 
    SG::ReadCondHandleKey<CaloDetDescrManager> m_caloMgrKey { this
    , "CaloDetDescrManager"
    , "CaloDetDescrManager"
    , "SG Key for CaloDetDescrManager in the Condition Store" };

    TTree *m_tree_AS{};
 
    unsigned int m_runNumber{};
    unsigned int m_eventNumber{};
    unsigned int m_eventTime{};
    unsigned int m_lumiBlock{};
    unsigned int m_bCID{};
    double m_eventWeight{};
 
    /* ----- FCal-related variables ----- */
    double m_vertx{}; // x-position for vertex generated particle (beam)
    double m_verty{};
    double m_vertz{};
 
    double m_vertex_eta{}; // eta value of generated particle
    double m_vertex_phi{};
 
    double m_pt{}; // Momentum of generated particle
    double m_px{};
    double m_py{};
    double m_pz{};
 
    double m_E{}; // Energy of generated particle
 
    int m_NCell1{}; // Number of cells hit
    int m_NCell2{};
    int m_NCell3{};
 
    double m_x_mc_cc1{}; // Center of cluster in x (FCal1, extrapolated)
    double m_y_mc_cc1{};
 
    double m_x_mc_cc2{}; // Center of cluster in x (FCal2, extrapolated)
    double m_y_mc_cc2{};
 
    double m_x_mc_cc3{}; // Center of cluster in x (FCal3, extrapolated)
    double m_y_mc_cc3{};
 
    double m_x_cc1{}; // Center of cluster in x (FCal1, c of g)
    double m_y_cc1{};
 
    double m_x_cc2{}; // Center of cluster in x (FCal2, c of g)
    double m_y_cc2{};
 
    double m_x_cc3{}; // Center of cluster in x (FCal3, c of g)
    double m_y_cc3{};
 
    std::vector<int> *m_pdg_id{};  // particle id
 
    std::vector<double> *m_hit_x1{}; // hit positions of cells
    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{}; // hit indices of cells
    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{}; // Energy in cells
    std::vector<double> *m_cell2_E{};
    std::vector<double> *m_cell3_E{};
 
    double m_FCal1_SumE{}; // Energy in individual FCal modules
    double m_FCal2_SumE{};
    double m_FCal3_SumE{};
    double m_TCScint_E{};
    double m_TCIron_E{};
 
    double m_totalFCalEnergy{};
    int m_numHitsFCal{};
 
    /* ----- Calibration Hits Variables ----- */
    double m_totalCalibrationEnergy{}; // Total energy
 
    // Physic processes
    double m_totalEmEnergy{};
    double m_totalNonEmEnergy{};
    double m_totalInvisibleEnergy{};
    double m_totalEscapedEnergy{};
 
    // Energy deposited in different material categories
    double m_totalActiveEnergy{};
    double m_totalInactiveEnergy{};
    double m_totalDeadMaterialEnergy{};
 
    // Number of hits in different material categories
    int m_numHitsActive{};
    int m_numHitsInactive{};
    int m_numHitsDead{};
 
    // Total energy deposited in the different FCal Modules
    double m_totalFCalCalibrationEnergy{}; // Energy in all FCal
    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{};
 
    // For LAr analysis: Do we have any calibration hits at all?
    bool m_calibrationRun;
 
    // In order to write some clever loops, store all the hit containers
    // of a given type in a map.
    typedef std::map<std::string, const CaloCalibrationHitContainer *> m_calibHitMap_t;
    typedef m_calibHitMap_t::iterator m_calibHitMap_ptr_t;
    m_calibHitMap_t m_calibHitMap;
 
    // Variables needed for cluster centers
    double m_cx1, m_cx2, m_cx3;
    double m_cy1, m_cy2, m_cy3;
};
 
#endif // LAR_FCAL_SAMPLING_FRACTION_H