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 <unordered_map>
 
namespace lar_content
{
 
class StitchingBaseTool;
class CosmicRayTaggingBaseTool;
class SliceIdBaseTool;
class SliceSelectionBaseTool;
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; 
};
 
//------------------------------------------------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------------------------------------------
 
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;
};
 
//------------------------------------------------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------------------------------------------
 
class SliceSelectionBaseTool : public pandora::AlgorithmTool
{
public:
    virtual void SelectSlices(const pandora::Algorithm *const pAlgorithm, const SliceVector &inputSliceVector, SliceVector &outputSliceVector) = 0;
};
 
} // namespace lar_content
 
#endif // #ifndef LAR_MASTER_ALGORITHM_H