pandora_srcnav/_three_d_hit_creation_algorithm_8cc_source.html

#include "Pandora/AlgorithmHeaders.h"


#include "larpandoracontent/LArHelpers/LArClusterHelper.h"

#include "larpandoracontent/LArHelpers/LArGeometryHelper.h"

#include "larpandoracontent/LArHelpers/LArPfoHelper.h"


#include "larpandoracontent/LArObjects/LArThreeDSlidingFitResult.h"


#include "larpandoracontent/LArThreeDReco/LArHitCreation/HitCreationBaseTool.h"

#include "larpandoracontent/LArThreeDReco/LArHitCreation/ThreeDHitCreationAlgorithm.h"


#include <algorithm>


using namespace pandora;


namespace lar_content

{


ThreeDHitCreationAlgorithm::ThreeDHitCreationAlgorithm() :

    m_iterateTrackHits(true),

    m_iterateShowerHits(false),

    m_slidingFitHalfWindow(10),

    m_nHitRefinementIterations(10),

    m_sigma3DFitMultiplier(0.2),

    m_iterationMaxChi2Ratio(1.)

{

}


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


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

{

    for (const CaloHit *const pCaloHit : inputCaloHitVector)

    {

        if (hitType == pCaloHit->GetHitType())

            outputCaloHitVector.push_back(pCaloHit);

    }

}


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


StatusCode ThreeDHitCreationAlgorithm::Run()

{

    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 ThreeDHitCreationAlgorithm::SeparateTwoDHits(

    const ParticleFlowObject *const pPfo, const ProtoHitVector &protoHitVector, CaloHitVector &remainingHitVector) const

{

    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);

}


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


void ThreeDHitCreationAlgorithm::IterativeTreatment(ProtoHitVector &protoHitVector) const

{

    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 &)

    {

    }

}


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


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

{

    chi2 = 0.;

    pointVector.clear();


    for (const ProtoHit &protoHit : protoHitVector)

    {

        chi2 += protoHit.GetChi2();

        pointVector.push_back(protoHit.GetPosition3D());

    }

}


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


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

{

    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 ThreeDHitCreationAlgorithm::GetHitMovementChi2(const ProtoHitVector &protoHitVector) const

{

    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 ThreeDHitCreationAlgorithm::RefineHitPositions(const ThreeDSlidingFitResult &slidingFitResult, ProtoHitVector &protoHitVector) const

{

    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);

    }

}


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


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

{

    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 ThreeDHitCreationAlgorithm::CreateThreeDHit(const ProtoHit &protoHit, const CaloHit *&pCaloHit3D) const

{

    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));

}


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


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

{

    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 ThreeDHitCreationAlgorithm::AddThreeDHitsToPfo(const ParticleFlowObject *const pPfo, const CaloHitList &caloHitList) const

{

    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));

}


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

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


const CartesianVector &ThreeDHitCreationAlgorithm::ProtoHit::GetPosition3D() const

{

    if (!m_isPositionSet)

        throw StatusCodeException(STATUS_CODE_NOT_INITIALIZED);


    return m_position3D;

}


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


double ThreeDHitCreationAlgorithm::ProtoHit::GetChi2() const

{

    if (!m_isPositionSet)

        throw StatusCodeException(STATUS_CODE_NOT_INITIALIZED);


    return m_chi2;

}


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


const ThreeDHitCreationAlgorithm::TrajectorySample &ThreeDHitCreationAlgorithm::ProtoHit::GetFirstTrajectorySample() const

{

    if (m_trajectorySampleVector.empty())

        throw StatusCodeException(STATUS_CODE_NOT_INITIALIZED);


    return m_trajectorySampleVector.front();

}


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


const ThreeDHitCreationAlgorithm::TrajectorySample &ThreeDHitCreationAlgorithm::ProtoHit::GetLastTrajectorySample() const

{

    if (m_trajectorySampleVector.size() < 2)

        throw StatusCodeException(STATUS_CODE_NOT_INITIALIZED);


    return m_trajectorySampleVector.back();

}


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

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


StatusCode ThreeDHitCreationAlgorithm::ReadSettings(const TiXmlHandle xmlHandle)

{

    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;

}


} // namespace lar_content

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

HitCreationBaseTool.h
Header file for the hit creation base tool.

LArClusterHelper.h
Header file for the cluster helper class.

LArGeometryHelper.h
Header file for the geometry helper class.

LArPfoHelper.h
Header file for the pfo helper class.

LArThreeDSlidingFitResult.h
Header file for the lar three dimensional sliding fit result class.

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

ThreeDHitCreationAlgorithm.h
Header file for the three dimensional hit creation algorithm class.

PandoraContentApi::SaveList
static pandora::StatusCode SaveList(const pandora::Algorithm &algorithm, const T &t, const std::string &newListName)
Save a provided input object list under a new name.
Definition PandoraContentApi.cc:132

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::AddToPfo
static pandora::StatusCode AddToPfo(const pandora::Algorithm &algorithm, const pandora::ParticleFlowObject *const pPfo, const T *const pT)
Add a cluster to a particle flow object.
Definition PandoraContentApi.cc:318

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::GetPlugins
static const pandora::PluginManager * GetPlugins(const pandora::Algorithm &algorithm)
Get the pandora plugin instance, providing access to user registered functions and calculators.
Definition PandoraContentApi.cc:29

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::HitCreationBaseTool
HitCreationBaseTool class.
Definition HitCreationBaseTool.h:22

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::SortHitsByPosition
static bool SortHitsByPosition(const pandora::CaloHit *const pLhs, const pandora::CaloHit *const pRhs)
Sort calo hits by their position (use Z, followed by X, followed by Y)
Definition LArClusterHelper.cc:732

lar_content::LArGeometryHelper::GetSigmaUVW
static float GetSigmaUVW(const pandora::Pandora &pandora, const float maxSigmaDiscrepancy=0.01)
Find the sigmaUVW value for the detector geometry.
Definition LArGeometryHelper.cc:546

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::LArPfoHelper::GetThreeDClusterList
static void GetThreeDClusterList(const pandora::ParticleFlowObject *const pPfo, pandora::ClusterList &clusterList)
Get the list of 3D clusters from an input pfo.
Definition LArPfoHelper.cc:136

lar_content::LArPfoHelper::IsTrack
static bool IsTrack(const pandora::ParticleFlowObject *const pPfo)
Return track flag based on Pfo Particle ID.
Definition LArPfoHelper.cc:344

lar_content::LArPfoHelper::IsShower
static bool IsShower(const pandora::ParticleFlowObject *const pPfo)
Return shower flag based on Pfo Particle ID.
Definition LArPfoHelper.cc:354

lar_content::LArPfoHelper::GetTwoDClusterList
static void GetTwoDClusterList(const pandora::ParticleFlowObject *const pPfo, pandora::ClusterList &clusterList)
Get the list of 2D clusters from an input pfo.
Definition LArPfoHelper.cc:123

lar_content::LArPfoHelper::SortByNHits
static bool SortByNHits(const pandora::ParticleFlowObject *const pLhs, const pandora::ParticleFlowObject *const pRhs)
Sort pfos by number of constituent hits.
Definition LArPfoHelper.cc:610

lar_content::ThreeDHitCreationAlgorithm::ProtoHit
Proto hits are temporary constructs to be used during iterative 3D hit procedure.
Definition ThreeDHitCreationAlgorithm.h:74

lar_content::ThreeDHitCreationAlgorithm::ProtoHit::GetFirstTrajectorySample
const TrajectorySample & GetFirstTrajectorySample() const
Get the first trajectory sample.
Definition ThreeDHitCreationAlgorithm.cc:442

lar_content::ThreeDHitCreationAlgorithm::ProtoHit::GetChi2
double GetChi2() const
Get the chi squared value.
Definition ThreeDHitCreationAlgorithm.cc:432

lar_content::ThreeDHitCreationAlgorithm::ProtoHit::GetParentCaloHit2D
const pandora::CaloHit * GetParentCaloHit2D() const
Get the address of the parent 2D calo hit.
Definition ThreeDHitCreationAlgorithm.h:330

lar_content::ThreeDHitCreationAlgorithm::ProtoHit::m_position3D
pandora::CartesianVector m_position3D
The output 3D position.
Definition ThreeDHitCreationAlgorithm.h:158

lar_content::ThreeDHitCreationAlgorithm::ProtoHit::GetLastTrajectorySample
const TrajectorySample & GetLastTrajectorySample() const
Get the last trajectory sample.
Definition ThreeDHitCreationAlgorithm.cc:452

lar_content::ThreeDHitCreationAlgorithm::ProtoHit::m_isPositionSet
bool m_isPositionSet
Whether the output 3D position has been set.
Definition ThreeDHitCreationAlgorithm.h:157

lar_content::ThreeDHitCreationAlgorithm::ProtoHit::GetPosition3D
const pandora::CartesianVector & GetPosition3D() const
Get the output 3D position.
Definition ThreeDHitCreationAlgorithm.cc:422

lar_content::ThreeDHitCreationAlgorithm::TrajectorySample
Trajectory samples record the results of sampling a particles in a particular view.
Definition ThreeDHitCreationAlgorithm.h:34

lar_content::ThreeDHitCreationAlgorithm::m_iterateTrackHits
bool m_iterateTrackHits
Whether to enable iterative improvement of 3D hits for track trajectories.
Definition ThreeDHitCreationAlgorithm.h:278

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

lar_content::ThreeDHitCreationAlgorithm::CheckThreeDHit
bool CheckThreeDHit(const ProtoHit &protoHit) const
Check that a new three dimensional position is not unphysical.
Definition ThreeDHitCreationAlgorithm.cc:373

lar_content::ThreeDHitCreationAlgorithm::IterativeTreatment
void IterativeTreatment(ProtoHitVector &protoHitVector) const
Improve initial 3D hits by fitting proto hits and iteratively creating consisted 3D hit trajectory.
Definition ThreeDHitCreationAlgorithm.cc:138

lar_content::ThreeDHitCreationAlgorithm::m_inputPfoListName
std::string m_inputPfoListName
The name of the input pfo list.
Definition ThreeDHitCreationAlgorithm.h:274

lar_content::ThreeDHitCreationAlgorithm::Run
pandora::StatusCode Run()
Run the algorithm.
Definition ThreeDHitCreationAlgorithm.cc:50

lar_content::ThreeDHitCreationAlgorithm::ProtoHitVector
std::vector< ProtoHit > ProtoHitVector
Definition ThreeDHitCreationAlgorithm.h:163

lar_content::ThreeDHitCreationAlgorithm::GetChi2WrtFit
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 tr...
Definition ThreeDHitCreationAlgorithm.cc:194

lar_content::ThreeDHitCreationAlgorithm::SeparateTwoDHits
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.
Definition ThreeDHitCreationAlgorithm.cc:105

lar_content::ThreeDHitCreationAlgorithm::RefineHitPositions
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 sli...
Definition ThreeDHitCreationAlgorithm.cc:251

lar_content::ThreeDHitCreationAlgorithm::CreateThreeDHits
void CreateThreeDHits(const ProtoHitVector &protoHitVector, pandora::CaloHitList &newThreeDHits) const
Create new three dimensional hits from two dimensional hits.
Definition ThreeDHitCreationAlgorithm.cc:322

lar_content::ThreeDHitCreationAlgorithm::ThreeDHitCreationAlgorithm
ThreeDHitCreationAlgorithm()
Default constructor.
Definition ThreeDHitCreationAlgorithm.cc:27

lar_content::ThreeDHitCreationAlgorithm::m_iterateShowerHits
bool m_iterateShowerHits
Whether to enable iterative improvement of 3D hits for showers.
Definition ThreeDHitCreationAlgorithm.h:279

lar_content::ThreeDHitCreationAlgorithm::FilterCaloHitsByType
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.
Definition ThreeDHitCreationAlgorithm.cc:39

lar_content::ThreeDHitCreationAlgorithm::GetHitMovementChi2
double GetHitMovementChi2(const ProtoHitVector &protoHitVector) const
Receive a chi2 value indicating consistency of a list of proto hits with the original,...
Definition ThreeDHitCreationAlgorithm.cc:230

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

lar_content::ThreeDHitCreationAlgorithm::m_algorithmToolVector
HitCreationToolVector m_algorithmToolVector
The algorithm tool vector.
Definition ThreeDHitCreationAlgorithm.h:272

lar_content::ThreeDHitCreationAlgorithm::m_slidingFitHalfWindow
unsigned int m_slidingFitHalfWindow
The sliding linear fit half window.
Definition ThreeDHitCreationAlgorithm.h:280

lar_content::ThreeDHitCreationAlgorithm::m_nHitRefinementIterations
unsigned int m_nHitRefinementIterations
The maximum number of hit refinement iterations.
Definition ThreeDHitCreationAlgorithm.h:281

lar_content::ThreeDHitCreationAlgorithm::m_sigma3DFitMultiplier
double m_sigma3DFitMultiplier
Multiplicative factor: sigmaUVW (same as sigmaHit and sigma2DFit) to sigma3DFit.
Definition ThreeDHitCreationAlgorithm.h:282

lar_content::ThreeDHitCreationAlgorithm::m_outputCaloHitListName
std::string m_outputCaloHitListName
The name of the output calo hit list.
Definition ThreeDHitCreationAlgorithm.h:275

lar_content::ThreeDHitCreationAlgorithm::AddThreeDHitsToPfo
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 req...
Definition ThreeDHitCreationAlgorithm.cc:391

lar_content::ThreeDHitCreationAlgorithm::CreateThreeDHit
void CreateThreeDHit(const ProtoHit &protoHit, const pandora::CaloHit *&pCaloHit3D) const
Create a new three dimensional hit from a two dimensional hit.
Definition ThreeDHitCreationAlgorithm.cc:338

lar_content::ThreeDHitCreationAlgorithm::m_outputClusterListName
std::string m_outputClusterListName
The name of the output cluster list.
Definition ThreeDHitCreationAlgorithm.h:276

lar_content::ThreeDHitCreationAlgorithm::m_iterationMaxChi2Ratio
double m_iterationMaxChi2Ratio
Max ratio between current and previous chi2 values to cease iterations.
Definition ThreeDHitCreationAlgorithm.h:283

lar_content::ThreeDSlidingFitResult
ThreeDSlidingFitResult class.
Definition LArThreeDSlidingFitResult.h:24

lar_content::ThreeDSlidingFitResult::GetGlobalFitPosition
pandora::StatusCode GetGlobalFitPosition(const float rL, pandora::CartesianVector &position) const
Get global fit position for a given longitudinal coordinate.
Definition LArThreeDSlidingFitResult.cc:121

lar_content::ThreeDSlidingFitResult::GetLongitudinalDisplacement
float GetLongitudinalDisplacement(const pandora::CartesianVector &position) const
Get longitudinal projection onto primary axis.
Definition LArThreeDSlidingFitResult.cc:114

pandora::CaloHit
CaloHit class.
Definition CaloHit.h:26

pandora::CaloHit::GetElectromagneticEnergy
float GetElectromagneticEnergy() const
Get the calibrated electromagnetic energy measure.
Definition CaloHit.h:483

pandora::CaloHit::GetHitType
HitType GetHitType() const
Get the calorimeter hit type.
Definition CaloHit.h:441

pandora::CaloHit::IsInOuterSamplingLayer
bool IsInOuterSamplingLayer() const
Whether cell is in one of the outermost detector sampling layers.
Definition CaloHit.h:469

pandora::CaloHit::GetHitRegion
HitRegion GetHitRegion() const
Get the region of the detector in which the calo hit is located.
Definition CaloHit.h:448

pandora::CaloHit::GetPositionVector
const CartesianVector & GetPositionVector() const
Get the position vector of center of calorimeter cell, units mm.
Definition CaloHit.h:350

pandora::CaloHit::GetLayer
unsigned int GetLayer() const
Get the subdetector readout layer number.
Definition CaloHit.h:455

pandora::CaloHit::GetMipEquivalentEnergy
float GetMipEquivalentEnergy() const
Get the calibrated mip equivalent energy.
Definition CaloHit.h:476

pandora::CaloHit::GetNCellRadiationLengths
float GetNCellRadiationLengths() const
Get the absorber material in front of cell, units radiation lengths.
Definition CaloHit.h:406

pandora::CaloHit::GetNCellInteractionLengths
float GetNCellInteractionLengths() const
Get the absorber material in front of cell, units interaction lengths.
Definition CaloHit.h:413

pandora::CaloHit::GetCellThickness
float GetCellThickness() const
Get the thickness of cell, units mm.
Definition CaloHit.h:399

pandora::CaloHit::GetCellLengthScale
float GetCellLengthScale() const
Get the typical length scale of cell, units mm.
Definition CaloHit.h:497

pandora::CaloHit::IsDigital
bool IsDigital() const
Whether cell should be treated as digital.
Definition CaloHit.h:434

pandora::CaloHit::GetCellNormalVector
const CartesianVector & GetCellNormalVector() const
Get the unit vector normal to the sampling layer, pointing outwards from the origin.
Definition CaloHit.h:371

pandora::CaloHit::GetHadronicEnergy
float GetHadronicEnergy() const
Get the calibrated hadronic energy measure.
Definition CaloHit.h:490

pandora::CaloHit::GetInputEnergy
float GetInputEnergy() const
Get the corrected energy of the calorimeter cell, units GeV, as supplied by the user.
Definition CaloHit.h:420

pandora::CaloHit::GetTime
float GetTime() const
Get the time of (earliest) energy deposition in this cell, units ns.
Definition CaloHit.h:427

pandora::CaloHit::GetExpectedDirection
const CartesianVector & GetExpectedDirection() const
Get the unit vector in direction of expected hit propagation.
Definition CaloHit.h:364

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

pandora::CartesianVector::GetX
float GetX() const
Get the cartesian x coordinate.
Definition CartesianVector.h:259

pandora::CartesianVector::GetZ
float GetZ() const
Get the cartesian z coordinate.
Definition CartesianVector.h:273

pandora::CartesianVector::GetY
float GetY() const
Get the cartesian y coordinate.
Definition CartesianVector.h:266

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

pandora::LArTransformationPlugin::GetMinChiSquaredYZ
virtual void GetMinChiSquaredYZ(const double u, const double v, const double w, const double sigmaU, const double sigmaV, const double sigmaW, double &y, double &z, double &chiSquared) const =0
Get the y, z position that yields the minimum chi squared value with respect to specified u,...

pandora::LArTransformationPlugin::YZtoU
virtual double YZtoU(const double y, const double z) const =0
Transform from (Y,Z) to U position.

pandora::LArTransformationPlugin::YZtoW
virtual double YZtoW(const double y, const double z) const =0
Transform from (Y,Z) to W position.

pandora::LArTransformationPlugin::YZtoV
virtual double YZtoV(const double y, const double z) const =0
Transform from (Y,Z) to V position.

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::PluginManager::GetLArTransformationPlugin
const LArTransformationPlugin * GetLArTransformationPlugin() const
Get the address of the lar transformation plugin.
Definition PluginManager.cc:104

pandora::PluginManager::GetPseudoLayerPlugin
const PseudoLayerPlugin * GetPseudoLayerPlugin() const
Get the address of the pseudo layer plugin.
Definition PluginManager.cc:114

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

pandora::PseudoLayerPlugin::GetPseudoLayer
virtual unsigned int GetPseudoLayer(const CartesianVector &positionVector) const =0
Get the appropriate pseudolayer for a specified position vector.

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

pandora::TiXmlHandle
Definition tinyxml.h:1646

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

pandora::XmlHelper::ProcessAlgorithmToolList
static StatusCode ProcessAlgorithmToolList(const Algorithm &algorithm, const TiXmlHandle &xmlHandle, const std::string &listName, AlgorithmToolVector &algorithmToolVector)
Process a list of algorithms tools in an xml file.
Definition XmlHelper.cc:101

lar_content
Definition CheatingBeamParticleIdTool.cc:19

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::CaloHitVector
std::vector< const CaloHit * > CaloHitVector
Definition PandoraInternal.h:444

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

pandora::PfoVector
std::vector< const ParticleFlowObject * > PfoVector
Definition PandoraInternal.h:450

pandora::CartesianPointVector
std::vector< CartesianVector > CartesianPointVector
Definition PandoraInternal.h:469

pandora::AlgorithmToolVector
std::vector< AlgorithmTool * > AlgorithmToolVector
Definition PandoraInternal.h:471

pandora::CaloHitSet
std::unordered_set< const CaloHit * > CaloHitSet
Definition PandoraInternal.h:455

pandora::RECTANGULAR
@ RECTANGULAR
Definition PandoraEnumeratedTypes.h:19

pandora::CaloHitList
MANAGED_CONTAINER< const CaloHit * > CaloHitList
Definition PandoraInternal.h:433

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

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