CrossedTrackSplittingAlgorithm class. More...

#include "CrossedTrackSplittingAlgorithm.h"

Inheritance diagram for lar_content::CrossedTrackSplittingAlgorithm:

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

Protected Member Functions
virtual pandora::StatusCode	Run ()

Private Types
typedef KDTreeLinkerAlgo< const pandora::CaloHit *, 2 >	HitKDTree2D

typedef KDTreeNodeInfoT< const pandora::CaloHit *, 2 >	HitKDNode2D

typedef std::vector< HitKDNode2D >	HitKDNode2DList

typedef std::unordered_map< const pandora::Cluster *, pandora::ClusterSet >	ClusterToClustersMap

typedef std::unordered_map< const pandora::CaloHit , const pandora::Cluster >	HitToClusterMap

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

pandora::StatusCode	PreparationStep (const pandora::ClusterVector &clusterVector)
	Perform any preparatory actions, such as caching information for subsequent expensive calculations. More...

pandora::StatusCode	TidyUpStep ()
	Tidy up any information cached in e.g. the preparation step. More...

pandora::StatusCode	FindBestSplitPosition (const TwoDSlidingFitResult &slidingFit1, const TwoDSlidingFitResult &slidingFit2, pandora::CartesianVector &splitPosition, pandora::CartesianVector &direction1, pandora::CartesianVector &direction2) const
	Find the best split position and direction for a pair of clusters. More...

void	FindCandidateSplitPositions (const pandora::Cluster const pCluster1, const pandora::Cluster const pCluster2, pandora::CartesianPointVector &candidateVector) const
	Find average positions of pairs of hits within a maximum separation. More...

Private Attributes
float	m_maxClusterSeparation
	maximum separation of two clusters More...

float	m_maxClusterSeparationSquared
	maximum separation of two clusters (squared) More...

float	m_minCosRelativeAngle
	maximum relative angle between tracks after un-crossing More...

float	m_searchRegion1D
	Search region, applied to each dimension, for look-up from kd-trees. More...

ClusterToClustersMap	m_nearbyClusters
	The nearby clusters map. More...

Detailed Description

CrossedTrackSplittingAlgorithm class.

Definition at line 26 of file CrossedTrackSplittingAlgorithm.h.

Member Typedef Documentation

typedef std::unordered_map<const pandora::Cluster*, pandora::ClusterSet> lar_content::CrossedTrackSplittingAlgorithm::ClusterToClustersMap

private

Definition at line 39 of file CrossedTrackSplittingAlgorithm.h.

typedef KDTreeNodeInfoT<const pandora::CaloHit*, 2> lar_content::CrossedTrackSplittingAlgorithm::HitKDNode2D

private

Definition at line 36 of file CrossedTrackSplittingAlgorithm.h.

typedef std::vector<HitKDNode2D> lar_content::CrossedTrackSplittingAlgorithm::HitKDNode2DList

private

Definition at line 37 of file CrossedTrackSplittingAlgorithm.h.

typedef KDTreeLinkerAlgo<const pandora::CaloHit*, 2> lar_content::CrossedTrackSplittingAlgorithm::HitKDTree2D

private

Definition at line 35 of file CrossedTrackSplittingAlgorithm.h.

typedef std::unordered_map<const pandora::CaloHit*, const pandora::Cluster*> lar_content::CrossedTrackSplittingAlgorithm::HitToClusterMap

private

Definition at line 40 of file CrossedTrackSplittingAlgorithm.h.

Constructor & Destructor Documentation

lar_content::CrossedTrackSplittingAlgorithm::CrossedTrackSplittingAlgorithm ( )

Default constructor.

Definition at line 23 of file CrossedTrackSplittingAlgorithm.cc.

                                                                :
     m_maxClusterSeparation(2.f),
     m_maxClusterSeparationSquared(m_maxClusterSeparation * m_maxClusterSeparation),
     m_minCosRelativeAngle(0.966f),
     m_searchRegion1D(2.f)
 {
 }

Member Function Documentation

StatusCode lar_content::CrossedTrackSplittingAlgorithm::FindBestSplitPosition	(	const TwoDSlidingFitResult &	slidingFit1,
		const TwoDSlidingFitResult &	slidingFit2,
		pandora::CartesianVector &	splitPosition,
		pandora::CartesianVector &	direction1,
		pandora::CartesianVector &	direction2
	)		const

privatevirtual

Find the best split position and direction for a pair of clusters.

Parameters

slidingFit1	the sliding linear fit to the first cluster
slidingFit2	the sliding linear fit to the second cluster
splitPosition	the output split position
direction1	the output direction of the first new cluster
direction2	the output direction of the second new cluster

Implements lar_content::TwoDSlidingFitSplittingAndSwitchingAlgorithm.

Definition at line 86 of file CrossedTrackSplittingAlgorithm.cc.

References a1, a2, f, FindCandidateSplitPositions(), lar_content::LArClusterHelper::GetClosestDistance(), lar_content::TwoDSlidingFitResult::GetCluster(), lar_content::TwoDSlidingFitResult::GetGlobalFitPosition(), lar_content::TwoDSlidingFitResult::GetGlobalFitProjection(), lar_content::TwoDSlidingFitResult::GetGlobalMaxLayerPosition(), lar_content::TwoDSlidingFitResult::GetGlobalMinLayerPosition(), lar_content::LArPointingClusterHelper::GetIntersection(), lar_content::TwoDSlidingFitResult::GetLayerFitHalfWindowLength(), lar_content::TwoDSlidingFitResult::GetLocalPosition(), m_maxClusterSeparation, m_minCosRelativeAngle, m_nearbyClusters, max, t1, and t2.

 {
     // Use cached results from kd-tree to avoid expensive calculations
     if (!m_nearbyClusters.count(slidingFitResult1.GetCluster()) ||
         !m_nearbyClusters.count(slidingFitResult2.GetCluster()) ||
         !m_nearbyClusters.at(slidingFitResult1.GetCluster()).count(slidingFitResult2.GetCluster()) ||
         !m_nearbyClusters.at(slidingFitResult2.GetCluster()).count(slidingFitResult1.GetCluster()))
     {
         return STATUS_CODE_NOT_FOUND;
     }
 
     // Identify crossed-track topology and find candidate intersection positions
     const CartesianVector& minPosition1(slidingFitResult1.GetGlobalMinLayerPosition());
     const CartesianVector& maxPosition1(slidingFitResult1.GetGlobalMaxLayerPosition());
 
     const CartesianVector& minPosition2(slidingFitResult2.GetGlobalMinLayerPosition());
     const CartesianVector& maxPosition2(slidingFitResult2.GetGlobalMaxLayerPosition());
 
     if (LArClusterHelper::GetClosestDistance(minPosition1, slidingFitResult2.GetCluster()) < 2.f * m_maxClusterSeparation ||
         LArClusterHelper::GetClosestDistance(maxPosition1, slidingFitResult2.GetCluster()) < 2.f * m_maxClusterSeparation ||
         LArClusterHelper::GetClosestDistance(minPosition2, slidingFitResult1.GetCluster()) < 2.f * m_maxClusterSeparation ||
         LArClusterHelper::GetClosestDistance(maxPosition2, slidingFitResult1.GetCluster()) < 2.f * m_maxClusterSeparation)
     {
         return STATUS_CODE_NOT_FOUND;
     }
 
     if (LArClusterHelper::GetClosestDistance(slidingFitResult1.GetCluster(), slidingFitResult2.GetCluster()) > m_maxClusterSeparation)
         return STATUS_CODE_NOT_FOUND;
 
     CartesianPointVector candidateVector;
     this->FindCandidateSplitPositions(slidingFitResult1.GetCluster(), slidingFitResult2.GetCluster(), candidateVector);
 
     if (candidateVector.empty())
         return STATUS_CODE_NOT_FOUND;
 
 
     // Loop over candidate positions and find best split position
     bool foundSplit(false);
     float closestSeparationSquared(std::numeric_limits<float>::max());
 
     const float halfWindowLength1(slidingFitResult1.GetLayerFitHalfWindowLength());
     const float halfWindowLength2(slidingFitResult2.GetLayerFitHalfWindowLength());
 
     for (CartesianPointVector::const_iterator iter = candidateVector.begin(), iterEnd = candidateVector.end(); iter != iterEnd; ++iter)
     {
         const CartesianVector &candidatePosition(*iter);
 
         // Projections onto first cluster
         float rL1(0.f), rT1(0.f);
         CartesianVector R1(0.f, 0.f, 0.f);
         CartesianVector F1(0.f, 0.f, 0.f);
         CartesianVector B1(0.f, 0.f, 0.f);
 
         if (STATUS_CODE_SUCCESS != slidingFitResult1.GetGlobalFitProjection(candidatePosition, R1))
             continue;
 
         slidingFitResult1.GetLocalPosition(R1, rL1, rT1);
         if ((STATUS_CODE_SUCCESS != slidingFitResult1.GetGlobalFitPosition(rL1 + halfWindowLength1, F1)) ||
             (STATUS_CODE_SUCCESS != slidingFitResult1.GetGlobalFitPosition(rL1 - halfWindowLength1, B1)))
         {
             continue;
         }
 
         // Projections onto second cluster
         float rL2(0.f), rT2(0.f);
         CartesianVector R2(0.f, 0.f, 0.f);
         CartesianVector F2(0.f, 0.f, 0.f);
         CartesianVector B2(0.f, 0.f, 0.f);
 
         if (STATUS_CODE_SUCCESS != slidingFitResult2.GetGlobalFitProjection(candidatePosition, R2))
             continue;
 
         slidingFitResult2.GetLocalPosition(R2, rL2, rT2);
         if ((STATUS_CODE_SUCCESS != slidingFitResult2.GetGlobalFitPosition(rL2 + halfWindowLength2, F2)) ||
             (STATUS_CODE_SUCCESS != slidingFitResult2.GetGlobalFitPosition(rL2 - halfWindowLength2, B2)))
         {
             continue;
         }
 
         // Calculate average position
         const CartesianVector C0((R1 + R2) * 0.5);
 
         // Calculate intersected position:
         // ==============================
         // First cluster gives set of points: B1->R1->F1
         // Second cluster gives set of points: B2->R2->F2
         //
         // Try swapping B1 with B2 to see if this gives intersecting straight lines:
         //
         //   F1   F2     a2   b1
         //    |   |       |   |
         //     |  |        |  |
         //     R1 R2       R1 R2
         //      | |         |  |
         //      |  |        |   |
         //     B1   B2     a1    b2
 
         // First straight line is a1->R1->b1
         // Second straight line is a2->R2->b2
 
         const CartesianVector a1(B1);
         const CartesianVector a2(F1);
 
         for (unsigned int iForward = 0; iForward<2; ++iForward)
         {
             const CartesianVector b1((0 == iForward) ? F2 : B2);
             const CartesianVector b2((0 == iForward) ? B2 : F2);
 
             const CartesianVector s1((b1 - R2).GetUnitVector());
             const CartesianVector t1((R1 - a1).GetUnitVector());
             const CartesianVector s2((b2 - R2).GetUnitVector());
             const CartesianVector t2((R1 - a2).GetUnitVector());
 
             if (s1.GetDotProduct(t1) < std::max(m_minCosRelativeAngle,-s1.GetDotProduct(s2)) ||
                 s2.GetDotProduct(t2) < std::max(m_minCosRelativeAngle,-t1.GetDotProduct(t2)))
                 continue;
 
             const CartesianVector p1((b1 - a1).GetUnitVector());
             const CartesianVector p2((b2 - a2).GetUnitVector());
 
             float mu1(0.f), mu2(0.f);
             CartesianVector C1(0.f,0.f,0.f);
 
             try
             {
                 LArPointingClusterHelper::GetIntersection(a1, p1, a2, p2, C1, mu1, mu2);
             }
             catch (const StatusCodeException &)
             {
                 continue;
             }
 
             if (mu1 < 0.f || mu2 < 0.f || mu1 > (b1 - a1).GetMagnitude() || mu2 > (b2 - a2).GetMagnitude())
                 continue;
 
             const float thisSeparationSquared((C0 - C1).GetMagnitudeSquared());
 
             if (thisSeparationSquared < closestSeparationSquared)
             {
                 closestSeparationSquared = thisSeparationSquared;
                 splitPosition = (C0 + C1) * 0.5;
                 firstDirection = t2 * -1.f;
                 secondDirection = t1;
                 foundSplit = true;
             }
         }
     }
 
     if (!foundSplit)
         return STATUS_CODE_NOT_FOUND;
 
     return STATUS_CODE_SUCCESS;
 }

void lar_content::CrossedTrackSplittingAlgorithm::FindCandidateSplitPositions	(	const pandora::Cluster *const	pCluster1,
		const pandora::Cluster *const	pCluster2,
		pandora::CartesianPointVector &	candidateVector
	)		const

private

Find average positions of pairs of hits within a maximum separation.

Parameters

pCluster1	the first cluster
pCluster2	the second cluster
candidateVector	to receive the average positions

Definition at line 243 of file CrossedTrackSplittingAlgorithm.cc.

References lar_content::LArClusterHelper::GetClosestPosition(), m_maxClusterSeparationSquared, and lar_content::LArClusterHelper::SortHitsByPosition().

Referenced by FindBestSplitPosition().

 {
     // ATTN The following is double-double counting
     CaloHitList caloHitList1, caloHitList2;
     pCluster1->GetOrderedCaloHitList().FillCaloHitList(caloHitList1);
     pCluster2->GetOrderedCaloHitList().FillCaloHitList(caloHitList2);
 
     CaloHitVector caloHitVector1(caloHitList1.begin(), caloHitList1.end()), caloHitVector2(caloHitList2.begin(), caloHitList2.end());
     std::sort(caloHitVector1.begin(), caloHitVector1.end(), LArClusterHelper::SortHitsByPosition);
     std::sort(caloHitVector2.begin(), caloHitVector2.end(), LArClusterHelper::SortHitsByPosition);
 
     for (const CaloHit *const pCaloHit : caloHitVector1)
     {
         const CartesianVector position1(pCaloHit->GetPositionVector());
         const CartesianVector position2(LArClusterHelper::GetClosestPosition(position1, pCluster2));
 
         if ((position1 - position2).GetMagnitudeSquared() < m_maxClusterSeparationSquared)
             candidateVector.push_back((position1 + position2) * 0.5);
     }
 
     for (const CaloHit *const pCaloHit : caloHitVector2)
     {
         const CartesianVector position2(pCaloHit->GetPositionVector());
         const CartesianVector position1(LArClusterHelper::GetClosestPosition(position2, pCluster1));
 
         if ((position2 - position1).GetMagnitudeSquared() < m_maxClusterSeparationSquared)
             candidateVector.push_back((position2 + position1) * 0.5);
     }
 }

StatusCode lar_content::CrossedTrackSplittingAlgorithm::PreparationStep ( const pandora::ClusterVector & clusterVector )

privatevirtual

Perform any preparatory actions, such as caching information for subsequent expensive calculations.

Parameters

clusterVector the cluster vector

Reimplemented from lar_content::TwoDSlidingFitSplittingAndSwitchingAlgorithm.

Definition at line 33 of file CrossedTrackSplittingAlgorithm.cc.

References lar_content::KDTreeLinkerAlgo< DATA, DIM >::build(), lar_content::build_2d_kd_search_region(), lar_content::fill_and_bound_2d_kd_tree(), m_nearbyClusters, m_searchRegion1D, and lar_content::KDTreeLinkerAlgo< DATA, DIM >::search().

 {
     // ATTN Don't need to update nearby cluster map after cluster merges because algorithm does not revisit processed clusters
     HitToClusterMap hitToClusterMap;
     CaloHitList allCaloHits;
 
     for (const Cluster *const pCluster : clusterVector)
     {
         CaloHitList daughterHits;
         pCluster->GetOrderedCaloHitList().FillCaloHitList(daughterHits);
         allCaloHits.insert(allCaloHits.end(), daughterHits.begin(), daughterHits.end());
 
         for (const CaloHit *const pCaloHit : daughterHits)
             (void) hitToClusterMap.insert(HitToClusterMap::value_type(pCaloHit, pCluster));
     }
 
     HitKDTree2D kdTree;
     HitKDNode2DList hitKDNode2DList;
 
     KDTreeBox hitsBoundingRegion2D(fill_and_bound_2d_kd_tree(allCaloHits, hitKDNode2DList));
     kdTree.build(hitKDNode2DList, hitsBoundingRegion2D);
 
     for (const Cluster *const pCluster : clusterVector)
     {
         CaloHitList daughterHits;
         pCluster->GetOrderedCaloHitList().FillCaloHitList(daughterHits);
 
         for (const CaloHit *const pCaloHit : daughterHits)
         {
             KDTreeBox searchRegionHits(build_2d_kd_search_region(pCaloHit, m_searchRegion1D, m_searchRegion1D));
 
             HitKDNode2DList found;
             kdTree.search(searchRegionHits, found);
 
             for (const auto &hit : found)
                 (void) m_nearbyClusters[pCluster].insert(hitToClusterMap.at(hit.data));
         }
     }
 
     return STATUS_CODE_SUCCESS;
 }

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

privatevirtual

Reimplemented from lar_content::TwoDSlidingFitSplittingAndSwitchingAlgorithm.

Definition at line 276 of file CrossedTrackSplittingAlgorithm.cc.

References m_maxClusterSeparation, m_maxClusterSeparationSquared, m_minCosRelativeAngle, m_searchRegion1D, and lar_content::TwoDSlidingFitSplittingAndSwitchingAlgorithm::ReadSettings().

 {
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle,
         "MaxClusterSeparation", m_maxClusterSeparation));
     m_maxClusterSeparationSquared = m_maxClusterSeparation * m_maxClusterSeparation;
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle,
         "MinCosRelativeAngle", m_minCosRelativeAngle));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle,
         "SearchRegion1D", m_searchRegion1D));
 
     return TwoDSlidingFitSplittingAndSwitchingAlgorithm::ReadSettings(xmlHandle);
 }

StatusCode lar_content::TwoDSlidingFitSplittingAndSwitchingAlgorithm::Run ( )

protectedvirtualinherited

Definition at line 29 of file TwoDSlidingFitSplittingAndSwitchingAlgorithm.cc.

References lar_content::TwoDSlidingFitSplittingAndSwitchingAlgorithm::BuildSlidingFitResultMap(), f, lar_content::TwoDSlidingFitSplittingAndSwitchingAlgorithm::FindBestSplitPosition(), lar_content::TwoDSlidingFitResult::GetCluster(), lar_content::TwoDSlidingFitSplittingAndSwitchingAlgorithm::GetListOfCleanClusters(), lar_content::TwoDSlidingFitSplittingAndSwitchingAlgorithm::PreparationStep(), lar_content::TwoDSlidingFitSplittingAndSwitchingAlgorithm::ReplaceClusters(), and lar_content::TwoDSlidingFitSplittingAndSwitchingAlgorithm::TidyUpStep().

 {
     const ClusterList *pClusterList = NULL;
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::GetCurrentList(*this, pClusterList));
 
     // Get ordered list of clean clusters
     ClusterVector clusterVector;
     this->GetListOfCleanClusters(pClusterList, clusterVector);
 
     // Calculate sliding fit results for clean clusters
     TwoDSlidingFitResultMap slidingFitResultMap;
     this->BuildSlidingFitResultMap(clusterVector, slidingFitResultMap);
 
     // May choose to cache information here, for subsequent expensive calculations
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->PreparationStep(clusterVector));
 
     // Loop over clusters, identify split positions, perform splits
     for (ClusterVector::iterator iter1 = clusterVector.begin(), iterEnd1 = clusterVector.end(); iter1 != iterEnd1; ++iter1)
     {
         if (NULL == *iter1)
             continue;
 
         TwoDSlidingFitResultMap::iterator sIter1 = slidingFitResultMap.find(*iter1);
 
         if (slidingFitResultMap.end() == sIter1)
             continue;
 
         const TwoDSlidingFitResult &slidingFitResult1(sIter1->second);
 
         for (ClusterVector::iterator iter2 = iter1, iterEnd2 = iterEnd1; iter2 != iterEnd2; ++iter2)
         {
             if (NULL == *iter2)
                 continue;
 
             TwoDSlidingFitResultMap::iterator sIter2 = slidingFitResultMap.find(*iter2);
 
             if (slidingFitResultMap.end() == sIter2)
                 continue;
 
             const TwoDSlidingFitResult &slidingFitResult2(sIter2->second);
 
             if (slidingFitResult1.GetCluster() == slidingFitResult2.GetCluster())
                 continue;
 
             CartesianVector splitPosition(0.f,0.f,0.f);
             CartesianVector firstDirection(0.f,0.f,0.f);
             CartesianVector secondDirection(0.f,0.f,0.f);
 
             if (STATUS_CODE_SUCCESS != this->FindBestSplitPosition(slidingFitResult1, slidingFitResult2, splitPosition, firstDirection, secondDirection))
                 continue;
 
             const Cluster *const pCluster1 = slidingFitResult1.GetCluster();
             const Cluster *const pCluster2 = slidingFitResult2.GetCluster();
 
             if (STATUS_CODE_SUCCESS != this->ReplaceClusters(pCluster1, pCluster2, splitPosition, firstDirection, secondDirection))
                 continue;
 
             slidingFitResultMap.erase(sIter1);
             slidingFitResultMap.erase(sIter2);
 
             *iter1 = NULL;
             *iter2 = NULL;
 
             break;
         }
     }
 
     return this->TidyUpStep();
 }

StatusCode lar_content::CrossedTrackSplittingAlgorithm::TidyUpStep ( )

privatevirtual

Tidy up any information cached in e.g. the preparation step.

Reimplemented from lar_content::TwoDSlidingFitSplittingAndSwitchingAlgorithm.

Definition at line 77 of file CrossedTrackSplittingAlgorithm.cc.

References m_nearbyClusters.

 {
     m_nearbyClusters.clear();
 
     return STATUS_CODE_SUCCESS;
 }

Member Data Documentation

float lar_content::CrossedTrackSplittingAlgorithm::m_maxClusterSeparation

private

maximum separation of two clusters

Definition at line 58 of file CrossedTrackSplittingAlgorithm.h.

Referenced by FindBestSplitPosition(), and ReadSettings().

float lar_content::CrossedTrackSplittingAlgorithm::m_maxClusterSeparationSquared

private

maximum separation of two clusters (squared)

Definition at line 59 of file CrossedTrackSplittingAlgorithm.h.

Referenced by FindCandidateSplitPositions(), and ReadSettings().

float lar_content::CrossedTrackSplittingAlgorithm::m_minCosRelativeAngle

private

maximum relative angle between tracks after un-crossing

Definition at line 60 of file CrossedTrackSplittingAlgorithm.h.

Referenced by FindBestSplitPosition(), and ReadSettings().

ClusterToClustersMap lar_content::CrossedTrackSplittingAlgorithm::m_nearbyClusters

private

The nearby clusters map.

Definition at line 63 of file CrossedTrackSplittingAlgorithm.h.

Referenced by FindBestSplitPosition(), PreparationStep(), and TidyUpStep().

float lar_content::CrossedTrackSplittingAlgorithm::m_searchRegion1D

private

Search region, applied to each dimension, for look-up from kd-trees.

Definition at line 62 of file CrossedTrackSplittingAlgorithm.h.

Referenced by PreparationStep(), and ReadSettings().

The documentation for this class was generated from the following files:

/cvmfs/larsoft.opensciencegrid.org/products/larpandoracontent/v03_14_03/source/larpandoracontent/LArTwoDReco/LArClusterSplitting/CrossedTrackSplittingAlgorithm.h
/cvmfs/larsoft.opensciencegrid.org/products/larpandoracontent/v03_14_03/source/larpandoracontent/LArTwoDReco/LArClusterSplitting/CrossedTrackSplittingAlgorithm.cc

Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation