ThreeDHitCreationAlgorithm::Algorithm class. More...

#include <ThreeDHitCreationAlgorithm.h>

Inheritance diagram for lar_content::ThreeDHitCreationAlgorithm:

Classes
class	ProtoHit
	Proto hits are temporary constructs to be used during iterative 3D hit procedure. More...

class	TrajectorySample
	Trajectory samples record the results of sampling a particles in a particular view. More...

Public Types
typedef std::vector < TrajectorySample >	TrajectorySampleVector

typedef std::vector< ProtoHit >	ProtoHitVector

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

void	FilterCaloHitsByType (const pandora::CaloHitVector &inputCaloHitVector, const pandora::HitType hitType, pandora::CaloHitVector &outputCaloHitVector) const
	Get the subset of a provided calo hit vector corresponding to a specified hit type. More...

Private Types
typedef std::vector < HitCreationBaseTool * >	HitCreationToolVector

Private Member Functions
pandora::StatusCode	Run ()

void	SeparateTwoDHits (const pandora::ParticleFlowObject *const pPfo, const ProtoHitVector &protoHitVector, pandora::CaloHitVector &remainingHitVector) const
	Get the list of 2D calo hits in a pfo for which 3D hits have and have not been created. More...

void	IterativeTreatment (ProtoHitVector &protoHitVector) const
	Improve initial 3D hits by fitting proto hits and iteratively creating consisted 3D hit trajectory. More...

void	ExtractResults (const ProtoHitVector &protoHitVector, double &chi2, pandora::CartesianPointVector &pointVector) const
	Extract key results from a provided proto hit vector. More...

double	GetChi2WrtFit (const ThreeDSlidingFitResult &slidingFitResult, const ProtoHitVector &protoHitVector) const
	Receive a chi2 value indicating consistency of a list of proto hits with a provided 3D sliding fit trajectory. More...

double	GetHitMovementChi2 (const ProtoHitVector &protoHitVector) const
	Receive a chi2 value indicating consistency of a list of proto hits with the original, input hit positions. More...

void	RefineHitPositions (const ThreeDSlidingFitResult &slidingFitResult, ProtoHitVector &protoHitVector) const
	Refine the 3D hit positions (and chi2) for a list of proto hits, in accordance with a provided 3D sliding fit trajectory. More...

void	CreateThreeDHits (const ProtoHitVector &protoHitVector, pandora::CaloHitList &newThreeDHits) const
	Create new three dimensional hits from two dimensional hits. More...

void	CreateThreeDHit (const ProtoHit &protoHit, const pandora::CaloHit *&pCaloHit3D) const
	Create a new three dimensional hit from a two dimensional hit. More...

bool	CheckThreeDHit (const ProtoHit &protoHit) const
	Check that a new three dimensional position is not unphysical. More...

void	AddThreeDHitsToPfo (const pandora::ParticleFlowObject *const pPfo, const pandora::CaloHitList &caloHitList) const
	Add a specified list of three dimensional hits to a cluster in a pfo, creating the new cluster if required. More...

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

Private Attributes
HitCreationToolVector	m_algorithmToolVector
	The algorithm tool vector. More...

std::string	m_inputPfoListName
	The name of the input pfo list. More...

std::string	m_outputCaloHitListName
	The name of the output calo hit list. More...

std::string	m_outputClusterListName
	The name of the output cluster list. More...

bool	m_iterateTrackHits
	Whether to enable iterative improvement of 3D hits for track trajectories. More...

bool	m_iterateShowerHits
	Whether to enable iterative improvement of 3D hits for showers. More...

unsigned int	m_slidingFitHalfWindow
	The sliding linear fit half window. More...

unsigned int	m_nHitRefinementIterations
	The maximum number of hit refinement iterations. More...

double	m_sigma3DFitMultiplier
	Multiplicative factor: sigmaUVW (same as sigmaHit and sigma2DFit) to sigma3DFit. More...

double	m_iterationMaxChi2Ratio
	Max ratio between current and previous chi2 values to cease iterations. More...

Detailed Description

ThreeDHitCreationAlgorithm::Algorithm class.

Definition at line 27 of file ThreeDHitCreationAlgorithm.h.

Member Typedef Documentation

typedef std::vector<HitCreationBaseTool *> lar_content::ThreeDHitCreationAlgorithm::HitCreationToolVector

private

Definition at line 271 of file ThreeDHitCreationAlgorithm.h.

typedef std::vector<ProtoHit> lar_content::ThreeDHitCreationAlgorithm::ProtoHitVector

Definition at line 163 of file ThreeDHitCreationAlgorithm.h.

typedef std::vector<TrajectorySample> lar_content::ThreeDHitCreationAlgorithm::TrajectorySampleVector

Definition at line 68 of file ThreeDHitCreationAlgorithm.h.

Constructor & Destructor Documentation

lar_content::ThreeDHitCreationAlgorithm::ThreeDHitCreationAlgorithm ( )

Default constructor.

Definition at line 27 of file ThreeDHitCreationAlgorithm.cc.

                                                        :
     m_iterateTrackHits(true),
     m_iterateShowerHits(false),
     m_slidingFitHalfWindow(10),
     m_nHitRefinementIterations(10),
     m_sigma3DFitMultiplier(0.2),
     m_iterationMaxChi2Ratio(1.)
 {
 }

Member Function Documentation

void lar_content::ThreeDHitCreationAlgorithm::AddThreeDHitsToPfo	(	const pandora::ParticleFlowObject *const	pPfo,
		const pandora::CaloHitList &	caloHitList
	)		const

private

Add a specified list of three dimensional hits to a cluster in a pfo, creating the new cluster if required.

Parameters

pPfo	the address of the pfo
caloHitList	the list of three dimensional hits

Definition at line 391 of file ThreeDHitCreationAlgorithm.cc.

 {
     if (caloHitList.empty())
         throw StatusCodeException(STATUS_CODE_NOT_INITIALIZED);
 
     ClusterList threeDClusterList;
     LArPfoHelper::GetThreeDClusterList(pPfo, threeDClusterList);
 
     if (!threeDClusterList.empty())
         throw StatusCodeException(STATUS_CODE_FAILURE);
 
     const ClusterList *pClusterList(nullptr);
     std::string clusterListName;
     PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::CreateTemporaryListAndSetCurrent(*this, pClusterList, clusterListName));
 
     PandoraContentApi::Cluster::Parameters parameters;
     parameters.m_caloHitList.insert(parameters.m_caloHitList.end(), caloHitList.begin(), caloHitList.end());
 
     const Cluster *pCluster3D(nullptr);
     PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::Cluster::Create(*this, parameters, pCluster3D));
 
     if (!pCluster3D || !pClusterList || pClusterList->empty())
         throw StatusCodeException(STATUS_CODE_FAILURE);
 
     PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::SaveList<Cluster>(*this, m_outputClusterListName));
     PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::AddToPfo(*this, pPfo, pCluster3D));
 }

bool lar_content::ThreeDHitCreationAlgorithm::CheckThreeDHit ( const ProtoHit & protoHit ) const

private

Check that a new three dimensional position is not unphysical.

Parameters

protoHit	the proto hit
boolean

Definition at line 373 of file ThreeDHitCreationAlgorithm.cc.

 {
     try
     {
         // Check that corresponding pseudo layer is within range - TODO use full LArTPC geometry here
         (void)PandoraContentApi::GetPlugins(*this)->GetPseudoLayerPlugin()->GetPseudoLayer(protoHit.GetPosition3D());
     }
     catch (StatusCodeException &)
     {
         return false;
     }
 
     // TODO Check against detector geometry
     return true;
 }

void lar_content::ThreeDHitCreationAlgorithm::CreateThreeDHit	(	const ProtoHit &	protoHit,
		const pandora::CaloHit *&	pCaloHit3D
	)		const

private

Create a new three dimensional hit from a two dimensional hit.

Parameters

protoHit	the proto hit containing all required information
pCaloHit3D	to receive the address of the new three dimensional calo hit

Definition at line 338 of file ThreeDHitCreationAlgorithm.cc.

 {
     if (!this->CheckThreeDHit(protoHit))
         throw StatusCodeException(STATUS_CODE_INVALID_PARAMETER);
 
     PandoraContentApi::CaloHit::Parameters parameters;
     parameters.m_positionVector = protoHit.GetPosition3D();
     parameters.m_hitType = TPC_3D;
 
     const CaloHit *const pCaloHit2D(protoHit.GetParentCaloHit2D());
     parameters.m_pParentAddress = static_cast<const void *>(pCaloHit2D);
 
     // TODO Check these parameters, especially new cell dimensions
     parameters.m_cellThickness = pCaloHit2D->GetCellThickness();
     parameters.m_cellGeometry = RECTANGULAR;
     parameters.m_cellSize0 = pCaloHit2D->GetCellLengthScale();
     parameters.m_cellSize1 = pCaloHit2D->GetCellLengthScale();
     parameters.m_cellNormalVector = pCaloHit2D->GetCellNormalVector();
     parameters.m_expectedDirection = pCaloHit2D->GetExpectedDirection();
     parameters.m_nCellRadiationLengths = pCaloHit2D->GetNCellRadiationLengths();
     parameters.m_nCellInteractionLengths = pCaloHit2D->GetNCellInteractionLengths();
     parameters.m_time = pCaloHit2D->GetTime();
     parameters.m_inputEnergy = pCaloHit2D->GetInputEnergy();
     parameters.m_mipEquivalentEnergy = pCaloHit2D->GetMipEquivalentEnergy();
     parameters.m_electromagneticEnergy = pCaloHit2D->GetElectromagneticEnergy();
     parameters.m_hadronicEnergy = pCaloHit2D->GetHadronicEnergy();
     parameters.m_isDigital = pCaloHit2D->IsDigital();
     parameters.m_hitRegion = pCaloHit2D->GetHitRegion();
     parameters.m_layer = pCaloHit2D->GetLayer();
     parameters.m_isInOuterSamplingLayer = pCaloHit2D->IsInOuterSamplingLayer();
     PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::CaloHit::Create(*this, parameters, pCaloHit3D));
 }

void lar_content::ThreeDHitCreationAlgorithm::CreateThreeDHits	(	const ProtoHitVector &	protoHitVector,
		pandora::CaloHitList &	newThreeDHits
	)		const

private

Create new three dimensional hits from two dimensional hits.

Parameters

protoHitVector	the input proto hit vector
newThreeDHits	to receive the addresses of the new three dimensional calo hits

Definition at line 322 of file ThreeDHitCreationAlgorithm.cc.

 {
     for (const ProtoHit &protoHit : protoHitVector)
     {
         const CaloHit *pCaloHit3D(nullptr);
         this->CreateThreeDHit(protoHit, pCaloHit3D);
 
         if (!pCaloHit3D)
             throw StatusCodeException(STATUS_CODE_FAILURE);
 
         newThreeDHits.push_back(pCaloHit3D);
     }
 }

void lar_content::ThreeDHitCreationAlgorithm::ExtractResults	(	const ProtoHitVector &	protoHitVector,
		double &	chi2,
		pandora::CartesianPointVector &	pointVector
	)		const

private

Extract key results from a provided proto hit vector.

Parameters

protoHitVector	the proto hit vector
chi2	to receive the sum of the proto hit chi2 values
pointVector	to receive a vector of proto hit 3D positions

Definition at line 180 of file ThreeDHitCreationAlgorithm.cc.

 {
     chi2 = 0.;
     pointVector.clear();
 
     for (const ProtoHit &protoHit : protoHitVector)
     {
         chi2 += protoHit.GetChi2();
         pointVector.push_back(protoHit.GetPosition3D());
     }
 }

void lar_content::ThreeDHitCreationAlgorithm::FilterCaloHitsByType	(	const pandora::CaloHitVector &	inputCaloHitVector,
		const pandora::HitType	hitType,
		pandora::CaloHitVector &	outputCaloHitVector
	)		const

Get the subset of a provided calo hit vector corresponding to a specified hit type.

Parameters

inputCaloHitVector	the input calo hit vector
hitType	the hit type to filter upon
outputCaloHitVector	to receive the output calo hit vector

Definition at line 39 of file ThreeDHitCreationAlgorithm.cc.

 {
     for (const CaloHit *const pCaloHit : inputCaloHitVector)
     {
         if (hitType == pCaloHit->GetHitType())
             outputCaloHitVector.push_back(pCaloHit);
     }
 }

double lar_content::ThreeDHitCreationAlgorithm::GetChi2WrtFit	(	const ThreeDSlidingFitResult &	slidingFitResult,
		const ProtoHitVector &	protoHitVector
	)		const

private

Receive a chi2 value indicating consistency of a list of proto hits with a provided 3D sliding fit trajectory.

Parameters

slidingFitResult	the 3D sliding fit result
protoHitVector	the proto hit vector

Returns: the chi2 value

Definition at line 194 of file ThreeDHitCreationAlgorithm.cc.

 {
     const double sigmaUVW(LArGeometryHelper::GetSigmaUVW(this->GetPandora()));
     const double sigma3DFit(sigmaUVW * m_sigma3DFitMultiplier);
 
     double chi2WrtFit(0.);
 
     for (const ProtoHit &protoHit : protoHitVector)
     {
         CartesianVector pointOnFit(0.f, 0.f, 0.f);
         const double rL(slidingFitResult.GetLongitudinalDisplacement(protoHit.GetPosition3D()));
 
         if (STATUS_CODE_SUCCESS != slidingFitResult.GetGlobalFitPosition(rL, pointOnFit))
             continue;
 
         const double uFit(PandoraContentApi::GetPlugins(*this)->GetLArTransformationPlugin()->YZtoU(pointOnFit.GetY(), pointOnFit.GetZ()));
         const double vFit(PandoraContentApi::GetPlugins(*this)->GetLArTransformationPlugin()->YZtoV(pointOnFit.GetY(), pointOnFit.GetZ()));
         const double wFit(PandoraContentApi::GetPlugins(*this)->GetLArTransformationPlugin()->YZtoW(pointOnFit.GetY(), pointOnFit.GetZ()));
 
         const double outputU(PandoraContentApi::GetPlugins(*this)->GetLArTransformationPlugin()->YZtoU(
             protoHit.GetPosition3D().GetY(), protoHit.GetPosition3D().GetZ()));
         const double outputV(PandoraContentApi::GetPlugins(*this)->GetLArTransformationPlugin()->YZtoV(
             protoHit.GetPosition3D().GetY(), protoHit.GetPosition3D().GetZ()));
         const double outputW(PandoraContentApi::GetPlugins(*this)->GetLArTransformationPlugin()->YZtoW(
             protoHit.GetPosition3D().GetY(), protoHit.GetPosition3D().GetZ()));
 
         const double deltaUFit(uFit - outputU), deltaVFit(vFit - outputV), deltaWFit(wFit - outputW);
         chi2WrtFit += ((deltaUFit * deltaUFit) / (sigma3DFit * sigma3DFit)) + ((deltaVFit * deltaVFit) / (sigma3DFit * sigma3DFit)) +
                       ((deltaWFit * deltaWFit) / (sigma3DFit * sigma3DFit));
     }
 
     return chi2WrtFit;
 }

double lar_content::ThreeDHitCreationAlgorithm::GetHitMovementChi2 ( const ProtoHitVector & protoHitVector ) const

private

Receive a chi2 value indicating consistency of a list of proto hits with the original, input hit positions.

Parameters

protoHitVector the proto hit vector

Returns: the chi2 value

Definition at line 230 of file ThreeDHitCreationAlgorithm.cc.

 {
     const double sigmaUVW(LArGeometryHelper::GetSigmaUVW(this->GetPandora()));
     double hitMovementChi2(0.);
 
     for (const ProtoHit &protoHit : protoHitVector)
     {
         const CaloHit *const pCaloHit2D(protoHit.GetParentCaloHit2D());
         const HitType hitType(pCaloHit2D->GetHitType());
 
         const CartesianVector projectedPosition(LArGeometryHelper::ProjectPosition(this->GetPandora(), protoHit.GetPosition3D(), hitType));
         const double delta(static_cast<double>(pCaloHit2D->GetPositionVector().GetZ() - projectedPosition.GetZ()));
 
         hitMovementChi2 += (delta * delta) / (sigmaUVW * sigmaUVW);
     }
 
     return hitMovementChi2;
 }

void lar_content::ThreeDHitCreationAlgorithm::IterativeTreatment ( ProtoHitVector & protoHitVector ) const

private

Improve initial 3D hits by fitting proto hits and iteratively creating consisted 3D hit trajectory.

Parameters

protoHitVector the vector of proto hits, describing current state of 3D hit construction

Definition at line 138 of file ThreeDHitCreationAlgorithm.cc.

 {
     const float layerPitch(LArGeometryHelper::GetWireZPitch(this->GetPandora()));
     const unsigned int layerWindow(m_slidingFitHalfWindow);
 
     double originalChi2(0.);
     CartesianPointVector currentPoints3D;
     this->ExtractResults(protoHitVector, originalChi2, currentPoints3D);
 
     try
     {
         const ThreeDSlidingFitResult originalSlidingFitResult(&currentPoints3D, layerWindow, layerPitch);
         const double originalChi2WrtFit(this->GetChi2WrtFit(originalSlidingFitResult, protoHitVector));
         double currentChi2(originalChi2 + originalChi2WrtFit);
 
         unsigned int nIterations(0);
 
         while (nIterations++ < m_nHitRefinementIterations)
         {
             ProtoHitVector newProtoHitVector(protoHitVector);
             const ThreeDSlidingFitResult newSlidingFitResult(&currentPoints3D, layerWindow, layerPitch);
             this->RefineHitPositions(newSlidingFitResult, newProtoHitVector);
 
             double newChi2(0.);
             CartesianPointVector newPoints3D;
             this->ExtractResults(newProtoHitVector, newChi2, newPoints3D);
 
             if (newChi2 > m_iterationMaxChi2Ratio * currentChi2)
                 break;
 
             currentChi2 = newChi2;
             currentPoints3D = newPoints3D;
             protoHitVector = newProtoHitVector;
         }
     }
     catch (const StatusCodeException &)
     {
     }
 }

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

private

Definition at line 463 of file ThreeDHitCreationAlgorithm.cc.

 {
     AlgorithmToolVector algorithmToolVector;
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ProcessAlgorithmToolList(*this, xmlHandle, "HitCreationTools", algorithmToolVector));
 
     for (AlgorithmToolVector::const_iterator iter = algorithmToolVector.begin(), iterEnd = algorithmToolVector.end(); iter != iterEnd; ++iter)
     {
         HitCreationBaseTool *const pHitCreationTool(dynamic_cast<HitCreationBaseTool *>(*iter));
 
         if (!pHitCreationTool)
             return STATUS_CODE_INVALID_PARAMETER;
 
         m_algorithmToolVector.push_back(pHitCreationTool);
     }
 
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "InputPfoListName", m_inputPfoListName));
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "OutputCaloHitListName", m_outputCaloHitListName));
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "OutputClusterListName", m_outputClusterListName));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "IterateTrackHits", m_iterateTrackHits));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "IterateShowerHits", m_iterateShowerHits));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "SlidingFitHalfWindow", m_slidingFitHalfWindow));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "NHitRefinementIterations", m_nHitRefinementIterations));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "Sigma3DFitMultiplier", m_sigma3DFitMultiplier));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "IterationMaxChi2Ratio", m_iterationMaxChi2Ratio));
 
     return STATUS_CODE_SUCCESS;
 }

void lar_content::ThreeDHitCreationAlgorithm::RefineHitPositions	(	const ThreeDSlidingFitResult &	slidingFitResult,
		ProtoHitVector &	protoHitVector
	)		const

private

Refine the 3D hit positions (and chi2) for a list of proto hits, in accordance with a provided 3D sliding fit trajectory.

Parameters

slidingFitResult	the 3D sliding fit result
protoHitVector	the proto hit vector, non const as proto hit properties will be updated

Definition at line 251 of file ThreeDHitCreationAlgorithm.cc.

 {
     const double sigmaUVW(LArGeometryHelper::GetSigmaUVW(this->GetPandora()));
     const double sigmaFit(sigmaUVW); // ATTN sigmaFit and sigmaHit here should agree with treatment in HitCreation tools
     const double sigmaHit(sigmaUVW);
     const double sigma3DFit(sigmaUVW * m_sigma3DFitMultiplier);
 
     for (ProtoHit &protoHit : protoHitVector)
     {
         CartesianVector pointOnFit(0.f, 0.f, 0.f);
         const double rL(slidingFitResult.GetLongitudinalDisplacement(protoHit.GetPosition3D()));
 
         if (STATUS_CODE_SUCCESS != slidingFitResult.GetGlobalFitPosition(rL, pointOnFit))
             continue;
 
         const CaloHit *const pCaloHit2D(protoHit.GetParentCaloHit2D());
         const HitType hitType(pCaloHit2D->GetHitType());
 
         const double uFit(PandoraContentApi::GetPlugins(*this)->GetLArTransformationPlugin()->YZtoU(pointOnFit.GetY(), pointOnFit.GetZ()));
         const double vFit(PandoraContentApi::GetPlugins(*this)->GetLArTransformationPlugin()->YZtoV(pointOnFit.GetY(), pointOnFit.GetZ()));
         const double wFit(PandoraContentApi::GetPlugins(*this)->GetLArTransformationPlugin()->YZtoW(pointOnFit.GetY(), pointOnFit.GetZ()));
 
         const double sigmaU((TPC_VIEW_U == hitType) ? sigmaHit : sigmaFit);
         const double sigmaV((TPC_VIEW_V == hitType) ? sigmaHit : sigmaFit);
         const double sigmaW((TPC_VIEW_W == hitType) ? sigmaHit : sigmaFit);
 
         CartesianVector position3D(0.f, 0.f, 0.f);
         double chi2(std::numeric_limits<double>::max());
         double u(std::numeric_limits<double>::max()), v(std::numeric_limits<double>::max()), w(std::numeric_limits<double>::max());
 
         if (protoHit.GetNTrajectorySamples() == 2)
         {
             u = (TPC_VIEW_U == hitType) ? pCaloHit2D->GetPositionVector().GetZ()
                                         : (TPC_VIEW_U == protoHit.GetFirstTrajectorySample().GetHitType())
                                               ? protoHit.GetFirstTrajectorySample().GetPosition().GetZ()
                                               : protoHit.GetLastTrajectorySample().GetPosition().GetZ();
             v = (TPC_VIEW_V == hitType) ? pCaloHit2D->GetPositionVector().GetZ()
                                         : (TPC_VIEW_V == protoHit.GetFirstTrajectorySample().GetHitType())
                                               ? protoHit.GetFirstTrajectorySample().GetPosition().GetZ()
                                               : protoHit.GetLastTrajectorySample().GetPosition().GetZ();
             w = (TPC_VIEW_W == hitType) ? pCaloHit2D->GetPositionVector().GetZ()
                                         : (TPC_VIEW_W == protoHit.GetFirstTrajectorySample().GetHitType())
                                               ? protoHit.GetFirstTrajectorySample().GetPosition().GetZ()
                                               : protoHit.GetLastTrajectorySample().GetPosition().GetZ();
         }
         else if (protoHit.GetNTrajectorySamples() == 1)
         {
             u = PandoraContentApi::GetPlugins(*this)->GetLArTransformationPlugin()->YZtoU(
                 protoHit.GetPosition3D().GetY(), protoHit.GetPosition3D().GetZ());
             v = PandoraContentApi::GetPlugins(*this)->GetLArTransformationPlugin()->YZtoV(
                 protoHit.GetPosition3D().GetY(), protoHit.GetPosition3D().GetZ());
             w = PandoraContentApi::GetPlugins(*this)->GetLArTransformationPlugin()->YZtoW(
                 protoHit.GetPosition3D().GetY(), protoHit.GetPosition3D().GetZ());
         }
         else
         {
             std::cout << "ThreeDHitCreationAlgorithm::IterativeTreatment - Unexpected number of trajectory samples" << std::endl;
             throw StatusCodeException(STATUS_CODE_FAILURE);
         }
 
         double bestY(std::numeric_limits<double>::max()), bestZ(std::numeric_limits<double>::max());
         PandoraContentApi::GetPlugins(*this)->GetLArTransformationPlugin()->GetMinChiSquaredYZ(
             u, v, w, sigmaU, sigmaV, sigmaW, uFit, vFit, wFit, sigma3DFit, bestY, bestZ, chi2);
         position3D.SetValues(pCaloHit2D->GetPositionVector().GetX(), static_cast<float>(bestY), static_cast<float>(bestZ));
 
         protoHit.SetPosition3D(position3D, chi2);
     }
 }

StatusCode lar_content::ThreeDHitCreationAlgorithm::Run ( )

private

Definition at line 50 of file ThreeDHitCreationAlgorithm.cc.

 {
     const PfoList *pPfoList(nullptr);
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_INITIALIZED, !=, PandoraContentApi::GetList(*this, m_inputPfoListName, pPfoList));
 
     if (!pPfoList || pPfoList->empty())
     {
         if (PandoraContentApi::GetSettings(*this)->ShouldDisplayAlgorithmInfo())
             std::cout << "ThreeDHitCreationAlgorithm: unable to find pfo list " << m_inputPfoListName << std::endl;
 
         return STATUS_CODE_SUCCESS;
     }
 
     CaloHitList allNewThreeDHits;
 
     PfoVector pfoVector(pPfoList->begin(), pPfoList->end());
     std::sort(pfoVector.begin(), pfoVector.end(), LArPfoHelper::SortByNHits);
 
     for (const ParticleFlowObject *const pPfo : pfoVector)
     {
         ProtoHitVector protoHitVector;
 
         for (HitCreationBaseTool *const pHitCreationTool : m_algorithmToolVector)
         {
             CaloHitVector remainingTwoDHits;
             this->SeparateTwoDHits(pPfo, protoHitVector, remainingTwoDHits);
 
             if (remainingTwoDHits.empty())
                 break;
 
             pHitCreationTool->Run(this, pPfo, remainingTwoDHits, protoHitVector);
         }
 
         if ((m_iterateTrackHits && LArPfoHelper::IsTrack(pPfo)) || (m_iterateShowerHits && LArPfoHelper::IsShower(pPfo)))
             this->IterativeTreatment(protoHitVector);
 
         if (protoHitVector.empty())
             continue;
 
         CaloHitList newThreeDHits;
         this->CreateThreeDHits(protoHitVector, newThreeDHits);
         this->AddThreeDHitsToPfo(pPfo, newThreeDHits);
 
         allNewThreeDHits.insert(allNewThreeDHits.end(), newThreeDHits.begin(), newThreeDHits.end());
     }
 
     if (!allNewThreeDHits.empty())
         PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::SaveList(*this, allNewThreeDHits, m_outputCaloHitListName));
 
     return STATUS_CODE_SUCCESS;
 }

void lar_content::ThreeDHitCreationAlgorithm::SeparateTwoDHits	(	const pandora::ParticleFlowObject *const	pPfo,
		const ProtoHitVector &	protoHitVector,
		pandora::CaloHitVector &	remainingHitVector
	)		const

private

Get the list of 2D calo hits in a pfo for which 3D hits have and have not been created.

Parameters

pPfo	the address of the pfo
protoHitVector	the vector of proto hits, describing current state of 3D hit construction
remainingHitVector	to receive the vector of 2D calo hits for which 3D hits have not been created

Definition at line 105 of file ThreeDHitCreationAlgorithm.cc.

 {
     ClusterList twoDClusterList;
     LArPfoHelper::GetTwoDClusterList(pPfo, twoDClusterList);
     CaloHitList remainingHitList;
 
     for (const Cluster *const pCluster : twoDClusterList)
     {
         if (TPC_3D == LArClusterHelper::GetClusterHitType(pCluster))
             throw StatusCodeException(STATUS_CODE_FAILURE);
 
         pCluster->GetOrderedCaloHitList().FillCaloHitList(remainingHitList);
     }
 
     CaloHitSet remainingHitSet(remainingHitList.begin(), remainingHitList.end());
 
     for (const ProtoHit &protoHit : protoHitVector)
     {
         CaloHitSet::iterator eraseIter = remainingHitSet.find(protoHit.GetParentCaloHit2D());
 
         if (remainingHitSet.end() == eraseIter)
             throw StatusCodeException(STATUS_CODE_FAILURE);
 
         remainingHitSet.erase(eraseIter);
     }
 
     remainingHitVector.insert(remainingHitVector.end(), remainingHitSet.begin(), remainingHitSet.end());
     std::sort(remainingHitVector.begin(), remainingHitVector.end(), LArClusterHelper::SortHitsByPosition);
 }