TransverseTensorVisualizationTool class. More...

#include <TransverseTensorVisualizationTool.h>

Inheritance diagram for lar_content::TransverseTensorVisualizationTool:

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

bool	Run (ThreeViewTransverseTracksAlgorithm *const pAlgorithm, TensorType &overlapTensor)
	Run the algorithm tool. More...

Private Member Functions
pandora::StatusCode	ReadSettings (const pandora::TiXmlHandle xmlHandle)

Private Attributes
unsigned int	m_minClusterConnections
	The minimum number of cluster connections for display. More...

bool	m_ignoreUnavailableClusters
	Whether to ignore (skip-over) unavailable clusters in the tensor. More...

bool	m_showEachIndividualElement
	Whether to draw each individual tensor element. More...

bool	m_showContext
	Whether to show input cluster lists to add context to tensor elements. More...

Additional Inherited Members
Public Types inherited from lar_content::TransverseTensorTool
typedef ThreeViewTransverseTracksAlgorithm::MatchingType::TensorType	TensorType

typedef std::vector< TensorType::ElementList::const_iterator >	IteratorList

Detailed Description

TransverseTensorVisualizationTool class.

Definition at line 19 of file TransverseTensorVisualizationTool.h.

Constructor & Destructor Documentation

lar_content::TransverseTensorVisualizationTool::TransverseTensorVisualizationTool ( )

Default constructor.

Definition at line 18 of file TransverseTensorVisualizationTool.cc.

                                                                      :
     m_minClusterConnections(1),
     m_ignoreUnavailableClusters(true),
     m_showEachIndividualElement(false),
     m_showContext(false)
 {
 }

Member Function Documentation

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

private

Definition at line 108 of file TransverseTensorVisualizationTool.cc.

 {
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MinClusterConnections", m_minClusterConnections));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "IgnoreUnavailableClusters", m_ignoreUnavailableClusters));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "ShowEachIndividualElement", m_showEachIndividualElement));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "ShowContext", m_showContext));
 
     return STATUS_CODE_SUCCESS;
 }

bool lar_content::TransverseTensorVisualizationTool::Run	(	ThreeViewTransverseTracksAlgorithm *const	pAlgorithm,
		TensorType &	overlapTensor
	)

virtual

Run the algorithm tool.

Parameters

pAlgorithm	address of the calling algorithm
overlapTensor	the overlap tensor

Returns: whether changes have been made by the tool

Implements lar_content::TransverseTensorTool.

Definition at line 28 of file TransverseTensorVisualizationTool.cc.

 {
     if (PandoraContentApi::GetSettings(*pAlgorithm)->ShouldDisplayAlgorithmInfo())
         std::cout << "----> Running Algorithm Tool: " << this->GetInstanceName() << ", " << this->GetType() << std::endl;
 
     ClusterSet usedKeyClusters;
     ClusterVector sortedKeyClusters;
     overlapTensor.GetSortedKeyClusters(sortedKeyClusters);
 
     for (const Cluster *const pKeyCluster : sortedKeyClusters)
     {
         if (m_ignoreUnavailableClusters && !pKeyCluster->IsAvailable())
             continue;
 
         if (usedKeyClusters.count(pKeyCluster))
             continue;
 
         unsigned int nU(0), nV(0), nW(0);
         TensorType::ElementList elementList;
         overlapTensor.GetConnectedElements(pKeyCluster, m_ignoreUnavailableClusters, elementList, nU, nV, nW);
 
         if ((nU < m_minClusterConnections) && (nV < m_minClusterConnections) && (nW < m_minClusterConnections))
             continue;
 
         if (nU * nV * nW == 0)
             continue;
 
         int counter(0);
         ClusterList allClusterListU, allClusterListV, allClusterListW;
         std::cout << " Connections: nU " << nU << ", nV " << nV << ", nW " << nW << ", nElements " << elementList.size() << std::endl;
 
         for (TensorType::ElementList::const_iterator eIter = elementList.begin(); eIter != elementList.end(); ++eIter)
         {
             if (allClusterListU.end() == std::find(allClusterListU.begin(), allClusterListU.end(), eIter->GetClusterU()))
                 allClusterListU.push_back(eIter->GetClusterU());
             if (allClusterListV.end() == std::find(allClusterListV.begin(), allClusterListV.end(), eIter->GetClusterV()))
                 allClusterListV.push_back(eIter->GetClusterV());
             if (allClusterListW.end() == std::find(allClusterListW.begin(), allClusterListW.end(), eIter->GetClusterW()))
                 allClusterListW.push_back(eIter->GetClusterW());
             usedKeyClusters.insert(eIter->GetClusterU());
 
             std::cout << " Element " << counter++ << ": MatchedFraction " << eIter->GetOverlapResult().GetMatchedFraction()
                       << ", MatchedSamplingPoints " << eIter->GetOverlapResult().GetNMatchedSamplingPoints() << ", xSpanU "
                       << eIter->GetOverlapResult().GetXOverlap().GetXSpanU() << ", xSpanV " << eIter->GetOverlapResult().GetXOverlap().GetXSpanV()
                       << ", xSpanW " << eIter->GetOverlapResult().GetXOverlap().GetXSpanW() << ", xOverlapSpan "
                       << eIter->GetOverlapResult().GetXOverlap().GetXOverlapSpan() << std::endl;
 
             if (m_showEachIndividualElement)
             {
                 const ClusterList clusterListU(1, eIter->GetClusterU()), clusterListV(1, eIter->GetClusterV()),
                     clusterListW(1, eIter->GetClusterW());
                 PANDORA_MONITORING_API(SetEveDisplayParameters(this->GetPandora(), false, DETECTOR_VIEW_XZ, -1.f, -1.f, 1.f));
                 PANDORA_MONITORING_API(VisualizeClusters(this->GetPandora(), &clusterListU, "UCluster", RED));
                 PANDORA_MONITORING_API(VisualizeClusters(this->GetPandora(), &clusterListV, "VCluster", GREEN));
                 PANDORA_MONITORING_API(VisualizeClusters(this->GetPandora(), &clusterListW, "WCluster", BLUE));
                 PANDORA_MONITORING_API(ViewEvent(this->GetPandora()));
             }
         }
 
         std::cout << " All Connected Clusters " << std::endl;
         PANDORA_MONITORING_API(SetEveDisplayParameters(this->GetPandora(), false, DETECTOR_VIEW_XZ, -1.f, -1.f, 1.f));
         PANDORA_MONITORING_API(VisualizeClusters(this->GetPandora(), &allClusterListU, "AllUClusters", RED));
         PANDORA_MONITORING_API(VisualizeClusters(this->GetPandora(), &allClusterListV, "AllVClusters", GREEN));
         PANDORA_MONITORING_API(VisualizeClusters(this->GetPandora(), &allClusterListW, "AllWClusters", BLUE));
 
         if (m_showContext)
         {
             PANDORA_MONITORING_API(VisualizeClusters(this->GetPandora(), &(pAlgorithm->GetInputClusterList(TPC_VIEW_U)), "InputClusterListU", GRAY));
             PANDORA_MONITORING_API(VisualizeClusters(this->GetPandora(), &(pAlgorithm->GetInputClusterList(TPC_VIEW_V)), "InputClusterListV", GRAY));
             PANDORA_MONITORING_API(VisualizeClusters(this->GetPandora(), &(pAlgorithm->GetInputClusterList(TPC_VIEW_W)), "InputClusterListW", GRAY));
         }
 
         PANDORA_MONITORING_API(ViewEvent(this->GetPandora()));
     }
 
     return false;
 }