VertexMonitoringAlgorithm class. More...

#include <VertexMonitoringAlgorithm.h>

Inheritance diagram for lar_content::VertexMonitoringAlgorithm:

Public Member Functions
	VertexMonitoringAlgorithm ()
	Default constructor. More...

virtual	~VertexMonitoringAlgorithm ()

Private Member Functions
pandora::StatusCode	AssessVertices () const

pandora::StatusCode	Run ()

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

Private Attributes
bool	m_visualise

bool	m_writeFile

std::string	m_filename

std::string	m_treename

float	m_transparencyThresholdE
	Cell energy for which transparency is saturated (0%, fully opaque) More...

float	m_energyScaleThresholdE
	Cell energy for which color is at top end of continous color palette. More...

float	m_scalingFactor
	TEve works with [cm], Pandora usually works with [mm] (but LArContent went with cm too) More...

Detailed Description

VertexMonitoringAlgorithm class.

Definition at line 19 of file VertexMonitoringAlgorithm.h.

Constructor & Destructor Documentation

lar_content::VertexMonitoringAlgorithm::VertexMonitoringAlgorithm ( )

Default constructor.

Definition at line 23 of file VertexMonitoringAlgorithm.cc.

                                                      :
     m_visualise{true},
     m_writeFile{false},
     m_transparencyThresholdE{-1.f},
     m_energyScaleThresholdE{1.f},
     m_scalingFactor{1.f}
 {
 }

lar_content::VertexMonitoringAlgorithm::~VertexMonitoringAlgorithm ( )

virtual

Definition at line 34 of file VertexMonitoringAlgorithm.cc.

 {
     if (m_writeFile)
     {
         PANDORA_MONITORING_API(SaveTree(this->GetPandora(), m_treename.c_str(), m_filename.c_str(), "UPDATE"));
     }
 }

Member Function Documentation

StatusCode lar_content::VertexMonitoringAlgorithm::AssessVertices ( ) const

private

Definition at line 64 of file VertexMonitoringAlgorithm.cc.

 {
     const MCParticleList *pMCParticleList{nullptr};
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::GetCurrentList(*this, pMCParticleList));
     const PfoList *pPfoList{nullptr};
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::GetCurrentList(*this, pPfoList));
 
     LArMCParticleHelper::MCContributionMap mcToHitsMap;
     MCParticleVector primaries;
     LArMCParticleHelper::GetPrimaryMCParticleList(pMCParticleList, primaries);
     const MCParticle *pTrueNeutrino{nullptr};
     const ParticleFlowObject *pRecoNeutrino{nullptr};
     if (!primaries.empty())
     {
         for (const MCParticle *primary : primaries)
         {
             const MCParticleList &parents{primary->GetParentList()};
             if (parents.size() == 1 && LArMCParticleHelper::IsNeutrino(parents.front()))
             {
                 pTrueNeutrino = parents.front();
                 break;
             }
         }
     }
 
     for (const ParticleFlowObject *pPfo : *pPfoList)
     {
         if (LArPfoHelper::IsNeutrino(pPfo))
         {
             pRecoNeutrino = pPfo;
             break;
         }
     }
 
     if (pRecoNeutrino && pTrueNeutrino)
     {
         const LArTransformationPlugin *transform{this->GetPandora().GetPlugins()->GetLArTransformationPlugin()};
         const CartesianVector &trueVertex{pTrueNeutrino->GetVertex()};
         const CartesianVector &recoVertex{LArPfoHelper::GetVertex(pRecoNeutrino)->GetPosition()};
         if (m_visualise)
         {
             const CartesianVector tu(trueVertex.GetX(), 0.f, static_cast<float>(transform->YZtoU(trueVertex.GetY(), trueVertex.GetZ())));
             const CartesianVector tv(trueVertex.GetX(), 0.f, static_cast<float>(transform->YZtoV(trueVertex.GetY(), trueVertex.GetZ())));
             const CartesianVector tw(trueVertex.GetX(), 0.f, static_cast<float>(transform->YZtoW(trueVertex.GetY(), trueVertex.GetZ())));
 
             const CartesianVector ru(recoVertex.GetX(), 0.f, static_cast<float>(transform->YZtoU(recoVertex.GetY(), recoVertex.GetZ())));
             const CartesianVector rv(recoVertex.GetX(), 0.f, static_cast<float>(transform->YZtoV(recoVertex.GetY(), recoVertex.GetZ())));
             const CartesianVector rw(recoVertex.GetX(), 0.f, static_cast<float>(transform->YZtoW(recoVertex.GetY(), recoVertex.GetZ())));
 
             const float du{(ru - tu).GetMagnitude()};
             const float dv{(rv - tv).GetMagnitude()};
             const float dw{(rw - tw).GetMagnitude()};
 
             std::cout << "delta(u, v, w): (" << du << ", " << dv << "," << dw << ")" << std::endl;
 
             PANDORA_MONITORING_API(AddMarkerToVisualization(this->GetPandora(), &tu, "U true vertex", BLUE, 2));
             PANDORA_MONITORING_API(AddMarkerToVisualization(this->GetPandora(), &tv, "V true vertex", BLUE, 2));
             PANDORA_MONITORING_API(AddMarkerToVisualization(this->GetPandora(), &tw, "W true vertex", BLUE, 2));
             PANDORA_MONITORING_API(AddMarkerToVisualization(this->GetPandora(), &ru, "U reco vertex", RED, 2));
             PANDORA_MONITORING_API(AddMarkerToVisualization(this->GetPandora(), &rv, "V reco vertex", RED, 2));
             PANDORA_MONITORING_API(AddMarkerToVisualization(this->GetPandora(), &rw, "W reco vertex", RED, 2));
         }
 
         if (m_writeFile && LArVertexHelper::IsInFiducialVolume(this->GetPandora(), trueVertex, "dune_fd_hd"))
         {
             const CartesianVector delta{recoVertex - trueVertex};
             const float dx{delta.GetX()}, dy{delta.GetY()}, dz{delta.GetZ()}, dr{delta.GetMagnitude()};
             const float trueNuEnergy{pTrueNeutrino->GetEnergy()};
             const int success{1};
             PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "success", success));
             PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "trueNuEnergy", trueNuEnergy));
             PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "dx", dx));
             PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "dy", dy));
             PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "dz", dz));
             PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "dr", dr));
             PANDORA_MONITORING_API(FillTree(this->GetPandora(), m_treename.c_str()));
         }
     }
     else if (pTrueNeutrino)
     {
         const CartesianVector &trueVertex{pTrueNeutrino->GetVertex()};
 
         if (m_writeFile && LArVertexHelper::IsInFiducialVolume(this->GetPandora(), trueVertex, "dune_fd_hd"))
         {
             const int success{0};
             const float dx{-999.f}, dy{-999.f}, dz{-999.f}, dr{-999.f};
             const float trueNuEnergy{pTrueNeutrino->GetEnergy()};
             PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "success", success));
             PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "trueNuEnergy", trueNuEnergy));
             PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "dx", dx));
             PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "dy", dy));
             PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "dz", dz));
             PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "dr", dr));
             PANDORA_MONITORING_API(FillTree(this->GetPandora(), m_treename.c_str()));
         }
     }
 
     return STATUS_CODE_SUCCESS;
 }

StatusCode lar_content::VertexMonitoringAlgorithm::ReadSettings ( const pandora::TiXmlHandle xmlHandle )

private

Definition at line 166 of file VertexMonitoringAlgorithm.cc.

 {
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "Visualize", m_visualise));
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "WriteFile", m_writeFile));
     if (m_writeFile)
     {
         PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "Filename", m_filename));
         PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "Treename", m_treename));
     }
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "TransparencyThresholdE", m_transparencyThresholdE));
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "EnergyScaleThresholdE", m_energyScaleThresholdE));
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "ScalingFactor", m_scalingFactor));
 
     return STATUS_CODE_SUCCESS;
 }

StatusCode lar_content::VertexMonitoringAlgorithm::Run ( )

private

Definition at line 44 of file VertexMonitoringAlgorithm.cc.

 {
     if (m_visualise)
     {
         PANDORA_MONITORING_API(SetEveDisplayParameters(
             this->GetPandora(), true, DETECTOR_VIEW_XZ, m_transparencyThresholdE, m_energyScaleThresholdE, m_scalingFactor));
     }
 
     this->AssessVertices();
 
     if (m_visualise)
     {
         PANDORA_MONITORING_API(ViewEvent(this->GetPandora()));
     }
 
     return STATUS_CODE_SUCCESS;
 }