DlVertexingBaseAlgorithm.h

Go to the documentation of this file.

#ifndef LAR_DL_VERTEXING_BASE_ALGORITHM_H
#define LAR_DL_VERTEXING_BASE_ALGORITHM_H 1

#include "Pandora/Algorithm.h"
#include "Pandora/AlgorithmHeaders.h"

#include "larpandoracontent/LArHelpers/LArMCParticleHelper.h"

#include "larpandoradlcontent/LArHelpers/LArDLHelper.h"
#include "larpandoradlcontent/LArObjects/VertexTuple.h"

#include <random>

using namespace lar_content;

namespace lar_dl_content
{
class DlVertexingBaseAlgorithm : public pandora::Algorithm
{
public:
    typedef std::map<std::pair<int, int>, std::vector<const pandora::CaloHit *>> PixelToCaloHitsMap;

    DlVertexingBaseAlgorithm();

    ~DlVertexingBaseAlgorithm();

protected:
    typedef std::pair<int, int> Pixel; // A Pixel is a row, column pair
    typedef std::vector<Pixel> PixelVector;

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

    /*
     *  @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;

    void GetCanvasParameters(const LArDLHelper::TorchOutput &networkOutput, const PixelVector &pixelVector, int &columnOffset,
        int &rowOffset, int &width, int &height) const;

    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_pass;                               
    int m_nClasses;                           
    int m_height;                             
    int m_width;                              
    float m_driftStep;                        
    std::vector<double> m_thresholds;         
    std::string m_volumeType;                 
};

} // namespace lar_dl_content

#endif // LAR_DL_VERTEXING_BASE_ALGORITHM_H