TransverseTrackHitsBaseTool.cc

Go to the documentation of this file.

#include "Pandora/AlgorithmHeaders.h"

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

#include "larpandoracontent/LArHelpers/LArGeometryHelper.h"

using namespace pandora;

namespace lar_content
{

void TransverseTrackHitsBaseTool::GetTrackHits3D(const CaloHitVector &inputTwoDHits, const MatchedSlidingFitMap &matchedSlidingFitMap,
    ProtoHitVector &protoHitVector) const
{   
    for (const CaloHit *const pCaloHit2D : inputTwoDHits)
    {
        try
        {
            ProtoHit protoHit(pCaloHit2D);
            this->GetTransverseTrackHit3D(matchedSlidingFitMap, protoHit);
            this->AddTransverseChi2(matchedSlidingFitMap, protoHit);

            if (protoHit.IsPositionSet() && (protoHit.GetChi2() < m_chiSquaredCut))
                protoHitVector.push_back(protoHit);
        }
        catch (StatusCodeException &)
        {
        }
    }
}

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

void TransverseTrackHitsBaseTool::AddTransverseChi2(const MatchedSlidingFitMap &matchedSlidingFitMap, ProtoHit &protoHit) const
{  
    // TODO Develop a proper treatment of the |dz/dx| * sigmaX uncertainty
    double chiSquared(protoHit.GetChi2());
    const HitType inputHitType(protoHit.GetParentCaloHit2D()->GetHitType());
    const CartesianVector &inputPosition3D(protoHit.GetPosition3D());

    for (const MatchedSlidingFitMap::value_type &mapEntry : matchedSlidingFitMap)
    {
        if (mapEntry.first == inputHitType)
            continue;

        const CartesianVector inputPosition2D(LArGeometryHelper::ProjectPosition(this->GetPandora(), inputPosition3D, mapEntry.first));
        chiSquared += this->GetTransverseChi2(inputPosition2D, mapEntry.second);
    }

    protoHit.SetPosition3D(inputPosition3D, chiSquared);
}

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

double TransverseTrackHitsBaseTool::GetTransverseChi2(const CartesianVector &position2D, const TwoDSlidingFitResult &fitResult) const
{
    const float minLayerX(fitResult.GetGlobalMinLayerPosition().GetX());
    const float maxLayerX(fitResult.GetGlobalMaxLayerPosition().GetX());

    const float minX(std::min(minLayerX, maxLayerX));
    const float maxX(std::max(minLayerX, maxLayerX));

    if (((position2D.GetX() - minX) > -std::numeric_limits<float>::epsilon()) && 
        ((position2D.GetX() - maxX) < +std::numeric_limits<float>::epsilon()))
        return 0.;

    const float minLayerDistanceSquared((position2D - fitResult.GetGlobalMinLayerPosition()).GetMagnitudeSquared());
    const float maxLayerDistanceSquared((position2D - fitResult.GetGlobalMaxLayerPosition()).GetMagnitudeSquared());

    double px(0.), pz(0.);

    if (minLayerDistanceSquared < maxLayerDistanceSquared)
    {
        px = fitResult.GetGlobalMinLayerDirection().GetX();
        pz = fitResult.GetGlobalMinLayerDirection().GetZ();
    }
    else if (maxLayerDistanceSquared < minLayerDistanceSquared)
    {
        px = fitResult.GetGlobalMaxLayerDirection().GetX();
        pz = fitResult.GetGlobalMaxLayerDirection().GetZ();
    }

    if (std::fabs(px) > std::numeric_limits<double>::epsilon())
    {
        return (0.5 * (pz * pz) / (px * px)); // TODO: Figure out the appropriate scale factor
    }

    throw StatusCodeException(STATUS_CODE_NOT_FOUND);
}

} // namespace lar_content