Validation.h

Go to the documentation of this file.

 
#ifndef NEW_LAR_VALIDATION_H
#define NEW_LAR_VALIDATION_H 1
 
#include <limits>
 
typedef std::vector<int> IntVector;
typedef std::vector<float> FloatVector;
 
class Parameters
{
public:
    Parameters();
 
    bool                    m_displayMatchedEvents;     
    int                     m_skipEvents;               
    int                     m_nEventsToProcess;         
    bool                    m_applyUbooneFiducialCut;   
    bool                    m_applySBNDFiducialCut;     
    bool                    m_correctTrackShowerId;     
    float                   m_vertexXCorrection;        
    bool                    m_histogramOutput;          
    bool                    m_testBeamMode;             
    bool                    m_triggeredBeamOnly;        
    std::string             m_histPrefix;               
    std::string             m_mapFileName;              
    std::string             m_eventFileName;            
};
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
class SimpleThreeVector
{
public:
    SimpleThreeVector();
 
    SimpleThreeVector(const float x, const float y, const float z);
 
    float               m_x;                            
    float               m_y;                            
    float               m_z;                            
};
 
typedef std::vector<SimpleThreeVector> SimpleThreeVectorList;
 
SimpleThreeVector operator-(const SimpleThreeVector &lhs, const SimpleThreeVector &rhs);
 
SimpleThreeVector operator+(const SimpleThreeVector &lhs, const SimpleThreeVector &rhs);
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
class SimpleMCPrimary
{
public:
    SimpleMCPrimary();
 
    int                 m_primaryId;                    
    int                 m_pdgCode;                      
    float               m_energy;                       
    SimpleThreeVector   m_momentum;                     
    SimpleThreeVector   m_vertex;                       
    SimpleThreeVector   m_endpoint;                     
    int                 m_nMCHitsTotal;                 
    int                 m_nMCHitsU;                     
    int                 m_nMCHitsV;                     
    int                 m_nMCHitsW;                     
 
    int                 m_nPrimaryMatchedPfos;          
    int                 m_nPrimaryMatchedNuPfos;        
    int                 m_nPrimaryMatchedCRPfos;        
    int                 m_bestMatchPfoId;               
    int                 m_bestMatchPfoPdgCode;          
    int                 m_bestMatchPfoIsRecoNu;         
    int                 m_bestMatchPfoRecoNuId;         
    int                 m_bestMatchPfoIsTestBeam;       
    int                 m_bestMatchPfoNHitsTotal;       
    int                 m_bestMatchPfoNHitsU;           
    int                 m_bestMatchPfoNHitsV;           
    int                 m_bestMatchPfoNHitsW;           
    int                 m_bestMatchPfoNSharedHitsTotal; 
    int                 m_bestMatchPfoNSharedHitsU;     
    int                 m_bestMatchPfoNSharedHitsV;     
    int                 m_bestMatchPfoNSharedHitsW;     
};
 
typedef std::vector<SimpleMCPrimary> SimpleMCPrimaryList;
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
class SimpleMCTarget
{
public:
    SimpleMCTarget();
 
    int                 m_interactionType;              
    int                 m_mcNuanceCode;                 
    int                 m_isNeutrino;                   
    int                 m_isBeamParticle;               
    int                 m_isCosmicRay;                  
 
    SimpleThreeVector   m_targetVertex;                 
    SimpleThreeVector   m_recoVertex;                   
 
    int                 m_isCorrectNu;                  
    int                 m_isCorrectTB;                  
    int                 m_isCorrectCR;                  
    int                 m_isFakeNu;                     
    int                 m_isFakeCR;                     
    int                 m_isSplitNu;                    
    int                 m_isSplitCR;                    
    int                 m_isLost;                       
 
    int                 m_nTargetMatches;               
    int                 m_nTargetNuMatches;             
    int                 m_nTargetCRMatches;             
    int                 m_nTargetGoodNuMatches;         
    int                 m_nTargetNuSplits;              
    int                 m_nTargetNuLosses;              
 
    int                 m_nTargetPrimaries;             
    SimpleMCPrimaryList m_mcPrimaryList;                
};
 
typedef std::vector<SimpleMCTarget> SimpleMCTargetList;
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
class SimpleMCEvent
{
public:
    SimpleMCEvent();
 
    int                 m_fileIdentifier;               
    int                 m_eventNumber;                  
 
    int                 m_nMCTargets;                   
    SimpleMCTargetList  m_mcTargetList;                 
};
 
typedef std::vector<SimpleMCEvent> SimpleMCEventList;
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
enum ExpectedPrimary : int
{
    MUON,
    ELECTRON,
    PROTON1,
    PROTON2,
    PROTON3,
    PROTON4,
    PROTON5,
    PIPLUS,
    PIMINUS,
    NEUTRON,
    PHOTON1,
    PHOTON2,
    OTHER_PRIMARY
};
 
std::string ToString(const ExpectedPrimary expectedPrimary);
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
enum InteractionType : int
{
    CCQEL_MU,
    CCQEL_MU_P,
    CCQEL_MU_P_P,
    CCQEL_MU_P_P_P,
    CCQEL_MU_P_P_P_P,
    CCQEL_MU_P_P_P_P_P,
    CCQEL_E,
    CCQEL_E_P,
    CCQEL_E_P_P,
    CCQEL_E_P_P_P,
    CCQEL_E_P_P_P_P,
    CCQEL_E_P_P_P_P_P,
    NCQEL_P,
    NCQEL_P_P,
    NCQEL_P_P_P,
    NCQEL_P_P_P_P,
    NCQEL_P_P_P_P_P,
    CCRES_MU,
    CCRES_MU_P,
    CCRES_MU_P_P,
    CCRES_MU_P_P_P,
    CCRES_MU_P_P_P_P,
    CCRES_MU_P_P_P_P_P,
    CCRES_MU_PIPLUS,
    CCRES_MU_P_PIPLUS,
    CCRES_MU_P_P_PIPLUS,
    CCRES_MU_P_P_P_PIPLUS,
    CCRES_MU_P_P_P_P_PIPLUS,
    CCRES_MU_P_P_P_P_P_PIPLUS,
    CCRES_MU_PHOTON,
    CCRES_MU_P_PHOTON,
    CCRES_MU_P_P_PHOTON,
    CCRES_MU_P_P_P_PHOTON,
    CCRES_MU_P_P_P_P_PHOTON,
    CCRES_MU_P_P_P_P_P_PHOTON,
    CCRES_MU_PIZERO,
    CCRES_MU_P_PIZERO,
    CCRES_MU_P_P_PIZERO,
    CCRES_MU_P_P_P_PIZERO,
    CCRES_MU_P_P_P_P_PIZERO,
    CCRES_MU_P_P_P_P_P_PIZERO,
    CCRES_E,
    CCRES_E_P,
    CCRES_E_P_P,
    CCRES_E_P_P_P,
    CCRES_E_P_P_P_P,
    CCRES_E_P_P_P_P_P,
    CCRES_E_PIPLUS,
    CCRES_E_P_PIPLUS,
    CCRES_E_P_P_PIPLUS,
    CCRES_E_P_P_P_PIPLUS,
    CCRES_E_P_P_P_P_PIPLUS,
    CCRES_E_P_P_P_P_P_PIPLUS,
    CCRES_E_PHOTON,
    CCRES_E_P_PHOTON,
    CCRES_E_P_P_PHOTON,
    CCRES_E_P_P_P_PHOTON,
    CCRES_E_P_P_P_P_PHOTON,
    CCRES_E_P_P_P_P_P_PHOTON,
    CCRES_E_PIZERO,
    CCRES_E_P_PIZERO,
    CCRES_E_P_P_PIZERO,
    CCRES_E_P_P_P_PIZERO,
    CCRES_E_P_P_P_P_PIZERO,
    CCRES_E_P_P_P_P_P_PIZERO,
    NCRES_P,
    NCRES_P_P,
    NCRES_P_P_P,
    NCRES_P_P_P_P,
    NCRES_P_P_P_P_P,
    NCRES_PIPLUS,
    NCRES_P_PIPLUS,
    NCRES_P_P_PIPLUS,
    NCRES_P_P_P_PIPLUS,
    NCRES_P_P_P_P_PIPLUS,
    NCRES_P_P_P_P_P_PIPLUS,
    NCRES_PIMINUS,
    NCRES_P_PIMINUS,
    NCRES_P_P_PIMINUS,
    NCRES_P_P_P_PIMINUS,
    NCRES_P_P_P_P_PIMINUS,
    NCRES_P_P_P_P_P_PIMINUS,
    NCRES_PHOTON,
    NCRES_P_PHOTON,
    NCRES_P_P_PHOTON,
    NCRES_P_P_P_PHOTON,
    NCRES_P_P_P_P_PHOTON,
    NCRES_P_P_P_P_P_PHOTON,
    NCRES_PIZERO,
    NCRES_P_PIZERO,
    NCRES_P_P_PIZERO,
    NCRES_P_P_P_PIZERO,
    NCRES_P_P_P_P_PIZERO,
    NCRES_P_P_P_P_P_PIZERO,
    CCDIS_MU,
    CCDIS_MU_P,
    CCDIS_MU_P_P,
    CCDIS_MU_P_P_P,
    CCDIS_MU_P_P_P_P,
    CCDIS_MU_P_P_P_P_P,
    CCDIS_MU_PIPLUS,
    CCDIS_MU_P_PIPLUS,
    CCDIS_MU_P_P_PIPLUS,
    CCDIS_MU_P_P_P_PIPLUS,
    CCDIS_MU_P_P_P_P_PIPLUS,
    CCDIS_MU_P_P_P_P_P_PIPLUS,
    CCDIS_MU_PHOTON,
    CCDIS_MU_P_PHOTON,
    CCDIS_MU_P_P_PHOTON,
    CCDIS_MU_P_P_P_PHOTON,
    CCDIS_MU_P_P_P_P_PHOTON,
    CCDIS_MU_P_P_P_P_P_PHOTON,
    CCDIS_MU_PIZERO,
    CCDIS_MU_P_PIZERO,
    CCDIS_MU_P_P_PIZERO,
    CCDIS_MU_P_P_P_PIZERO,
    CCDIS_MU_P_P_P_P_PIZERO,
    CCDIS_MU_P_P_P_P_P_PIZERO,
    NCDIS_P,
    NCDIS_P_P,
    NCDIS_P_P_P,
    NCDIS_P_P_P_P,
    NCDIS_P_P_P_P_P,
    NCDIS_PIPLUS,
    NCDIS_P_PIPLUS,
    NCDIS_P_P_PIPLUS,
    NCDIS_P_P_P_PIPLUS,
    NCDIS_P_P_P_P_PIPLUS,
    NCDIS_P_P_P_P_P_PIPLUS,
    NCDIS_PIMINUS,
    NCDIS_P_PIMINUS,
    NCDIS_P_P_PIMINUS,
    NCDIS_P_P_P_PIMINUS,
    NCDIS_P_P_P_P_PIMINUS,
    NCDIS_P_P_P_P_P_PIMINUS,
    NCDIS_PHOTON,
    NCDIS_P_PHOTON,
    NCDIS_P_P_PHOTON,
    NCDIS_P_P_P_PHOTON,
    NCDIS_P_P_P_P_PHOTON,
    NCDIS_P_P_P_P_P_PHOTON,
    NCDIS_PIZERO,
    NCDIS_P_PIZERO,
    NCDIS_P_P_PIZERO,
    NCDIS_P_P_P_PIZERO,
    NCDIS_P_P_P_P_PIZERO,
    NCDIS_P_P_P_P_P_PIZERO,
    CCCOH,
    NCCOH,
    COSMIC_RAY_MU,
    COSMIC_RAY_P,
    COSMIC_RAY_E,
    COSMIC_RAY_PHOTON,
    COSMIC_RAY_OTHER,
    BEAM_PARTICLE_MU,
    BEAM_PARTICLE_P,
    BEAM_PARTICLE_E,
    BEAM_PARTICLE_PHOTON,
    BEAM_PARTICLE_PI_PLUS,
    BEAM_PARTICLE_PI_MINUS,
    BEAM_PARTICLE_KAON_PLUS,
    BEAM_PARTICLE_KAON_MINUS,
    BEAM_PARTICLE_OTHER,
    OTHER_INTERACTION,
    ALL_INTERACTIONS
};
 
std::string ToString(const InteractionType interactionType);
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
class CountingDetails
{
public:
    CountingDetails();
 
    unsigned int            m_nTotal;                   
    unsigned int            m_nMatch0;                  
    unsigned int            m_nMatch1;                  
    unsigned int            m_nMatch2;                  
    unsigned int            m_nMatch3Plus;              
    unsigned int            m_correctId;                
};
 
typedef std::map<ExpectedPrimary, CountingDetails> CountingMap;
typedef std::map<InteractionType, CountingMap> InteractionCountingMap;
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
class PrimaryResult
{
public:
    PrimaryResult();
 
    unsigned int            m_nPfoMatches;              
    unsigned int            m_nMCHitsTotal;             
    unsigned int            m_nBestMatchSharedHitsTotal;
    unsigned int            m_nBestMatchRecoHitsTotal;  
    float                   m_bestMatchCompleteness;    
    float                   m_bestMatchPurity;          
    bool                    m_isCorrectParticleId;      
    float                   m_trueMomentum;             
};
 
typedef std::map<ExpectedPrimary, PrimaryResult> PrimaryResultMap;
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
class TargetResult
{
public:
    TargetResult();
 
    int                     m_fileIdentifier;           
    int                     m_eventNumber;              
    bool                    m_isCorrect;                
    bool                    m_hasRecoVertex;            
    SimpleThreeVector       m_vertexOffset;             
    PrimaryResultMap        m_primaryResultMap;         
};
 
typedef std::vector<TargetResult> TargetResultList; // ATTN Not terribly efficient, but that's not the main aim here
typedef std::map<InteractionType, TargetResultList> InteractionTargetResultMap;
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
class TH1F;
 
class TargetHistogramCollection
{
public:
    TargetHistogramCollection();
 
    TH1F                   *m_hVtxDeltaX;               
    TH1F                   *m_hVtxDeltaY;               
    TH1F                   *m_hVtxDeltaZ;               
    TH1F                   *m_hVtxDeltaR;               
};
 
typedef std::map<InteractionType, TargetHistogramCollection> InteractionTargetHistogramMap;
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
class PrimaryHistogramCollection
{
public:
    PrimaryHistogramCollection();
 
    TH1F                   *m_hHitsAll;                 
    TH1F                   *m_hHitsEfficiency;          
    TH1F                   *m_hMomentumAll;             
    TH1F                   *m_hMomentumEfficiency;      
    TH1F                   *m_hCompleteness;            
    TH1F                   *m_hPurity;                  
};
 
typedef std::map<ExpectedPrimary, PrimaryHistogramCollection> PrimaryHistogramMap;
typedef std::map<InteractionType, PrimaryHistogramMap> InteractionPrimaryHistogramMap;
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
void Validation(const std::string &inputFiles, const Parameters &parameters = Parameters());
 
int ReadNextEvent(TChain *const pTChain, const int iEntry, SimpleMCEvent &simpleMCEvent, const Parameters &parameters);
 
void DisplaySimpleMCEventMatches(const SimpleMCEvent &simpleMCEvent, const Parameters &parameters);
 
void CountPfoMatches(const SimpleMCEvent &simpleMCEvent, const Parameters &parameters, InteractionCountingMap &interactionCountingMap,
    InteractionTargetResultMap &interactionTargetResultMap);
 
bool PassFiducialCut(const SimpleMCTarget &simpleMCTarget, const Parameters &parameters);
 
bool PassUbooneFiducialCut(const SimpleMCTarget &simpleMCTarget);
 
bool PassSBNDFiducialCut(const SimpleMCTarget &simpleMCTarget);
 
ExpectedPrimary GetExpectedPrimary(const SimpleMCPrimary &simpleMCPrimary, const SimpleMCPrimaryList &simpleMCPrimaryList);
 
bool IsGoodParticleIdMatch(const SimpleMCPrimary &simpleMCPrimary, const int bestMatchPfoPdgCode);
 
void DisplayInteractionCountingMap(const InteractionCountingMap &interactionCountingMap, const Parameters &parameters);
 
void AnalyseInteractionTargetResultMap(const InteractionTargetResultMap &interactionTargetResultMap, const Parameters &parameters);
 
void FillTargetHistogramCollection(const std::string &histPrefix, const TargetResult &targetResult, TargetHistogramCollection &targetHistogramCollection);
 
void FillPrimaryHistogramCollection(const std::string &histPrefix, const Parameters &parameters, const PrimaryResult &primaryResult, PrimaryHistogramCollection &primaryHistogramCollection);
 
void ProcessHistogramCollections(const InteractionPrimaryHistogramMap &interactionPrimaryHistogramMap);
 
//------------------------------------------------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------------------------------------------
 
Parameters::Parameters() :
    m_displayMatchedEvents(true),
    m_skipEvents(0),
    m_nEventsToProcess(std::numeric_limits<int>::max()),
    m_applyUbooneFiducialCut(false),
    m_applySBNDFiducialCut(false),
    m_correctTrackShowerId(false),
    m_vertexXCorrection(0.495694f),
    m_histogramOutput(false),
    m_testBeamMode(false),
    m_triggeredBeamOnly(true)
{
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------------------------------------------
 
SimpleThreeVector::SimpleThreeVector() :
    m_x(-std::numeric_limits<float>::max()),
    m_y(-std::numeric_limits<float>::max()),
    m_z(-std::numeric_limits<float>::max())
{
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
SimpleThreeVector::SimpleThreeVector(const float x, const float y, const float z) :
    m_x(x),
    m_y(y),
    m_z(z)
{
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
SimpleThreeVector operator-(const SimpleThreeVector &lhs, const SimpleThreeVector &rhs)
{
    return SimpleThreeVector(lhs.m_x - rhs.m_x, lhs.m_y - rhs.m_y, lhs.m_z - rhs.m_z);
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
SimpleThreeVector operator+(const SimpleThreeVector &lhs, const SimpleThreeVector &rhs)
{
    return SimpleThreeVector(lhs.m_x + rhs.m_x, lhs.m_y + rhs.m_y, lhs.m_z + rhs.m_z);
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------------------------------------------
 
SimpleMCPrimary::SimpleMCPrimary() :
    m_primaryId(-1),
    m_pdgCode(0),
    m_energy(0.f),
    m_momentum(0.f, 0.f, 0.f),
    m_vertex(-1.f, -1.f, -1.f),
    m_endpoint(-1.f, -1.f, -1.f),
    m_nMCHitsTotal(0),
    m_nMCHitsU(0),
    m_nMCHitsV(0),
    m_nMCHitsW(0),
    m_nPrimaryMatchedPfos(0),
    m_nPrimaryMatchedNuPfos(0),
    m_nPrimaryMatchedCRPfos(0),
    m_bestMatchPfoId(-1),
    m_bestMatchPfoPdgCode(0),
    m_bestMatchPfoIsRecoNu(0),
    m_bestMatchPfoRecoNuId(-1),
    m_bestMatchPfoIsTestBeam(0),
    m_bestMatchPfoNHitsTotal(0),
    m_bestMatchPfoNHitsU(0),
    m_bestMatchPfoNHitsV(0),
    m_bestMatchPfoNHitsW(0),
    m_bestMatchPfoNSharedHitsTotal(0),
    m_bestMatchPfoNSharedHitsU(0),
    m_bestMatchPfoNSharedHitsV(0),
    m_bestMatchPfoNSharedHitsW(0)
{
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------------------------------------------
 
SimpleMCTarget::SimpleMCTarget() :
    m_interactionType(OTHER_INTERACTION),
    m_mcNuanceCode(0),
    m_isNeutrino(false),
    m_isBeamParticle(false),
    m_isCosmicRay(false),
    m_targetVertex(0.f, 0.f, 0.f),
    m_recoVertex(std::numeric_limits<float>::max(), std::numeric_limits<float>::max(), std::numeric_limits<float>::max()),
    m_isCorrectNu(false),
    m_isCorrectTB(false),
    m_isCorrectCR(false),
    m_isFakeNu(false),
    m_isFakeCR(false),
    m_isSplitNu(false),
    m_isSplitCR(false),
    m_isLost(false),
    m_nTargetMatches(0),
    m_nTargetNuMatches(0),
    m_nTargetCRMatches(0),
    m_nTargetGoodNuMatches(0),
    m_nTargetNuSplits(0),
    m_nTargetNuLosses(0),
    m_nTargetPrimaries(0)
{
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------------------------------------------
 
SimpleMCEvent::SimpleMCEvent() :
    m_fileIdentifier(-1),
    m_eventNumber(0),
    m_nMCTargets(0)
{
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------------------------------------------
 
CountingDetails::CountingDetails() :
    m_nTotal(0),
    m_nMatch0(0),
    m_nMatch1(0),
    m_nMatch2(0),
    m_nMatch3Plus(0),
    m_correctId(0)
{
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------------------------------------------
 
PrimaryResult::PrimaryResult() :
    m_nPfoMatches(0),
    m_nMCHitsTotal(0),
    m_nBestMatchSharedHitsTotal(0),
    m_nBestMatchRecoHitsTotal(0),
    m_bestMatchCompleteness(0.f),
    m_bestMatchPurity(0.f),
    m_isCorrectParticleId(false),
    m_trueMomentum(-1.f)
{
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------------------------------------------
 
TargetResult::TargetResult() :
    m_fileIdentifier(-1),
    m_eventNumber(-1),
    m_isCorrect(false),
    m_hasRecoVertex(false),
    m_vertexOffset(std::numeric_limits<float>::max(), std::numeric_limits<float>::max(), std::numeric_limits<float>::max())
{
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------------------------------------------
 
PrimaryHistogramCollection::PrimaryHistogramCollection() :
    m_hHitsAll(nullptr),
    m_hHitsEfficiency(nullptr),
    m_hMomentumAll(nullptr),
    m_hMomentumEfficiency(nullptr),
    m_hCompleteness(nullptr),
    m_hPurity(nullptr)
{
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------------------------------------------
 
TargetHistogramCollection::TargetHistogramCollection() :
    m_hVtxDeltaX(nullptr),
    m_hVtxDeltaY(nullptr),
    m_hVtxDeltaZ(nullptr),
    m_hVtxDeltaR(nullptr)
{
}
 
#endif // #ifndef NEW_LAR_VALIDATION_H