DlSNSignalAlgorithm.h

Go to the documentation of this file.

#ifndef LAR_DL_SIGNAL_ALGORITHM_H
#define LAR_DL_SIGNAL_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 DlSNSignalAlgorithm : public pandora::Algorithm
{
public:
    typedef std::map<std::pair<int, int>, std::vector<const pandora::CaloHit *>> PixelToCaloHitsMap;

    DlSNSignalAlgorithm();

    virtual ~DlSNSignalAlgorithm();

private:
    typedef std::pair<int, int> Pixel;                          // A Pixel is a row, column pair
    typedef std::map<const pandora::CaloHit *, Pixel> PixelMap; //A mapping between a CaloHit and a Pixel in the canvas

    pandora::StatusCode Run();
    pandora::StatusCode ReadSettings(const pandora::TiXmlHandle xmlHandle);
    pandora::StatusCode PrepareTrainingSample();
    pandora::StatusCode Infer();
    pandora::StatusCode CheatedSeparation();

    /*
     *  @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, PixelMap &pixelMap) 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;

    bool m_trainingMode;                           
    std::string m_trainingOutputFile;              
    std::string m_inputSignalListName;             
    pandora::StringVector m_caloHitListNames;      
    LArDLHelper::TorchModel m_modelU;              
    LArDLHelper::TorchModel m_modelV;              
    LArDLHelper::TorchModel m_modelW;              
    int m_event;                                   
    int m_pass;                                    
    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;                            
    bool m_printOut;                               
    std::string m_signalListNameU;                 
    std::string m_signalListNameV;                 
    std::string m_signalListNameW;                 
    std::string m_signalListName2D;                
    std::string m_caloHitListName2D;               
    pandora::StringVector m_inputCaloHitListNames; 
    std::string m_backgroundListName;              
    bool m_applyCheatedSeparation;                 
    bool m_simpleZoom;                             
    long unsigned int m_passOneTrustThreshold; 
    const int PHOTON_CLASS{2};                 
    const int ELECTRON_CLASS{3};               
    const int SIGNAL_CLASS{2};                 
};

} // namespace lar_dl_content

#endif // LAR_DL_SIGNAL_ALGORITHM_H