TrackCreator.h

#ifndef TRACK_CREATOR_H
#define TRACK_CREATOR_H 1

#include "lcio.h"

#include "IMPL/LCCollectionVec.h"
#include "IMPL/LCFlagImpl.h"

#include "EVENT/LCEvent.h"
#include "EVENT/Track.h"

#include "Api/PandoraApi.h"
#include "Objects/Helix.h"

typedef std::vector<Track *> TrackVector;
typedef std::set<const Track *> TrackList;
typedef std::map<Track *, int> TrackToPidMap;

inline LCCollectionVec *newTrkCol(const std::string &name, LCEvent *evt , bool isSubset)
{
    LCCollectionVec* col = new LCCollectionVec( LCIO::TRACK ) ;

    LCFlagImpl hitFlag(0) ;
    hitFlag.setBit( LCIO::TRBIT_HITS ) ;
    col->setFlag( hitFlag.getFlag()  ) ;
    evt->addCollection( col , name ) ;
    col->setSubset( isSubset ) ;

    return col ;
}

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

class TrackCreator
{
public:
    typedef std::vector<double> DoubleVector;
    typedef std::vector<std::string> StringVector;

    class Settings
    {
    public:
        Settings();

        StringVector    m_trackCollections;                     
        StringVector    m_kinkVertexCollections;                
        StringVector    m_prongVertexCollections;               
        StringVector    m_splitVertexCollections;               
        StringVector    m_v0VertexCollections;                  

        StringVector    m_prongSplitVertexCollections;          
        int             m_shouldFormTrackRelationships;         

        int             m_minTrackHits;                         
        int             m_minFtdTrackHits;                      
        int             m_maxTrackHits;                         

        float           m_d0TrackCut;                           
        float           m_z0TrackCut;                           

        int             m_usingNonVertexTracks;                 
        int             m_usingUnmatchedNonVertexTracks;        
        int             m_usingUnmatchedVertexTracks;           
        float           m_unmatchedVertexTrackMaxEnergy;        

        float           m_d0UnmatchedVertexTrackCut;            
        float           m_z0UnmatchedVertexTrackCut;            
        float           m_zCutForNonVertexTracks;               

        int             m_reachesECalNTpcHits;                  
        int             m_reachesECalNFtdHits;                  
        float           m_reachesECalTpcOuterDistance;          
        int             m_reachesECalMinFtdLayer;               
        float           m_reachesECalTpcZMaxDistance;           
        float           m_reachesECalFtdZMaxDistance;           
        float           m_curvatureToMomentumFactor;            

        float           m_minTrackECalDistanceFromIp;           
        float           m_maxTrackSigmaPOverP;                  
        float           m_minMomentumForTrackHitChecks;         

        float           m_tpcMembraneMaxZ;                      
        float           m_maxTpcInnerRDistance;                 
        float           m_minTpcHitFractionOfExpected;          
        int             m_minFtdHitsForTpcHitFraction;          
    };

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

     ~TrackCreator();

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

    pandora::StatusCode CreateTracks(EVENT::LCEvent *pLCEvent);

    const TrackVector &GetTrackVector() const;

    void Reset();

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

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

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

    bool IsConflictingRelationship(const EVENT::TrackVec &trackVec) const;

    bool IsV0(const EVENT::Track *const pTrack) const;

    bool IsParent(const EVENT::Track *const pTrack) const;

    bool IsDaughter(const EVENT::Track *const pTrack) const;

    void GetTrackStates(const EVENT::Track *const pTrack, PandoraApi::Track::Parameters &trackParameters) const;

    void CopyTrackState(const TrackState *const pTrackState, pandora::InputTrackState &inputTrackState) const;

    float CalculateTrackTimeAtCalorimeter(const EVENT::Track *const pTrack) const;

    void TrackReachesECAL(const EVENT::Track *const pTrack, PandoraApi::Track::Parameters &trackParameters) const;

    void DefineTrackPfoUsage(const EVENT::Track *const pTrack, PandoraApi::Track::Parameters &trackParameters) const;

    bool PassesQualityCuts(const EVENT::Track *const pTrack, const PandoraApi::Track::Parameters &trackParameters) const;

    int GetNTpcHits(const EVENT::Track *const pTrack) const;

    int GetNFtdHits(const EVENT::Track *const pTrack) const;

    const Settings          m_settings;                     
    const pandora::Pandora *m_pPandora;                     

    const float             m_bField;                       

    const float             m_tpcInnerR;                    
    const float             m_tpcOuterR;                    
    const unsigned int      m_tpcMaxRow;                    
    const float             m_tpcZmax;                      
    float                   m_cosTpc;                       

    DoubleVector            m_ftdInnerRadii;                
    DoubleVector            m_ftdOuterRadii;                
    DoubleVector            m_ftdZPositions;                
    unsigned int            m_nFtdLayers;                   
    float                   m_tanLambdaFtd;                 

    const int               m_eCalBarrelInnerSymmetry;      
    const float             m_eCalBarrelInnerPhi0;          
    const float             m_eCalBarrelInnerR;             
    const float             m_eCalEndCapInnerZ;             

    float                   m_minEtdZPosition;              
    float                   m_minSetRadius;                 

    TrackVector             m_trackVector;                  
    TrackList               m_v0TrackList;                  
    TrackList               m_parentTrackList;              
    TrackList               m_daughterTrackList;            
    TrackToPidMap           m_trackToPidMap;                
};

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

inline const TrackVector &TrackCreator::GetTrackVector() const
{
    return m_trackVector;
}

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

inline void TrackCreator::Reset()
{
    m_trackVector.clear();
    m_v0TrackList.clear();
    m_parentTrackList.clear();
    m_daughterTrackList.clear();
    m_trackToPidMap.clear();
}

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

inline bool TrackCreator::IsV0(const Track *const pTrack) const
{
    return (m_v0TrackList.end() != m_v0TrackList.find(pTrack));
}

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

inline bool TrackCreator::IsParent(const Track *const pTrack) const
{
    return (m_parentTrackList.end() != m_parentTrackList.find(pTrack));
}

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

inline bool TrackCreator::IsDaughter(const Track *const pTrack) const
{
    return (m_daughterTrackList.end() != m_daughterTrackList.find(pTrack));
}

#endif // #ifndef TRACK_CREATOR_H