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 <unordered_map>

namespace lar_content
{

class StitchingBaseTool;
class CosmicRayTaggingBaseTool;
class SliceIdBaseTool;
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;

private:
    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;

    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;       

    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;       

    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;

    StitchingToolVector         m_stitchingToolVector;              
    CosmicRayTaggingToolVector  m_cosmicRayTaggingToolVector;       
    SliceIdToolVector           m_sliceIdToolVector;                

    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;                      
};

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

class StitchingBaseTool : public pandora::AlgorithmTool
{
public:
    virtual void Run(const MasterAlgorithm *const pAlgorithm, const pandora::PfoList *const pMultiPfoList, PfoToLArTPCMap &pfoToLArTPCMap, PfoToFloatMap &stitchedPfosToX0Map) = 0;
};

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

class CosmicRayTaggingBaseTool : public pandora::AlgorithmTool
{
public:
    virtual void FindAmbiguousPfos(const pandora::PfoList &parentCosmicRayPfos, pandora::PfoList &ambiguousPfos, const MasterAlgorithm *const pAlgorithm) = 0;
};

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

class SliceIdBaseTool : public pandora::AlgorithmTool
{
public:
    virtual void SelectOutputPfos(const pandora::Algorithm *const pAlgorithm, const SliceHypotheses &nuSliceHypotheses, const SliceHypotheses &crSliceHypotheses,
        pandora::PfoList &selectedPfos) = 0;
};

} // namespace lar_content

#endif // #ifndef LAR_MASTER_ALGORITHM_H