MasterAlgorithm.h

Go to the documentation of this file.

#ifndef LAR_MASTER_ALGORITHM_H
#define LAR_MASTER_ALGORITHM_H 1

#include "Pandora/AlgorithmTool.h"
#include "Pandora/ExternallyConfiguredAlgorithm.h"

#include "larpandoracontent/LArControlFlow/MultiPandoraApi.h"
#include "larpandoracontent/LArObjects/LArCaloHit.h"

#include "larpandoracontent/LArControlFlow/CosmicRayTaggingBaseTool.h"
#include "larpandoracontent/LArControlFlow/SliceIdBaseTool.h"
#include "larpandoracontent/LArControlFlow/SliceSelectionBaseTool.h"
#include "larpandoracontent/LArControlFlow/StitchingBaseTool.h"

#include <unordered_map>

namespace lar_content
{

class LArMCParticleFactory;

typedef std::vector<pandora::CaloHitList> SliceVector;
typedef std::vector<pandora::PfoList> SliceHypotheses;
typedef std::unordered_map<const pandora::ParticleFlowObject *, const pandora::LArTPC *> PfoToLArTPCMap;
typedef std::unordered_map<const pandora::ParticleFlowObject *, float> PfoToFloatMap;

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

class MasterAlgorithm : public pandora::ExternallyConfiguredAlgorithm
{
public:
    MasterAlgorithm();

    class ExternalSteeringParameters : public pandora::ExternalParameters
    {
    public:
        pandora::InputBool m_shouldRunAllHitsCosmicReco;  
        pandora::InputBool m_shouldRunStitching;          
        pandora::InputBool m_shouldRunCosmicHitRemoval;   
        pandora::InputBool m_shouldRunSlicing;            
        pandora::InputBool m_shouldRunNeutrinoRecoOption; 
        pandora::InputBool m_shouldRunCosmicRecoOption;   
        pandora::InputBool m_shouldPerformSliceId;        
        pandora::InputBool m_printOverallRecoStatus;      
    };

    typedef std::unordered_map<const pandora::ParticleFlowObject *, const pandora::LArTPC *> PfoToLArTPCMap;

    void ShiftPfoHierarchy(const pandora::ParticleFlowObject *const pParentPfo, const PfoToLArTPCMap &pfoToLArTPCMap, const float x0) const;

    void StitchPfos(const pandora::ParticleFlowObject *const pPfoToEnlarge, const pandora::ParticleFlowObject *const pPfoToDelete,
        PfoToLArTPCMap &pfoToLArTPCMap) const;

protected:
    class LArTPCHitList
    {
    public:
        pandora::CaloHitList m_allHitList;       
        pandora::CaloHitList m_truncatedHitList; 
    };

    typedef std::map<unsigned int, LArTPCHitList> VolumeIdToHitListMap;

    pandora::StatusCode Run();

    pandora::StatusCode InitializeWorkerInstances();

    pandora::StatusCode CopyMCParticles() const;

    pandora::StatusCode GetVolumeIdToHitListMap(VolumeIdToHitListMap &volumeIdToHitListMap) const;

    pandora::StatusCode RunCosmicRayReconstruction(const VolumeIdToHitListMap &volumeIdToHitListMap) const;

    pandora::StatusCode RecreateCosmicRayPfos(PfoToLArTPCMap &pfoToLArTPCMap) const;

    pandora::StatusCode StitchCosmicRayPfos(PfoToLArTPCMap &pfoToLArTPCMap, PfoToFloatMap &stitchedPfosToX0Map) const;

    pandora::StatusCode TagCosmicRayPfos(
        const PfoToFloatMap &stitchedPfosToX0Map, pandora::PfoList &clearCosmicRayPfos, pandora::PfoList &ambiguousPfos) const;

    pandora::StatusCode RunCosmicRayHitRemoval(const pandora::PfoList &ambiguousPfos) const;

    pandora::StatusCode RunSlicing(const VolumeIdToHitListMap &volumeIdToHitListMap, SliceVector &sliceVector) const;

    pandora::StatusCode RunSliceReconstruction(SliceVector &sliceVector, SliceHypotheses &nuSliceHypotheses, SliceHypotheses &crSliceHypotheses) const;

    pandora::StatusCode SelectBestSliceHypotheses(const SliceHypotheses &nuSliceHypotheses, const SliceHypotheses &crSliceHypotheses) const;

    pandora::StatusCode Reset();

    pandora::StatusCode Copy(const pandora::Pandora *const pPandora, const pandora::CaloHit *const pCaloHit) const;

    pandora::StatusCode Copy(const pandora::Pandora *const pPandora, const pandora::MCParticle *const pMCParticle,
        const LArMCParticleFactory *const pMCParticleFactory) const;

    pandora::StatusCode Recreate(const pandora::PfoList &inputPfoList, pandora::PfoList &newPfoList) const;

    pandora::StatusCode Recreate(const pandora::ParticleFlowObject *const pInputPfo, const pandora::ParticleFlowObject *const pNewParentPfo,
        pandora::PfoList &newPfoList) const;

    const pandora::CaloHit *CreateCaloHit(const pandora::CaloHit *const pInputCaloHit, const pandora::CaloHit *const pParentCaloHit) const;

    const pandora::Cluster *CreateCluster(const pandora::Cluster *const pInputCluster, const pandora::CaloHitList &newCaloHitList,
        const pandora::CaloHitList &newIsolatedCaloHitList) const;

    const pandora::Vertex *CreateVertex(const pandora::Vertex *const pInputVertex) const;

    const pandora::ParticleFlowObject *CreatePfo(const pandora::ParticleFlowObject *const pInputPfo,
        const pandora::ClusterList &newClusterList, const pandora::VertexList &newVertexList) const;

    const pandora::Pandora *CreateWorkerInstance(const pandora::LArTPC &larTPC, const pandora::DetectorGapList &gapList,
        const std::string &settingsFile, const std::string &name) const;

    const pandora::Pandora *CreateWorkerInstance(const pandora::LArTPCMap &larTPCMap, const pandora::DetectorGapList &gapList,
        const std::string &settingsFile, const std::string &name) const;

    virtual pandora::StatusCode RegisterCustomContent(const pandora::Pandora *const pPandora) const;

    pandora::StatusCode ReadSettings(const pandora::TiXmlHandle xmlHandle);

    pandora::StatusCode ReadExternalSettings(const ExternalSteeringParameters *const pExternalParameters,
        const pandora::InputBool inputBool, const pandora::TiXmlHandle xmlHandle, const std::string &xmlTag, bool &outputBool);

    bool m_workerInstancesInitialized; 

    unsigned int m_larCaloHitVersion; 

    bool m_shouldRunAllHitsCosmicReco;  
    bool m_shouldRunStitching;          
    bool m_shouldRunCosmicHitRemoval;   
    bool m_shouldRunSlicing;            
    bool m_shouldRunNeutrinoRecoOption; 
    bool m_shouldRunCosmicRecoOption;   
    bool m_shouldPerformSliceId;        
    bool m_printOverallRecoStatus;      
    bool m_visualizeOverallRecoStatus;  
    bool m_shouldRemoveOutOfTimeHits;   

    PandoraInstanceList m_crWorkerInstances;          
    const pandora::Pandora *m_pSlicingWorkerInstance; 
    const pandora::Pandora *m_pSliceNuWorkerInstance; 
    const pandora::Pandora *m_pSliceCRWorkerInstance; 

    bool m_fullWidthCRWorkerWireGaps;        
    bool m_passMCParticlesToWorkerInstances; 

    typedef std::vector<StitchingBaseTool *> StitchingToolVector;
    typedef std::vector<CosmicRayTaggingBaseTool *> CosmicRayTaggingToolVector;
    typedef std::vector<SliceIdBaseTool *> SliceIdToolVector;
    typedef std::vector<SliceSelectionBaseTool *> SliceSelectionToolVector;

    StitchingToolVector m_stitchingToolVector;               
    CosmicRayTaggingToolVector m_cosmicRayTaggingToolVector; 
    SliceIdToolVector m_sliceIdToolVector;                   
    SliceSelectionToolVector m_sliceSelectionToolVector;     

    std::string m_filePathEnvironmentVariable; 
    std::string m_crSettingsFile;              
    std::string m_nuSettingsFile;              
    std::string m_slicingSettingsFile;         

    std::string m_inputMCParticleListName;  
    std::string m_inputHitListName;         
    std::string m_recreatedPfoListName;     
    std::string m_recreatedClusterListName; 
    std::string m_recreatedVertexListName;  

    float m_inTimeMaxX0;                   
    LArCaloHitFactory m_larCaloHitFactory; 
};

} // namespace lar_content

#endif // #ifndef LAR_MASTER_ALGORITHM_H