pandora_srcnav/_vertex_based_pfo_recovery_algorithm_8cc_source.html

#include "Pandora/AlgorithmHeaders.h"


#include "larpandoracontent/LArThreeDReco/LArPfoRecovery/VertexBasedPfoRecoveryAlgorithm.h"


#include "larpandoracontent/LArHelpers/LArClusterHelper.h"

#include "larpandoracontent/LArHelpers/LArGeometryHelper.h"

#include "larpandoracontent/LArHelpers/LArPointingClusterHelper.h"


using namespace pandora;


namespace lar_content

{


VertexBasedPfoRecoveryAlgorithm::VertexBasedPfoRecoveryAlgorithm() :

    m_slidingFitHalfWindow(10),

    m_maxLongitudinalDisplacement(5.f),

    m_maxTransverseDisplacement(2.f),

    m_twoViewChi2Cut(5.f),

    m_threeViewChi2Cut(5.f)

{

}


//------------------------------------------------------------------------------------------------------------------------------------------


StatusCode VertexBasedPfoRecoveryAlgorithm::Run()

{

    const VertexList *pVertexList = NULL;

    PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_INITIALIZED, !=, PandoraContentApi::GetCurrentList(*this, pVertexList));


    const Vertex *const pSelectedVertex(

        (pVertexList && (pVertexList->size() == 1) && (VERTEX_3D == (*(pVertexList->begin()))->GetVertexType())) ? *(pVertexList->begin()) : NULL);


    if (!pSelectedVertex)

    {

        if (PandoraContentApi::GetSettings(*this)->ShouldDisplayAlgorithmInfo())

            std::cout << "VertexBasedPfoRecoveryAlgorithm: unable to find vertex in current list " << std::endl;


        return STATUS_CODE_SUCCESS;

    }


    // Get the available clusters from each view

    ClusterVector availableClusters;

    PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->GetAvailableClusters(m_inputClusterListNames, availableClusters));


    // Build a set of sliding fit results

    TwoDSlidingFitResultMap slidingFitResultMap;

    this->BuildSlidingFitResultMap(availableClusters, slidingFitResultMap);


    // Select seed clusters (adjacent to vertex)

    ClusterVector selectedClusters;

    this->SelectVertexClusters(pSelectedVertex, slidingFitResultMap, availableClusters, selectedClusters);


    // Match the cluster end points

    ClusterSet vetoList;

    ParticleList particleList;

    this->MatchThreeViews(pSelectedVertex, slidingFitResultMap, selectedClusters, vetoList, particleList);

    this->MatchTwoViews(pSelectedVertex, slidingFitResultMap, selectedClusters, vetoList, particleList);


    // Build new particles

    this->BuildParticles(particleList);


    return STATUS_CODE_SUCCESS;

}


//------------------------------------------------------------------------------------------------------------------------------------------


StatusCode VertexBasedPfoRecoveryAlgorithm::GetAvailableClusters(const StringVector inputClusterListNames, ClusterVector &clusterVector) const

{

    for (StringVector::const_iterator iter = inputClusterListNames.begin(), iterEnd = inputClusterListNames.end(); iter != iterEnd; ++iter)

    {

        const ClusterList *pClusterList(NULL);

        PANDORA_THROW_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_INITIALIZED, !=, PandoraContentApi::GetList(*this, *iter, pClusterList));


        if (NULL == pClusterList)

        {

            if (PandoraContentApi::GetSettings(*this)->ShouldDisplayAlgorithmInfo())

                std::cout << "VertexBasedPfoRecoveryAlgorithm: could not find cluster list " << *iter << std::endl;

            continue;

        }


        for (ClusterList::const_iterator cIter = pClusterList->begin(), cIterEnd = pClusterList->end(); cIter != cIterEnd; ++cIter)

        {

            const Cluster *const pCluster = *cIter;


            if (!pCluster->IsAvailable())

                continue;


            if (pCluster->GetNCaloHits() <= 1)

                continue;


            if (TPC_3D == LArClusterHelper::GetClusterHitType(pCluster))

                continue;


            clusterVector.push_back(pCluster);

        }

    }


    std::sort(clusterVector.begin(), clusterVector.end(), LArClusterHelper::SortByNHits);


    return STATUS_CODE_SUCCESS;

}


//------------------------------------------------------------------------------------------------------------------------------------------


void VertexBasedPfoRecoveryAlgorithm::BuildSlidingFitResultMap(const ClusterVector &clusterVector, TwoDSlidingFitResultMap &slidingFitResultMap) const

{

    const float slidingFitPitch(LArGeometryHelper::GetWireZPitch(this->GetPandora()));


    for (ClusterVector::const_iterator iter = clusterVector.begin(), iterEnd = clusterVector.end(); iter != iterEnd; ++iter)

    {

        if (slidingFitResultMap.end() == slidingFitResultMap.find(*iter))

        {

            try

            {

                const TwoDSlidingFitResult slidingFitResult(*iter, m_slidingFitHalfWindow, slidingFitPitch);

                const LArPointingCluster pointingCluster(slidingFitResult);


                if (pointingCluster.GetLengthSquared() < std::numeric_limits<float>::epsilon())

                    continue;


                if (!slidingFitResultMap.insert(TwoDSlidingFitResultMap::value_type(*iter, slidingFitResult)).second)

                    throw StatusCodeException(STATUS_CODE_FAILURE);

            }

            catch (StatusCodeException &statusCodeException)

            {

                if (STATUS_CODE_FAILURE == statusCodeException.GetStatusCode())

                    throw statusCodeException;

            }

        }

    }

}


//------------------------------------------------------------------------------------------------------------------------------------------


void VertexBasedPfoRecoveryAlgorithm::SelectVertexClusters(const Vertex *const pVertex, const TwoDSlidingFitResultMap &slidingFitResultMap,

    const ClusterVector &inputClusters, ClusterVector &outputClusters) const

{

    const CartesianVector vertexU(LArGeometryHelper::ProjectPosition(this->GetPandora(), pVertex->GetPosition(), TPC_VIEW_U));

    const CartesianVector vertexV(LArGeometryHelper::ProjectPosition(this->GetPandora(), pVertex->GetPosition(), TPC_VIEW_V));

    const CartesianVector vertexW(LArGeometryHelper::ProjectPosition(this->GetPandora(), pVertex->GetPosition(), TPC_VIEW_W));


    for (ClusterVector::const_iterator cIter = inputClusters.begin(), cIterEnd = inputClusters.end(); cIter != cIterEnd; ++cIter)

    {

        const Cluster *const pCluster = *cIter;

        const HitType hitType(LArClusterHelper::GetClusterHitType(pCluster));


        if (TPC_3D == hitType)

            continue;


        const CartesianVector vertexPosition((TPC_VIEW_U == hitType) ? vertexU : (TPC_VIEW_V == hitType) ? vertexV : vertexW);


        TwoDSlidingFitResultMap::const_iterator sIter = slidingFitResultMap.find(pCluster);

        if (slidingFitResultMap.end() == sIter)

            continue;


        const TwoDSlidingFitResult &slidingFitResult = sIter->second;

        const LArPointingCluster pointingCluster(slidingFitResult);


        for (unsigned int iVtx = 0; iVtx < 2; ++iVtx)

        {

            const LArPointingCluster::Vertex &pointingVertex((0 == iVtx) ? pointingCluster.GetInnerVertex() : pointingCluster.GetOuterVertex());


            float rL(0.f), rT(0.f);

            LArPointingClusterHelper::GetImpactParameters(pointingVertex, vertexPosition, rL, rT);


            if (rL > -1.f && rL < m_maxLongitudinalDisplacement && rT < m_maxTransverseDisplacement)

            {

                outputClusters.push_back(pCluster);

                break;

            }

        }

    }

}


//------------------------------------------------------------------------------------------------------------------------------------------


void VertexBasedPfoRecoveryAlgorithm::MatchThreeViews(const Vertex *const pVertex, const TwoDSlidingFitResultMap &slidingFitResultMap,

    const ClusterVector &inputClusters, ClusterSet &vetoList, ParticleList &particleList) const

{

    while (true)

    {

        ClusterVector availableClusters, clustersU, clustersV, clustersW;

        this->SelectAvailableClusters(vetoList, inputClusters, availableClusters);

        this->SelectClusters(TPC_VIEW_U, availableClusters, clustersU);

        this->SelectClusters(TPC_VIEW_V, availableClusters, clustersV);

        this->SelectClusters(TPC_VIEW_W, availableClusters, clustersW);


        float chi2(m_threeViewChi2Cut);

        const Cluster *pCluster1(NULL);

        const Cluster *pCluster2(NULL);

        const Cluster *pCluster3(NULL);


        this->GetBestChi2(pVertex, slidingFitResultMap, clustersU, clustersV, clustersW, pCluster1, pCluster2, pCluster3, chi2);


        if (NULL == pCluster1 || NULL == pCluster2 || NULL == pCluster3)

            return;


        const HitType hitType1(LArClusterHelper::GetClusterHitType(pCluster1));

        const HitType hitType2(LArClusterHelper::GetClusterHitType(pCluster2));

        const HitType hitType3(LArClusterHelper::GetClusterHitType(pCluster3));


        const Cluster *const pClusterU(

            (TPC_VIEW_U == hitType1) ? pCluster1 : (TPC_VIEW_U == hitType2) ? pCluster2 : (TPC_VIEW_U == hitType3) ? pCluster3 : NULL);

        const Cluster *const pClusterV(

            (TPC_VIEW_V == hitType1) ? pCluster1 : (TPC_VIEW_V == hitType2) ? pCluster2 : (TPC_VIEW_V == hitType3) ? pCluster3 : NULL);

        const Cluster *const pClusterW(

            (TPC_VIEW_W == hitType1) ? pCluster1 : (TPC_VIEW_W == hitType2) ? pCluster2 : (TPC_VIEW_W == hitType3) ? pCluster3 : NULL);


        particleList.push_back(Particle(pClusterU, pClusterV, pClusterW));


        vetoList.insert(pCluster1);

        vetoList.insert(pCluster2);

        vetoList.insert(pCluster3);

    }

}


//------------------------------------------------------------------------------------------------------------------------------------------


void VertexBasedPfoRecoveryAlgorithm::MatchTwoViews(const Vertex *const pVertex, const TwoDSlidingFitResultMap &slidingFitResultMap,

    const ClusterVector &inputClusters, ClusterSet &vetoList, ParticleList &particleList) const

{

    while (true)

    {

        ClusterVector availableClusters, clustersU, clustersV, clustersW;

        this->SelectAvailableClusters(vetoList, inputClusters, availableClusters);

        this->SelectClusters(TPC_VIEW_U, availableClusters, clustersU);

        this->SelectClusters(TPC_VIEW_V, availableClusters, clustersV);

        this->SelectClusters(TPC_VIEW_W, availableClusters, clustersW);


        float chi2(m_twoViewChi2Cut);

        const Cluster *pCluster1(NULL);

        const Cluster *pCluster2(NULL);


        this->GetBestChi2(pVertex, slidingFitResultMap, clustersU, clustersV, pCluster1, pCluster2, chi2);

        this->GetBestChi2(pVertex, slidingFitResultMap, clustersV, clustersW, pCluster1, pCluster2, chi2);

        this->GetBestChi2(pVertex, slidingFitResultMap, clustersW, clustersU, pCluster1, pCluster2, chi2);


        if (NULL == pCluster1 || NULL == pCluster2)

            return;


        const HitType hitType1(LArClusterHelper::GetClusterHitType(pCluster1));

        const HitType hitType2(LArClusterHelper::GetClusterHitType(pCluster2));


        const Cluster *const pClusterU((TPC_VIEW_U == hitType1) ? pCluster1 : (TPC_VIEW_U == hitType2) ? pCluster2 : NULL);

        const Cluster *const pClusterV((TPC_VIEW_V == hitType1) ? pCluster1 : (TPC_VIEW_V == hitType2) ? pCluster2 : NULL);

        const Cluster *const pClusterW((TPC_VIEW_W == hitType1) ? pCluster1 : (TPC_VIEW_W == hitType2) ? pCluster2 : NULL);


        particleList.push_back(Particle(pClusterU, pClusterV, pClusterW));


        vetoList.insert(pCluster1);

        vetoList.insert(pCluster2);

    }

}


//------------------------------------------------------------------------------------------------------------------------------------------


void VertexBasedPfoRecoveryAlgorithm::GetBestChi2(const Vertex *const pVertex, const TwoDSlidingFitResultMap &slidingFitResultMap,

    const ClusterVector &clusters1, const ClusterVector &clusters2, const ClusterVector &clusters3, const Cluster *&pBestCluster1,

    const Cluster *&pBestCluster2, const Cluster *&pBestCluster3, float &bestChi2) const

{

    if (clusters1.empty() || clusters2.empty() || clusters3.empty())

        return;


    // First loop

    for (ClusterVector::const_iterator cIter1 = clusters1.begin(), cIterEnd1 = clusters1.end(); cIter1 != cIterEnd1; ++cIter1)

    {

        const Cluster *const pCluster1 = *cIter1;


        TwoDSlidingFitResultMap::const_iterator sIter1 = slidingFitResultMap.find(pCluster1);

        if (slidingFitResultMap.end() == sIter1)

            continue;


        const TwoDSlidingFitResult &slidingFitResult1 = sIter1->second;

        const LArPointingCluster pointingCluster1(slidingFitResult1);


        // Second loop

        for (ClusterVector::const_iterator cIter2 = clusters2.begin(), cIterEnd2 = clusters2.end(); cIter2 != cIterEnd2; ++cIter2)

        {

            const Cluster *const pCluster2 = *cIter2;


            TwoDSlidingFitResultMap::const_iterator sIter2 = slidingFitResultMap.find(pCluster2);

            if (slidingFitResultMap.end() == sIter2)

                continue;


            const TwoDSlidingFitResult &slidingFitResult2 = sIter2->second;

            const LArPointingCluster pointingCluster2(slidingFitResult2);


            // Third loop

            for (ClusterVector::const_iterator cIter3 = clusters3.begin(), cIterEnd3 = clusters3.end(); cIter3 != cIterEnd3; ++cIter3)

            {

                const Cluster *const pCluster3 = *cIter3;


                TwoDSlidingFitResultMap::const_iterator sIter3 = slidingFitResultMap.find(pCluster3);

                if (slidingFitResultMap.end() == sIter3)

                    continue;


                const TwoDSlidingFitResult &slidingFitResult3 = sIter3->second;

                const LArPointingCluster pointingCluster3(slidingFitResult3);


                // Calculate chi-squared

                const float thisChi2(this->GetChi2(pVertex, pointingCluster1, pointingCluster2, pointingCluster3));


                if (thisChi2 < bestChi2)

                {

                    bestChi2 = thisChi2;

                    pBestCluster1 = pCluster1;

                    pBestCluster2 = pCluster2;

                    pBestCluster3 = pCluster3;

                }

            }

        }

    }

}


//------------------------------------------------------------------------------------------------------------------------------------------


void VertexBasedPfoRecoveryAlgorithm::GetBestChi2(const Vertex *const pVertex, const TwoDSlidingFitResultMap &slidingFitResultMap,

    const ClusterVector &clusters1, const ClusterVector &clusters2, const Cluster *&pBestCluster1, const Cluster *&pBestCluster2, float &bestChi2) const

{

    if (clusters1.empty() || clusters2.empty())

        return;


    // First loop

    for (ClusterVector::const_iterator cIter1 = clusters1.begin(), cIterEnd1 = clusters1.end(); cIter1 != cIterEnd1; ++cIter1)

    {

        const Cluster *const pCluster1 = *cIter1;


        TwoDSlidingFitResultMap::const_iterator sIter1 = slidingFitResultMap.find(pCluster1);

        if (slidingFitResultMap.end() == sIter1)

            continue;


        const TwoDSlidingFitResult &slidingFitResult1 = sIter1->second;

        const LArPointingCluster pointingCluster1(slidingFitResult1);


        // Second loop

        for (ClusterVector::const_iterator cIter2 = clusters2.begin(), cIterEnd2 = clusters2.end(); cIter2 != cIterEnd2; ++cIter2)

        {

            const Cluster *const pCluster2 = *cIter2;


            TwoDSlidingFitResultMap::const_iterator sIter2 = slidingFitResultMap.find(pCluster2);

            if (slidingFitResultMap.end() == sIter2)

                continue;


            const TwoDSlidingFitResult &slidingFitResult2 = sIter2->second;

            const LArPointingCluster pointingCluster2(slidingFitResult2);


            // Calculate chi-squared

            const float thisChi2(this->GetChi2(pVertex, pointingCluster1, pointingCluster2));


            if (thisChi2 < bestChi2)

            {

                bestChi2 = thisChi2;

                pBestCluster1 = pCluster1;

                pBestCluster2 = pCluster2;

            }

        }

    }

}


//------------------------------------------------------------------------------------------------------------------------------------------


float VertexBasedPfoRecoveryAlgorithm::GetChi2(

    const Vertex *const pVertex, const LArPointingCluster &pointingCluster1, const LArPointingCluster &pointingCluster2) const

{

    const HitType hitType1(LArClusterHelper::GetClusterHitType(pointingCluster1.GetCluster()));

    const HitType hitType2(LArClusterHelper::GetClusterHitType(pointingCluster2.GetCluster()));


    if (hitType1 == hitType2)

        throw StatusCodeException(STATUS_CODE_FAILURE);


    const CartesianVector vertex1(LArGeometryHelper::ProjectPosition(this->GetPandora(), pVertex->GetPosition(), hitType1));

    const CartesianVector vertex2(LArGeometryHelper::ProjectPosition(this->GetPandora(), pVertex->GetPosition(), hitType2));


    const LArPointingCluster::Vertex &pointingVertex1(this->GetOuterVertex(vertex1, pointingCluster1));

    const LArPointingCluster::Vertex &pointingVertex2(this->GetOuterVertex(vertex2, pointingCluster2));


    float chi2(0.f);

    CartesianVector mergedPosition(0.f, 0.f, 0.f);

    LArGeometryHelper::MergeTwoPositions3D(

        this->GetPandora(), hitType1, hitType2, pointingVertex1.GetPosition(), pointingVertex2.GetPosition(), mergedPosition, chi2);


    return chi2;

}


//------------------------------------------------------------------------------------------------------------------------------------------


float VertexBasedPfoRecoveryAlgorithm::GetChi2(const Vertex *const pVertex, const LArPointingCluster &pointingCluster1,

    const LArPointingCluster &pointingCluster2, const LArPointingCluster &pointingCluster3) const

{

    const HitType hitType1(LArClusterHelper::GetClusterHitType(pointingCluster1.GetCluster()));

    const HitType hitType2(LArClusterHelper::GetClusterHitType(pointingCluster2.GetCluster()));

    const HitType hitType3(LArClusterHelper::GetClusterHitType(pointingCluster3.GetCluster()));


    if ((hitType1 == hitType2) || (hitType2 == hitType3) || (hitType3 == hitType1))

        throw StatusCodeException(STATUS_CODE_FAILURE);


    const CartesianVector vertex1(LArGeometryHelper::ProjectPosition(this->GetPandora(), pVertex->GetPosition(), hitType1));

    const CartesianVector vertex2(LArGeometryHelper::ProjectPosition(this->GetPandora(), pVertex->GetPosition(), hitType2));

    const CartesianVector vertex3(LArGeometryHelper::ProjectPosition(this->GetPandora(), pVertex->GetPosition(), hitType3));


    const LArPointingCluster::Vertex &pointingVertex1(this->GetOuterVertex(vertex1, pointingCluster1));

    const LArPointingCluster::Vertex &pointingVertex2(this->GetOuterVertex(vertex2, pointingCluster2));

    const LArPointingCluster::Vertex &pointingVertex3(this->GetOuterVertex(vertex3, pointingCluster3));


    float chi2(0.f);

    CartesianVector mergedPosition(0.f, 0.f, 0.f);

    LArGeometryHelper::MergeThreePositions3D(this->GetPandora(), hitType1, hitType2, hitType3, pointingVertex1.GetPosition(),

        pointingVertex2.GetPosition(), pointingVertex3.GetPosition(), mergedPosition, chi2);


    return chi2;

}


//------------------------------------------------------------------------------------------------------------------------------------------


void VertexBasedPfoRecoveryAlgorithm::SelectAvailableClusters(const ClusterSet &vetoList, const ClusterVector &inputVector, ClusterVector &outputVector) const

{

    for (ClusterVector::const_iterator iter = inputVector.begin(), iterEnd = inputVector.end(); iter != iterEnd; ++iter)

    {

        if (0 == vetoList.count(*iter))

            outputVector.push_back(*iter);

    }

}


//------------------------------------------------------------------------------------------------------------------------------------------


void VertexBasedPfoRecoveryAlgorithm::SelectClusters(const HitType hitType, const ClusterVector &inputVector, ClusterVector &outputVector) const

{

    for (ClusterVector::const_iterator iter = inputVector.begin(), iterEnd = inputVector.end(); iter != iterEnd; ++iter)

    {

        if (hitType == LArClusterHelper::GetClusterHitType(*iter))

            outputVector.push_back(*iter);

    }

}


//------------------------------------------------------------------------------------------------------------------------------------------


const LArPointingCluster::Vertex &VertexBasedPfoRecoveryAlgorithm::GetInnerVertex(const CartesianVector &vertex, const LArPointingCluster &cluster) const

{

    const float innerDistance((vertex - cluster.GetInnerVertex().GetPosition()).GetMagnitudeSquared());

    const float outerDistance((vertex - cluster.GetOuterVertex().GetPosition()).GetMagnitudeSquared());


    if (innerDistance < outerDistance)

        return cluster.GetInnerVertex();

    else

        return cluster.GetOuterVertex();

}


//------------------------------------------------------------------------------------------------------------------------------------------


const LArPointingCluster::Vertex &VertexBasedPfoRecoveryAlgorithm::GetOuterVertex(const CartesianVector &vertex, const LArPointingCluster &cluster) const

{

    const LArPointingCluster::Vertex &innerVertex = this->GetInnerVertex(vertex, cluster);


    if (innerVertex.IsInnerVertex())

        return cluster.GetOuterVertex();

    else

        return cluster.GetInnerVertex();

}


//------------------------------------------------------------------------------------------------------------------------------------------


void VertexBasedPfoRecoveryAlgorithm::BuildParticles(const ParticleList &particleList)

{

    if (particleList.empty())

        return;


    const PfoList *pPfoList = NULL;

    std::string pfoListName;

    PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::CreateTemporaryListAndSetCurrent(*this, pPfoList, pfoListName));


    for (ParticleList::const_iterator iter = particleList.begin(), iterEnd = particleList.end(); iter != iterEnd; ++iter)

    {

        const Particle &particle = *iter;


        ClusterList clusterList;

        const Cluster *const pClusterU = particle.m_pClusterU;

        const Cluster *const pClusterV = particle.m_pClusterV;

        const Cluster *const pClusterW = particle.m_pClusterW;


        const bool isAvailableU((NULL != pClusterU) ? pClusterU->IsAvailable() : true);

        const bool isAvailableV((NULL != pClusterV) ? pClusterV->IsAvailable() : true);

        const bool isAvailableW((NULL != pClusterW) ? pClusterW->IsAvailable() : true);


        if (!(isAvailableU && isAvailableV && isAvailableW))

            throw StatusCodeException(STATUS_CODE_FAILURE);


        if (pClusterU)

            clusterList.push_back(pClusterU);

        if (pClusterV)

            clusterList.push_back(pClusterV);

        if (pClusterW)

            clusterList.push_back(pClusterW);


        // TODO Correct these placeholder parameters

        PandoraContentApi::ParticleFlowObject::Parameters pfoParameters;

        pfoParameters.m_particleId = MU_MINUS; // TRACK

        pfoParameters.m_charge = PdgTable::GetParticleCharge(pfoParameters.m_particleId.Get());

        pfoParameters.m_mass = PdgTable::GetParticleMass(pfoParameters.m_particleId.Get());

        pfoParameters.m_energy = 0.f;

        pfoParameters.m_momentum = CartesianVector(0.f, 0.f, 0.f);

        pfoParameters.m_clusterList = clusterList;


        const ParticleFlowObject *pPfo(NULL);

        PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::ParticleFlowObject::Create(*this, pfoParameters, pPfo));

    }


    if (!pPfoList->empty())

        PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::SaveList<Pfo>(*this, m_outputPfoListName));

}


//------------------------------------------------------------------------------------------------------------------------------------------


VertexBasedPfoRecoveryAlgorithm::Particle::Particle(const Cluster *const pClusterU, const Cluster *const pClusterV, const Cluster *const pClusterW) :

    m_pClusterU(pClusterU),

    m_pClusterV(pClusterV),

    m_pClusterW(pClusterW)

{

    if (NULL == m_pClusterU && NULL == m_pClusterV && NULL == m_pClusterW)

        throw StatusCodeException(STATUS_CODE_FAILURE);


    const HitType hitTypeU(NULL == m_pClusterU ? TPC_VIEW_U : LArClusterHelper::GetClusterHitType(m_pClusterU));

    const HitType hitTypeV(NULL == m_pClusterV ? TPC_VIEW_V : LArClusterHelper::GetClusterHitType(m_pClusterV));

    const HitType hitTypeW(NULL == m_pClusterW ? TPC_VIEW_W : LArClusterHelper::GetClusterHitType(m_pClusterW));


    if (!(TPC_VIEW_U == hitTypeU && TPC_VIEW_V == hitTypeV && TPC_VIEW_W == hitTypeW))

        throw StatusCodeException(STATUS_CODE_FAILURE);

}


//------------------------------------------------------------------------------------------------------------------------------------------


StatusCode VertexBasedPfoRecoveryAlgorithm::ReadSettings(const TiXmlHandle xmlHandle)

{

    PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadVectorOfValues(xmlHandle, "InputClusterListNames", m_inputClusterListNames));


    PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "OutputPfoListName", m_outputPfoListName));


    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, "MaxLongitudinalDisplacement", m_maxLongitudinalDisplacement));


    PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,

        XmlHelper::ReadValue(xmlHandle, "MaxTransverseDisplacement", m_maxTransverseDisplacement));


    PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "TwoViewChi2Cut", m_twoViewChi2Cut));


    PANDORA_RETURN_RESULT_IF_AND_IF(

        STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "ThreeViewChi2Cut", m_threeViewChi2Cut));


    return STATUS_CODE_SUCCESS;

}


} // namespace lar_content

AlgorithmHeaders.h
Grouping of header files for many classes of use in particle flow algorithms.

LArClusterHelper.h
Header file for the cluster helper class.

LArGeometryHelper.h
Header file for the geometry helper class.

LArPointingClusterHelper.h

PANDORA_THROW_RESULT_IF_AND_IF
#define PANDORA_THROW_RESULT_IF_AND_IF(StatusCode1, StatusCode2, Operator, Command)
Definition StatusCodes.h:55

PANDORA_THROW_RESULT_IF
#define PANDORA_THROW_RESULT_IF(StatusCode1, Operator, Command)
Definition StatusCodes.h:43

PANDORA_RETURN_RESULT_IF_AND_IF
#define PANDORA_RETURN_RESULT_IF_AND_IF(StatusCode1, StatusCode2, Operator, Command)
Definition StatusCodes.h:31

PANDORA_RETURN_RESULT_IF
#define PANDORA_RETURN_RESULT_IF(StatusCode1, Operator, Command)
Definition StatusCodes.h:19

VertexBasedPfoRecoveryAlgorithm.h
Header file for the vertex-based particle recovery algorithm.

PandoraContentApi::ReplaceCurrentList
static pandora::StatusCode ReplaceCurrentList(const pandora::Algorithm &algorithm, const std::string &newListName)
Replace the current list with a pre-saved list; use this new list as a permanent replacement for the ...
Definition PandoraContentApi.cc:100

PandoraContentApi::CreateTemporaryListAndSetCurrent
static pandora::StatusCode CreateTemporaryListAndSetCurrent(const pandora::Algorithm &algorithm, const T *&pT, std::string &temporaryListName)
Create a temporary list and set it to be the current list, enabling object creation.
Definition PandoraContentApi.cc:182

PandoraContentApi::GetCurrentList
static pandora::StatusCode GetCurrentList(const pandora::Algorithm &algorithm, const T *&pT)
Get the current list.
Definition PandoraContentApi.cc:75

PandoraContentApi::GetList
static pandora::StatusCode GetList(const pandora::Algorithm &algorithm, const std::string &listName, const T *&pT)
Get a named list.
Definition PandoraContentApi.cc:116

PandoraContentApi::GetSettings
static const pandora::PandoraSettings * GetSettings(const pandora::Algorithm &algorithm)
Get the pandora settings instance.
Definition PandoraContentApi.cc:15

lar_content::LArClusterHelper::GetClusterHitType
static pandora::HitType GetClusterHitType(const pandora::Cluster *const pCluster)
Get the hit type associated with a two dimensional cluster.
Definition LArClusterHelper.cc:21

lar_content::LArClusterHelper::SortByNHits
static bool SortByNHits(const pandora::Cluster *const pLhs, const pandora::Cluster *const pRhs)
Sort clusters by number of hits, then layer span, then inner layer, then position,...
Definition LArClusterHelper.cc:656

lar_content::LArGeometryHelper::GetWireZPitch
static float GetWireZPitch(const pandora::Pandora &pandora, const float maxWirePitchDiscrepancy=0.01)
Return the wire pitch.
Definition LArGeometryHelper.h:273

lar_content::LArGeometryHelper::ProjectPosition
static pandora::CartesianVector ProjectPosition(const pandora::Pandora &pandora, const pandora::CartesianVector &position3D, const pandora::HitType view)
Project 3D position into a given 2D view.
Definition LArGeometryHelper.cc:323

lar_content::LArGeometryHelper::MergeTwoPositions3D
static void MergeTwoPositions3D(const pandora::Pandora &pandora, const pandora::HitType view1, const pandora::HitType view2, const pandora::CartesianVector &position1, const pandora::CartesianVector &position2, pandora::CartesianVector &position3D, float &chiSquared)
Merge 2D positions from two views to give unified 3D position.
Definition LArGeometryHelper.cc:299

lar_content::LArGeometryHelper::MergeThreePositions3D
static void MergeThreePositions3D(const pandora::Pandora &pandora, const pandora::HitType view1, const pandora::HitType view2, const pandora::HitType view3, const pandora::CartesianVector &position1, const pandora::CartesianVector &position2, const pandora::CartesianVector &position3, pandora::CartesianVector &position3D, float &chiSquared)
Merge 2D positions from three views to give unified 3D position.
Definition LArGeometryHelper.cc:311

lar_content::LArPointingCluster::Vertex
Vertex class.
Definition LArPointingCluster.h:27

lar_content::LArPointingCluster::Vertex::GetPosition
const pandora::CartesianVector & GetPosition() const
Get the vertex position.
Definition LArPointingCluster.h:247

lar_content::LArPointingCluster::Vertex::IsInnerVertex
bool IsInnerVertex() const
Is this the inner vertex.
Definition LArPointingCluster.h:277

lar_content::LArPointingClusterHelper::GetImpactParameters
static void GetImpactParameters(const LArPointingCluster::Vertex &pointingVertex, const LArPointingCluster::Vertex &targetVertex, float &longitudinal, float &transverse)
Calculate impact parameters between a pair of pointing vertices.
Definition LArPointingClusterHelper.cc:199

lar_content::LArPointingCluster
LArPointingCluster class.
Definition LArPointingCluster.h:21

lar_content::LArPointingCluster::GetInnerVertex
const Vertex & GetInnerVertex() const
Get the inner vertex.
Definition LArPointingCluster.h:208

lar_content::LArPointingCluster::GetCluster
const pandora::Cluster * GetCluster() const
Get the address of the cluster.
Definition LArPointingCluster.h:201

lar_content::LArPointingCluster::GetOuterVertex
const Vertex & GetOuterVertex() const
Get the outer vertex.
Definition LArPointingCluster.h:215

lar_content::LArPointingCluster::GetLengthSquared
float GetLengthSquared() const
Get length squared of pointing cluster.
Definition LArPointingCluster.h:222

lar_content::TwoDSlidingFitResult
TwoDSlidingFitResult class.
Definition LArTwoDSlidingFitResult.h:24

lar_content::VertexBasedPfoRecoveryAlgorithm::Particle
Particle class.
Definition VertexBasedPfoRecoveryAlgorithm.h:37

lar_content::VertexBasedPfoRecoveryAlgorithm::Particle::m_pClusterV
const pandora::Cluster * m_pClusterV
Address of cluster in V view.
Definition VertexBasedPfoRecoveryAlgorithm.h:49

lar_content::VertexBasedPfoRecoveryAlgorithm::Particle::m_pClusterU
const pandora::Cluster * m_pClusterU
Address of cluster in U view.
Definition VertexBasedPfoRecoveryAlgorithm.h:48

lar_content::VertexBasedPfoRecoveryAlgorithm::Particle::Particle
Particle(const pandora::Cluster *const pClusterU, const pandora::Cluster *const pClusterV, const pandora::Cluster *const pClusterW)
Constructor.
Definition VertexBasedPfoRecoveryAlgorithm.cc:520

lar_content::VertexBasedPfoRecoveryAlgorithm::Particle::m_pClusterW
const pandora::Cluster * m_pClusterW
Address of cluster in W view.
Definition VertexBasedPfoRecoveryAlgorithm.h:50

lar_content::VertexBasedPfoRecoveryAlgorithm::ParticleList
std::vector< Particle > ParticleList
Definition VertexBasedPfoRecoveryAlgorithm.h:53

lar_content::VertexBasedPfoRecoveryAlgorithm::MatchThreeViews
void MatchThreeViews(const pandora::Vertex *const pVertex, const TwoDSlidingFitResultMap &slidingFitResultMap, const pandora::ClusterVector &selectedClusters, pandora::ClusterSet &vetoList, ParticleList &particleList) const
Match clusters from three views.
Definition VertexBasedPfoRecoveryAlgorithm.cc:184

lar_content::VertexBasedPfoRecoveryAlgorithm::m_twoViewChi2Cut
float m_twoViewChi2Cut
Definition VertexBasedPfoRecoveryAlgorithm.h:207

lar_content::VertexBasedPfoRecoveryAlgorithm::SelectAvailableClusters
void SelectAvailableClusters(const pandora::ClusterSet &vetoList, const pandora::ClusterVector &inputVector, pandora::ClusterVector &outputVector) const
Select cluster which haven't been vetoed.
Definition VertexBasedPfoRecoveryAlgorithm.cc:422

lar_content::VertexBasedPfoRecoveryAlgorithm::GetInnerVertex
const LArPointingCluster::Vertex & GetInnerVertex(const pandora::CartesianVector &vertex, const LArPointingCluster &cluster) const
Find nearest end of pointing cluster to a specified position vector.
Definition VertexBasedPfoRecoveryAlgorithm.cc:444

lar_content::VertexBasedPfoRecoveryAlgorithm::GetOuterVertex
const LArPointingCluster::Vertex & GetOuterVertex(const pandora::CartesianVector &vertex, const LArPointingCluster &cluster) const
Find furthest end of pointing cluster from a specified position vector.
Definition VertexBasedPfoRecoveryAlgorithm.cc:457

lar_content::VertexBasedPfoRecoveryAlgorithm::SelectVertexClusters
void SelectVertexClusters(const pandora::Vertex *const pVertex, const TwoDSlidingFitResultMap &slidingFitResultMap, const pandora::ClusterVector &inputClusters, pandora::ClusterVector &outputClusters) const
Select clusters in proximity to reconstructed vertex.
Definition VertexBasedPfoRecoveryAlgorithm.cc:142

lar_content::VertexBasedPfoRecoveryAlgorithm::m_maxLongitudinalDisplacement
float m_maxLongitudinalDisplacement
Definition VertexBasedPfoRecoveryAlgorithm.h:205

lar_content::VertexBasedPfoRecoveryAlgorithm::m_outputPfoListName
std::string m_outputPfoListName
The name of the output pfo list.
Definition VertexBasedPfoRecoveryAlgorithm.h:202

lar_content::VertexBasedPfoRecoveryAlgorithm::BuildSlidingFitResultMap
void BuildSlidingFitResultMap(const pandora::ClusterVector &clusterVector, TwoDSlidingFitResultMap &slidingFitResultMap) const
Build the map of sliding fit results.
Definition VertexBasedPfoRecoveryAlgorithm.cc:112

lar_content::VertexBasedPfoRecoveryAlgorithm::MatchTwoViews
void MatchTwoViews(const pandora::Vertex *const pVertex, const TwoDSlidingFitResultMap &slidingFitResultMap, const pandora::ClusterVector &selectedClusters, pandora::ClusterSet &vetoList, ParticleList &particleList) const
Match clusters from two views.
Definition VertexBasedPfoRecoveryAlgorithm.cc:226

lar_content::VertexBasedPfoRecoveryAlgorithm::Run
pandora::StatusCode Run()
Run the algorithm.
Definition VertexBasedPfoRecoveryAlgorithm.cc:33

lar_content::VertexBasedPfoRecoveryAlgorithm::GetBestChi2
void GetBestChi2(const pandora::Vertex *const pVertex, const TwoDSlidingFitResultMap &slidingFitResultMap, const pandora::ClusterVector &clusters1, const pandora::ClusterVector &clusters2, const pandora::ClusterVector &clusters3, const pandora::Cluster *&pBestCluster1, const pandora::Cluster *&pBestCluster2, const pandora::Cluster *&pBestCluster3, float &chi2) const
Get best-matched triplet of clusters from a set of input cluster vectors.
Definition VertexBasedPfoRecoveryAlgorithm.cc:264

lar_content::VertexBasedPfoRecoveryAlgorithm::m_threeViewChi2Cut
float m_threeViewChi2Cut
Definition VertexBasedPfoRecoveryAlgorithm.h:208

lar_content::VertexBasedPfoRecoveryAlgorithm::VertexBasedPfoRecoveryAlgorithm
VertexBasedPfoRecoveryAlgorithm()
Default constructor.
Definition VertexBasedPfoRecoveryAlgorithm.cc:22

lar_content::VertexBasedPfoRecoveryAlgorithm::GetChi2
float GetChi2(const pandora::Vertex *const pVertex, const LArPointingCluster &pointingCluster1, const LArPointingCluster &pointingCluster2) const
Merge two pointing clusters and return chi-squared metric giving consistency of matching.
Definition VertexBasedPfoRecoveryAlgorithm.cc:369

lar_content::VertexBasedPfoRecoveryAlgorithm::m_maxTransverseDisplacement
float m_maxTransverseDisplacement
Definition VertexBasedPfoRecoveryAlgorithm.h:206

lar_content::VertexBasedPfoRecoveryAlgorithm::ReadSettings
pandora::StatusCode ReadSettings(const pandora::TiXmlHandle xmlHandle)
Read the algorithm settings.
Definition VertexBasedPfoRecoveryAlgorithm.cc:538

lar_content::VertexBasedPfoRecoveryAlgorithm::GetAvailableClusters
pandora::StatusCode GetAvailableClusters(const pandora::StringVector inputClusterListName, pandora::ClusterVector &clusterVector) const
Get a vector of available clusters.
Definition VertexBasedPfoRecoveryAlgorithm.cc:75

lar_content::VertexBasedPfoRecoveryAlgorithm::SelectClusters
void SelectClusters(const pandora::HitType hitType, const pandora::ClusterVector &inputVector, pandora::ClusterVector &outputVector) const
Select clusters of a specified hit type.
Definition VertexBasedPfoRecoveryAlgorithm.cc:433

lar_content::VertexBasedPfoRecoveryAlgorithm::m_inputClusterListNames
pandora::StringVector m_inputClusterListNames
The list of input cluster list names.
Definition VertexBasedPfoRecoveryAlgorithm.h:201

lar_content::VertexBasedPfoRecoveryAlgorithm::m_slidingFitHalfWindow
unsigned int m_slidingFitHalfWindow
Definition VertexBasedPfoRecoveryAlgorithm.h:204

lar_content::VertexBasedPfoRecoveryAlgorithm::BuildParticles
void BuildParticles(const ParticleList &particleList)
Build particle flow objects from matched clusters.
Definition VertexBasedPfoRecoveryAlgorithm.cc:469

pandora::CartesianVector
CartesianVector class.
Definition CartesianVector.h:24

pandora::Cluster
Cluster class.
Definition Cluster.h:31

pandora::Cluster::IsAvailable
bool IsAvailable() const
Whether the cluster is available to be added to a particle flow object.
Definition Cluster.h:582

pandora::Cluster::GetNCaloHits
unsigned int GetNCaloHits() const
Get the number of calo hits in the cluster.
Definition Cluster.h:484

pandora::PandoraSettings::ShouldDisplayAlgorithmInfo
bool ShouldDisplayAlgorithmInfo() const
Whether to display algorithm information during processing.
Definition PandoraSettings.h:160

pandora::ParticleFlowObject
ParticleFlowObject class.
Definition ParticleFlowObject.h:26

pandora::PdgTable::GetParticleMass
static float GetParticleMass(const int pdgCode)
Get the mass of a particle type.
Definition PdgTable.h:205

pandora::PdgTable::GetParticleCharge
static int GetParticleCharge(const int pdgCode)
Get the charge of a particle type.
Definition PdgTable.h:227

pandora::Process::GetPandora
const Pandora & GetPandora() const
Get the associated pandora instance.
Definition Process.h:116

pandora::StatusCodeException
StatusCodeException class.
Definition StatusCodes.h:119

pandora::StatusCodeException::GetStatusCode
StatusCode GetStatusCode() const
Get status code.
Definition StatusCodes.h:191

pandora::TiXmlHandle
Definition tinyxml.h:1646

pandora::Vertex
Vertex class.
Definition Vertex.h:26

pandora::Vertex::GetPosition
const CartesianVector & GetPosition() const
Get the vertex position.
Definition Vertex.h:103

pandora::XmlHelper::ReadVectorOfValues
static StatusCode ReadVectorOfValues(const TiXmlHandle &xmlHandle, const std::string &xmlElementName, std::vector< T > &vector)
Read a vector of values from a (space separated) list in an xml element.
Definition XmlHelper.h:229

pandora::XmlHelper::ReadValue
static StatusCode ReadValue(const TiXmlHandle &xmlHandle, const std::string &xmlElementName, T &t)
Read a value from an xml element.
Definition XmlHelper.h:136

cluster
Definition LArPandoraOutput.h:18

lar_content
Definition CheatingBeamParticleIdTool.cc:19

lar_content::TwoDSlidingFitResultMap
std::unordered_map< const pandora::Cluster *, TwoDSlidingFitResult > TwoDSlidingFitResultMap
Definition LArTwoDSlidingFitResult.h:551

pandora
Definition LArContent.h:12

pandora::HitType
HitType
Calorimeter hit type enum.
Definition PandoraEnumeratedTypes.h:65

pandora::TPC_VIEW_V
@ TPC_VIEW_V
Definition PandoraEnumeratedTypes.h:71

pandora::TPC_VIEW_U
@ TPC_VIEW_U
Definition PandoraEnumeratedTypes.h:70

pandora::TPC_3D
@ TPC_3D
Definition PandoraEnumeratedTypes.h:73

pandora::TPC_VIEW_W
@ TPC_VIEW_W
Definition PandoraEnumeratedTypes.h:72

pandora::ClusterVector
std::vector< const Cluster * > ClusterVector
Definition PandoraInternal.h:445

pandora::ClusterList
MANAGED_CONTAINER< const Cluster * > ClusterList
Definition PandoraInternal.h:434

pandora::StringVector
std::vector< std::string > StringVector
Definition PandoraInternal.h:468

pandora::ClusterSet
std::unordered_set< const Cluster * > ClusterSet
Definition PandoraInternal.h:456

pandora::VertexList
MANAGED_CONTAINER< const Vertex * > VertexList
Definition PandoraInternal.h:442

pandora::StatusCode
StatusCode
The StatusCode enum.
Definition StatusCodes.h:100

pandora::PfoList
MANAGED_CONTAINER< const ParticleFlowObject * > PfoList
Definition PandoraInternal.h:439

pandora::VERTEX_3D
@ VERTEX_3D
Definition PandoraEnumeratedTypes.h:148