DlVertexingAlgorithm.h

Go to the documentation of this file.

 
#ifndef LAR_DL_VERTEXING_ALGORITHM_H
#define LAR_DL_VERTEXING_ALGORITHM_H 1
 
#include "Pandora/Algorithm.h"
#include "Pandora/AlgorithmHeaders.h"
 
#include "larpandoracontent/LArHelpers/LArMCParticleHelper.h"
 
#include "larpandoradlcontent/LArHelpers/LArDLHelper.h"
 
#include <random>
 
using namespace lar_content;
 
namespace lar_dl_content
{
class DlVertexingAlgorithm : public pandora::Algorithm
{
public:
    typedef std::map<std::pair<int, int>, std::vector<const pandora::CaloHit *>> PixelToCaloHitsMap;
 
    DlVertexingAlgorithm();
 
    virtual ~DlVertexingAlgorithm();
 
private:
    class VertexTuple
    {
    public:
        VertexTuple(const pandora::Pandora &pandora, const pandora::CartesianVector &vertexU, const pandora::CartesianVector &vertexV,
            const pandora::CartesianVector &vertexW);
 
        VertexTuple(const pandora::Pandora &pandora, const pandora::CartesianVector &vertex1, const pandora::CartesianVector &vertex2,
            const pandora::HitType view1, const pandora::HitType view2);
 
        const pandora::CartesianVector &GetPosition() const;
        float GetChi2() const;
        std::string ToString() const;
 
    private:
        pandora::CartesianVector m_pos; 
        float m_chi2;                   
    };
 
    typedef std::pair<int, int> Pixel; // A Pixel is a row, column pair
    typedef std::vector<Pixel> PixelVector;
 
    pandora::StatusCode Run();
    pandora::StatusCode ReadSettings(const pandora::TiXmlHandle xmlHandle);
    pandora::StatusCode PrepareTrainingSample();
    pandora::StatusCode Infer();
 
    /*
     *  @brief  Create input for the network from a calo hit list
     *
     *  @param  caloHits The CaloHitList from which the input should be made
     *  @param  view The wire plane view
     *  @param  xMin The minimum x coordinate for the hits
     *  @param  xMax The maximum x coordinate for the hits
     *  @param  zMin The minimum x coordinate for the hits
     *  @param  zMax The maximum x coordinate for the hits
     *  @param  networkInput The TorchInput object to populate
     *  @param  pixelVector The output vector of populated pixels
     *
     *  @return The StatusCode resulting from the function
     **/
    pandora::StatusCode MakeNetworkInputFromHits(const pandora::CaloHitList &caloHits, const pandora::HitType view, const float xMin,
        const float xMax, const float zMin, const float zMax, LArDLHelper::TorchInput &networkInput, PixelVector &pixelVector) const;
 
    /*
     *  @brief  Create a list of wire plane-space coordinates from a canvas
     *
     *  @param  canvas The input canvas
     *  @param  canvasWidth The width of the canvas
     *  @param  canvasHeight The height of the canvas
     *  @param  columnOffset The column offset used when populating the canvas
     *  @param  rowOffset The row offset used when populating the canvas
     *  @param  xMin The minimum x coordinate for the hits
     *  @param  xMax The maximum x coordinate for the hits
     *  @param  zMin The minimum x coordinate for the hits
     *  @param  zMax The maximum x coordinate for the hits
     *  @param  positionVector The output vector of wire plane positions
     *
     *  @return The StatusCode resulting from the function
     **/
    pandora::StatusCode MakeWirePlaneCoordinatesFromCanvas(float **canvas, const int canvasWidth, const int canvasHeight,
        const int columnOffset, const int rowOffset, const pandora::HitType view, const float xMin, const float xMax, const float zMin,
        const float zMax, pandora::CartesianPointVector &positionVector) const;
 
    void GetCanvasParameters(const LArDLHelper::TorchOutput &networkOutput, const PixelVector &pixelVector, int &columnOffset,
        int &rowOffset, int &width, int &height) const;
 
    void DrawRing(float **canvas, const int row, const int col, const int inner, const int outer, const float weight) const;
 
    void Update(const int radius, int &col, int &row) const;
 
    /*
     *  @brief  Retrieve the map from MC to calo hits for reconstructable particles
     *
     *  @param  mcToHitsMap The map to populate
     *
     *  @return The StatusCode resulting from the function
     **/
    pandora::StatusCode GetMCToHitsMap(LArMCParticleHelper::MCContributionMap &mcToHitsMap) const;
 
    /*
     *  @brief  Construct a list of the MC particles from the MC to calo hits map, completing the interaction hierarchy with the invisible
     *          upstream particles.
     *
     *  @param  mcToHitsMap The map of reconstructible MC particles to calo hits
     *  @param  mcHierarchy The output list of MC particles representing the interaction
     *
     *  @return The StatusCode resulting from the function
     **/
    pandora::StatusCode CompleteMCHierarchy(const LArMCParticleHelper::MCContributionMap &mcToHitsMap, pandora::MCParticleList &mcHierarchy) const;
 
    /*
     *  @brief  Determine the physical bounds associated with a CaloHitList.
     *
     *  @param  caloHitList The CaloHitList for which bounds should be determined
     *  @param  xMin The output minimum x value
     *  @param  xMax The output maximum x value
     *  @param  zMin The output minimum z value
     *  @param  zMax The output maximum z value
     *
     *  @return The StatusCode resulting from the function
     */
    void GetHitRegion(const pandora::CaloHitList &caloHitList, float &xMin, float &xMax, float &zMin, float &zMax) const;
 
    pandora::StatusCode MakeCandidateVertexList(const pandora::CartesianPointVector &positions);
 
    void GetTrueVertexPosition(float &x, float &y, float &z) const;
 
    void GetTrueVertexPosition(float &x, float &u, float &v, float &w) const;
 
    const pandora::CartesianVector &GetTrueVertex() const;
 
#ifdef MONITORING
    void PopulateRootTree(const std::vector<VertexTuple> &vertexTuples, const pandora::CartesianPointVector &vertexCandidatesU,
        const pandora::CartesianPointVector &vertexCandidatesV, const pandora::CartesianPointVector &vertexCandidatesW) const;
#endif
 
    bool m_trainingMode;                      
    std::string m_trainingOutputFile;         
    std::string m_inputVertexListName;        
    std::string m_outputVertexListName;       
    pandora::StringVector m_caloHitListNames; 
    LArDLHelper::TorchModel m_modelU;         
    LArDLHelper::TorchModel m_modelV;         
    LArDLHelper::TorchModel m_modelW;         
    int m_event;                              
    int m_pass;                               
    int m_nClasses;                           
    int m_height;                             
    int m_width;                              
    float m_driftStep;                        
    bool m_visualise;                         
    bool m_writeTree;                         
    std::string m_rootTreeName;               
    std::string m_rootFileName;               
    std::mt19937 m_rng;                       
    std::vector<double> m_thresholds;         
    std::string m_volumeType;                 
};
 
} // namespace lar_dl_content
 
#endif // LAR_DL_VERTEXING_ALGORITHM_H