CalibrationHelper.h

#ifndef CALIBRATION_HELPER_H
#define CALIBRATION_HELPER_H 1

#include "EVENT/LCStrVec.h"

#include "marlin/Processor.h"

#include <set>
#include <vector>

class TFile;
class TH1F;
class TTree;

//------------------------------------------------------------------------------------------------------------------------------------------

namespace pandora_analysis
{

class CalibrationHelper
{
public:
    class Settings
    {
    public:
        Settings();

        LCStrVec    m_eCalCollections;                      
        LCStrVec    m_hCalCollections;                      
        LCStrVec    m_muonCollections;                      
        LCStrVec    m_bCalCollections;                      
        LCStrVec    m_lHCalCollections;                     
        LCStrVec    m_lCalCollections;                      

        LCStrVec    m_eCalCollectionsSimCaloHit;            
        LCStrVec    m_hCalBarrelCollectionsSimCaloHit;      
        LCStrVec    m_hCalEndCapCollectionsSimCaloHit;      
        LCStrVec    m_hCalOtherCollectionsSimCaloHit;       

        int         m_hCalRingOuterSymmetryOrder;           
        float       m_hCalRingOuterPhi0;                    
    };

    typedef std::vector<const EVENT::ReconstructedParticle *> ParticleVector;

    CalibrationHelper(const Settings &settings);

    ~CalibrationHelper();

    void Calibrate(const EVENT::LCEvent *pLCEvent, const ParticleVector &particleVector, const int nPfoTargetsTotal, const int nPfoTargetsTracks, const int nPfoTargetsNeutralHadrons, const float pfoTargetsEnergyTotal);

    void SetBranchAddresses(TTree *pTTree);

    void CreateHistograms();

    void SetHistogramDirectories(TFile *pTFile);

    void WriteHistograms();

    void Clear();

private:
    int GetMinNHCalLayersFromEdge(const ParticleVector &pParticleVector, const int m_hCalRingOuterSymmetryOrder, const float m_hCalRingOuterPhi0) const;

    void ReadCaloHitEnergies(const EVENT::LCEvent *pLCEvent, const EVENT::LCStrVec &collectionNames, float &hitEnergySum) const;

    void AddSimCaloHitEntries(const EVENT::LCEvent *pLCEvent, const EVENT::LCStrVec &collectionNames, const unsigned int SimCaloHit_DC, TH1F *pTH1F) const;

    void AddDirectionCorrectedCaloHitEntries(const EVENT::LCEvent *pLCEvent, const EVENT::LCStrVec &collectionNames, TH1F *pTH1F) const;

    int GetNHCalLayersFromEdge(const EVENT::CalorimeterHit *const pCaloHit, const int m_hCalRingOuterSymmetryOrder, const float m_hCalRingOuterPhi0) const;

    float GetMaximumRadius(const EVENT::CalorimeterHit *const pCaloHit, const unsigned int symmetryOrder, const float phi0) const;

    const Settings  m_settings;                                    

    int             m_pfoMinHCalLayerToEdge;                       

    float           m_totalCaloHitEnergy;                          
    float           m_eCalTotalCaloHitEnergy;                      
    float           m_hCalTotalCaloHitEnergy;                      
    float           m_muonTotalCaloHitEnergy;                      
    float           m_bCalTotalCaloHitEnergy;                      
    float           m_lHCalTotalCaloHitEnergy;                     
    float           m_lCalTotalCaloHitEnergy;                      

    TH1F           *m_hECalDirectionCorrectedCaloHitEnergy;        
    TH1F           *m_hHCalDirectionCorrectedCaloHitEnergy;        
    TH1F           *m_hMuonDirectionCorrectedCaloHitEnergy;        

    TH1F           *m_hHCalBarrelDirectionCorrectedSimCaloHit;     
    TH1F           *m_hHCalEndCapDirectionCorrectedSimCaloHit;     
    TH1F           *m_hHCalOtherDirectionCorrectedSimCaloHit;      

    TH1F           *m_hECalDirectionCorrectedSimCaloHit;           

    TH1F           *m_hHCalBarrelDirectionCorrectionSimCaloHit;    
    TH1F           *m_hHCalEndCapDirectionCorrectionSimCaloHit;    
    TH1F           *m_hHCalOtherDirectionCorrectionSimCaloHit;     
};

} // namespace pandora_analysis

#endif // #ifndef CALIBRATION_HELPER_H