CaloHitCreator.h

#ifndef CALO_HIT_CREATOR_H
#define CALO_HIT_CREATOR_H 1

#include "EVENT/CalorimeterHit.h"

#include "gear/LayerLayout.h"

#include "Api/PandoraApi.h"

#include <string>

typedef std::vector<CalorimeterHit *> CalorimeterHitVector;

class CaloHitCreator
{
public:
    typedef std::vector<std::string> StringVector;

    class Settings
    {
    public:
        Settings();

        StringVector    m_eCalCaloHitCollections;               
        StringVector    m_hCalCaloHitCollections;               
        StringVector    m_lCalCaloHitCollections;               
        StringVector    m_lHCalCaloHitCollections;              
        StringVector    m_muonCaloHitCollections;               

        float           m_absorberRadLengthECal;                
        float           m_absorberIntLengthECal;                
        float           m_absorberRadLengthHCal;                
        float           m_absorberIntLengthHCal;                
        float           m_absorberRadLengthOther;               
        float           m_absorberIntLengthOther;               

        float           m_eCalToMip;                            
        float           m_hCalToMip;                            
        float           m_muonToMip;                            
        float           m_eCalMipThreshold;                     
        float           m_hCalMipThreshold;                     
        float           m_muonMipThreshold;                     

        float           m_eCalToEMGeV;                          
        float           m_eCalToHadGeVBarrel;                   
        float           m_eCalToHadGeVEndCap;                   
        float           m_hCalToEMGeV;                          
        float           m_hCalToHadGeV;                         
        int             m_muonDigitalHits;                      
        float           m_muonHitEnergy;                        

        float           m_maxHCalHitHadronicEnergy;             
        int             m_nOuterSamplingLayers;                 
        float           m_layersFromEdgeMaxRearDistance;        

        int             m_hCalEndCapInnerSymmetryOrder;         
        float           m_hCalEndCapInnerPhiCoordinate;         

        // For Strip Splitting method and hybrid ECAL.
        int             m_stripSplittingOn;                     
        int             m_useEcalScLayers;                      
        float           m_eCalSiToMip;                          
        float           m_eCalScToMip;                          
        float           m_eCalSiMipThreshold;                   
        float           m_eCalScMipThreshold;                   
        float           m_eCalSiToEMGeV;                        
        float           m_eCalScToEMGeV;                        
        float           m_eCalSiToHadGeVBarrel;                 
        float           m_eCalScToHadGeVBarrel;                 
        float           m_eCalSiToHadGeVEndCap;                 
        float           m_eCalScToHadGeVEndCap;                 
    };

     CaloHitCreator(const Settings &settings, const pandora::Pandora *const pPandora);

     ~CaloHitCreator();

    pandora::StatusCode CreateCaloHits(const LCEvent *const pLCEvent);

    const CalorimeterHitVector &GetCalorimeterHitVector() const;

    void Reset();

private:
    pandora::StatusCode CreateECalCaloHits(const EVENT::LCEvent *const pLCEvent);

    pandora::StatusCode CreateHCalCaloHits(const EVENT::LCEvent *const pLCEvent);

    pandora::StatusCode CreateMuonCaloHits(const EVENT::LCEvent *const pLCEvent);

    pandora::StatusCode CreateLCalCaloHits(const EVENT::LCEvent *const pLCEvent);

    pandora::StatusCode CreateLHCalCaloHits(const EVENT::LCEvent *const pLCEvent);

    void GetCommonCaloHitProperties(const EVENT::CalorimeterHit *const pCaloHit, PandoraApi::CaloHit::Parameters &caloHitParameters) const;

    void GetEndCapCaloHitProperties(const EVENT::CalorimeterHit *const pCaloHit, const gear::LayerLayout &layerLayout,
        PandoraApi::CaloHit::Parameters &caloHitParameters, float &absorberCorrection) const;

    void GetBarrelCaloHitProperties(const EVENT::CalorimeterHit *const pCaloHit, const gear::LayerLayout &layerLayout,
        unsigned int barrelSymmetryOrder, float barrelPhi0, unsigned int staveNumber, PandoraApi::CaloHit::Parameters &caloHitParameters,
        float &absorberCorrection) const;

    int GetNLayersFromEdge(const EVENT::CalorimeterHit *const pCaloHit) const;

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

    std::string GetLayerCoding(const std::string &encodingString) const;

    std::string GetStaveCoding(const std::string &encodingString) const;

    const Settings                      m_settings;                         

    const pandora::Pandora             *m_pPandora;                         

    const float                         m_eCalBarrelOuterZ;                 
    const float                         m_hCalBarrelOuterZ;                 
    const float                         m_muonBarrelOuterZ;                 
    const float                         m_coilOuterR;                       

    const float                         m_eCalBarrelInnerPhi0;              
    const unsigned int                  m_eCalBarrelInnerSymmetry;          
    const float                         m_hCalBarrelInnerPhi0;              
    const unsigned int                  m_hCalBarrelInnerSymmetry;          
    const float                         m_muonBarrelInnerPhi0;              
    const unsigned int                  m_muonBarrelInnerSymmetry;          

    const float                         m_hCalEndCapOuterR;                 
    const float                         m_hCalEndCapOuterZ;                 
    const float                         m_hCalBarrelOuterR;                 
    const float                         m_hCalBarrelOuterPhi0;              
    const unsigned int                  m_hCalBarrelOuterSymmetry;          

    float                               m_hCalBarrelLayerThickness;         
    float                               m_hCalEndCapLayerThickness;         

    CalorimeterHitVector                m_calorimeterHitVector;             
};

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

inline const CalorimeterHitVector &CaloHitCreator::GetCalorimeterHitVector() const
{
    return m_calorimeterHitVector;
}

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

inline void CaloHitCreator::Reset()
{
    m_calorimeterHitVector.clear();
}

#endif // #ifndef CALO_HIT_CREATOR_H