pandora_srcnav/_cluster_8cc_source.html

#include "Managers/PluginManager.h"


#include "Objects/CaloHit.h"

#include "Objects/Cluster.h"

#include "Objects/Track.h"


#include "Pandora/Pandora.h"

#include "Pandora/PdgTable.h"


#include "Plugins/EnergyCorrectionsPlugin.h"

#include "Plugins/ParticleIdPlugin.h"

#include "Plugins/ShowerProfilePlugin.h"


#include <algorithm>


namespace pandora

{


const Track *Cluster::GetTrackSeed() const

{

    if (!m_pTrackSeed)

        throw StatusCodeException(STATUS_CODE_NOT_INITIALIZED);


    return m_pTrackSeed;

}


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


const CartesianVector Cluster::GetCentroid(const unsigned int pseudoLayer) const

{

    PointByPseudoLayerMap::const_iterator pointValueIter = m_sumXYZByPseudoLayer.find(pseudoLayer);


    if (m_sumXYZByPseudoLayer.end() == pointValueIter)

        throw StatusCodeException(STATUS_CODE_FAILURE);


    const SimplePoint &mypoint = pointValueIter->second;


    if (0 == mypoint.m_nHits)

        throw StatusCodeException(STATUS_CODE_FAILURE);


    return CartesianVector(static_cast<float>(mypoint.m_xyzPositionSums[0] / static_cast<float>(mypoint.m_nHits)),

        static_cast<float>(mypoint.m_xyzPositionSums[1] / static_cast<float>(mypoint.m_nHits)),

        static_cast<float>(mypoint.m_xyzPositionSums[2] / static_cast<float>(mypoint.m_nHits)));

}


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


const CartesianVector &Cluster::GetInitialDirection() const

{

    if (!m_isDirectionUpToDate)

        this->UpdateInitialDirectionCache();


    return m_initialDirection;

}


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


const ClusterFitResult &Cluster::GetFitToAllHitsResult() const

{

    if (!m_isFitUpToDate)

        this->UpdateFitToAllHitsCache();


    return m_fitToAllHitsResult;

}


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


HitType Cluster::GetInnerLayerHitType() const

{

    if (!m_innerLayerHitType.IsInitialized())

        this->UpdateLayerHitTypeCache(m_innerPseudoLayer.Get(), m_innerLayerHitType);


    return m_innerLayerHitType.Get();

}


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


HitType Cluster::GetOuterLayerHitType() const

{

    if (!m_outerLayerHitType.IsInitialized())

        this->UpdateLayerHitTypeCache(m_outerPseudoLayer.Get(), m_outerLayerHitType);


    return m_outerLayerHitType.Get();

}


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


float Cluster::GetCorrectedElectromagneticEnergy(const Pandora &pandora) const

{

    if (!m_correctedElectromagneticEnergy.IsInitialized())

        this->UpdateEnergyCorrectionsCache(pandora);


    return m_correctedElectromagneticEnergy.Get();

}


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


float Cluster::GetCorrectedHadronicEnergy(const Pandora &pandora) const

{

    if (!m_correctedHadronicEnergy.IsInitialized())

        this->UpdateEnergyCorrectionsCache(pandora);


    return m_correctedHadronicEnergy.Get();

}


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


float Cluster::GetTrackComparisonEnergy(const Pandora &pandora) const

{

    if (!m_trackComparisonEnergy.IsInitialized())

        this->UpdateEnergyCorrectionsCache(pandora);


    return m_trackComparisonEnergy.Get();

}


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


bool Cluster::PassPhotonId(const Pandora &pandora) const

{

    if (PHOTON == m_particleId)

        return true;


    if (!m_passPhotonId.IsInitialized())

        this->UpdatePhotonIdCache(pandora);


    return m_passPhotonId.Get();

}


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


unsigned int Cluster::GetShowerStartLayer(const Pandora &pandora) const

{

    if (!m_showerStartLayer.IsInitialized())

        this->UpdateShowerLayerCache(pandora);


    return m_showerStartLayer.Get();

}


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


float Cluster::GetShowerProfileStart(const Pandora &pandora) const

{

    if (!m_showerProfileStart.IsInitialized())

        this->UpdateShowerProfileCache(pandora);


    return m_showerProfileStart.Get();

}


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


float Cluster::GetShowerProfileDiscrepancy(const Pandora &pandora) const

{

    if (!m_showerProfileDiscrepancy.IsInitialized())

        this->UpdateShowerProfileCache(pandora);


    return m_showerProfileDiscrepancy.Get();

}


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


void Cluster::GetClusterSpanX(float &xmin, float &xmax) const

{

    if (m_xMin.IsInitialized() && m_xMax.IsInitialized())

    {

        xmin = m_xMin.Get();

        xmax = m_xMax.Get();

    }

    else

    {

        xmin = std::numeric_limits<float>::max();

        xmax = -std::numeric_limits<float>::max();


        for (OrderedCaloHitList::const_iterator ochIter = m_orderedCaloHitList.begin();  ochIter != m_orderedCaloHitList.end(); ++ochIter)

        {

            for (CaloHitList::const_iterator hIter = ochIter->second->begin(); hIter != ochIter->second->end(); ++hIter)

            {

                const CaloHit *const pCaloHit = *hIter;

                const CartesianVector &hit(pCaloHit->GetPositionVector());

                xmin = std::min(hit.GetX(), xmin);

                xmax = std::max(hit.GetX(), xmax);

            }

        }

        m_xMin.Set(xmin);

        m_xMax.Set(xmax);

    }

}


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


void Cluster::GetClusterSpanZ(const float xmin, const float xmax, float &zmin, float &zmax) const

{

    if (xmin > xmax)

        throw StatusCodeException(STATUS_CODE_INVALID_PARAMETER);


    const OrderedCaloHitList &orderedCaloHitList(this->GetOrderedCaloHitList());


    zmin = std::numeric_limits<float>::max();

    zmax = -std::numeric_limits<float>::max();


    bool foundHits(false);


    for (OrderedCaloHitList::const_iterator ochIter = orderedCaloHitList.begin(), ochIterEnd = orderedCaloHitList.end(); ochIter != ochIterEnd; ++ochIter)

    {

        for (CaloHitList::const_iterator hIter = ochIter->second->begin(), hIterEnd = ochIter->second->end(); hIter != hIterEnd; ++hIter)

        {

            const CaloHit *const pCaloHit = *hIter;

            const CartesianVector &hit(pCaloHit->GetPositionVector());


            if (hit.GetX() < xmin || hit.GetX() > xmax)

                continue;


            zmin = std::min(hit.GetZ(), zmin);

            zmax = std::max(hit.GetZ(), zmax);

            foundHits = true;

        }

    }


    if (!foundHits)

        throw StatusCodeException(STATUS_CODE_NOT_FOUND);

}


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


Cluster::Cluster(const object_creation::Cluster::Parameters &parameters) :

    m_nCaloHits(0),

    m_nPossibleMipHits(0),

    m_nCaloHitsInOuterLayer(0),

    m_electromagneticEnergy(0),

    m_hadronicEnergy(0),

    m_isolatedElectromagneticEnergy(0),

    m_isolatedHadronicEnergy(0),

    m_particleId(UNKNOWN_PARTICLE_TYPE),

    m_pTrackSeed(parameters.m_pTrack.IsInitialized() ? parameters.m_pTrack.Get() : nullptr),

    m_initialDirection(0.f, 0.f, 0.f),

    m_isDirectionUpToDate(false),

    m_isFitUpToDate(false),

    m_isAvailable(true)

{

    if (parameters.m_caloHitList.empty() && parameters.m_isolatedCaloHitList.empty() && !parameters.m_pTrack.IsInitialized())

        throw StatusCodeException(STATUS_CODE_INVALID_PARAMETER);


    if (parameters.m_pTrack.IsInitialized())

    {

        m_initialDirection = parameters.m_pTrack.Get()->GetTrackStateAtCalorimeter().GetMomentum().GetUnitVector();

        m_isDirectionUpToDate = true;

    }


    for (const CaloHit *const pCaloHit : parameters.m_caloHitList)

    {

        PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->AddCaloHit(pCaloHit));

    }


    for (const CaloHit *const pCaloHit : parameters.m_isolatedCaloHitList)

    {

        PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->AddIsolatedCaloHit(pCaloHit));

    }

}


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


Cluster::~Cluster()

{

}


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


StatusCode Cluster::AlterMetadata(const object_creation::Cluster::Metadata &metadata)

{

    if (metadata.m_particleId.IsInitialized())

    {

        m_passPhotonId.Reset();

        m_particleId = metadata.m_particleId.Get();

    }


    return STATUS_CODE_SUCCESS;

}


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


StatusCode Cluster::AddCaloHit(const CaloHit *const pCaloHit)

{

    PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, m_orderedCaloHitList.Add(pCaloHit));


    this->ResetOutdatedProperties();


    ++m_nCaloHits;


    if (pCaloHit->IsPossibleMip())

        ++m_nPossibleMipHits;


    if (pCaloHit->IsInOuterSamplingLayer())

        ++m_nCaloHitsInOuterLayer;


    const float x(pCaloHit->GetPositionVector().GetX());

    const float y(pCaloHit->GetPositionVector().GetY());

    const float z(pCaloHit->GetPositionVector().GetZ());


    m_electromagneticEnergy += pCaloHit->GetElectromagneticEnergy();

    m_hadronicEnergy += pCaloHit->GetHadronicEnergy();


    const unsigned int pseudoLayer(pCaloHit->GetPseudoLayer());

    OrderedCaloHitList::const_iterator iter = m_orderedCaloHitList.find(pseudoLayer);


    if ((m_orderedCaloHitList.end() != iter) && (iter->second->size() > 1))

    {

        SimplePoint &mypoint = m_sumXYZByPseudoLayer[pseudoLayer];

        mypoint.m_xyzPositionSums[0] += x;

        mypoint.m_xyzPositionSums[1] += y;

        mypoint.m_xyzPositionSums[2] += z;

        ++mypoint.m_nHits;

    }

    else

    {

        SimplePoint &mypoint = m_sumXYZByPseudoLayer[pseudoLayer];

        mypoint.m_xyzPositionSums[0] = x;

        mypoint.m_xyzPositionSums[1] = y;

        mypoint.m_xyzPositionSums[2] = z;

        mypoint.m_nHits = 1;

    }


    if (!m_innerPseudoLayer.IsInitialized() || (pseudoLayer < m_innerPseudoLayer.Get()))

        m_innerPseudoLayer = pseudoLayer;


    if (!m_outerPseudoLayer.IsInitialized() || (pseudoLayer > m_outerPseudoLayer.Get()))

        m_outerPseudoLayer = pseudoLayer;


    return STATUS_CODE_SUCCESS;

}


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


StatusCode Cluster::RemoveCaloHit(const CaloHit *const pCaloHit)

{

    PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, m_orderedCaloHitList.Remove(pCaloHit));


    if (m_orderedCaloHitList.empty())

        return this->ResetProperties();


    this->ResetOutdatedProperties();


    --m_nCaloHits;


    if (pCaloHit->IsPossibleMip())

        --m_nPossibleMipHits;


    if (pCaloHit->IsInOuterSamplingLayer())

        --m_nCaloHitsInOuterLayer;


    const float x(pCaloHit->GetPositionVector().GetX());

    const float y(pCaloHit->GetPositionVector().GetY());

    const float z(pCaloHit->GetPositionVector().GetZ());


    m_electromagneticEnergy -= pCaloHit->GetElectromagneticEnergy();

    m_hadronicEnergy -= pCaloHit->GetHadronicEnergy();


    const unsigned int pseudoLayer(pCaloHit->GetPseudoLayer());


    if (m_orderedCaloHitList.end() != m_orderedCaloHitList.find(pseudoLayer))

    {

        SimplePoint &mypoint = m_sumXYZByPseudoLayer[pseudoLayer];

        mypoint.m_xyzPositionSums[0] -= x;

        mypoint.m_xyzPositionSums[1] -= y;

        mypoint.m_xyzPositionSums[2] -= z;

        --mypoint.m_nHits;

    }

    else

    {

        m_sumXYZByPseudoLayer.erase(pseudoLayer);

    }


    if (pseudoLayer <= m_innerPseudoLayer.Get())

        m_innerPseudoLayer = m_orderedCaloHitList.begin()->first;


    if (pseudoLayer >= m_outerPseudoLayer.Get())

        m_outerPseudoLayer = m_orderedCaloHitList.rbegin()->first;


    return STATUS_CODE_SUCCESS;

}


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


StatusCode Cluster::AddIsolatedCaloHit(const CaloHit *const pCaloHit)

{

    if (m_isolatedCaloHitList.end() != std::find(m_isolatedCaloHitList.begin(), m_isolatedCaloHitList.end(), pCaloHit))

        return STATUS_CODE_ALREADY_PRESENT;


    m_isolatedCaloHitList.push_back(pCaloHit);

    const float electromagneticEnergy(pCaloHit->GetElectromagneticEnergy());

    const float hadronicEnergy(pCaloHit->GetHadronicEnergy());


    m_electromagneticEnergy += electromagneticEnergy;

    m_hadronicEnergy += hadronicEnergy;

    m_isolatedElectromagneticEnergy += electromagneticEnergy;

    m_isolatedHadronicEnergy += hadronicEnergy;


    return STATUS_CODE_SUCCESS;

}


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


StatusCode Cluster::RemoveIsolatedCaloHit(const CaloHit *const pCaloHit)

{

    CaloHitList::iterator iter = std::find(m_isolatedCaloHitList.begin(), m_isolatedCaloHitList.end(), pCaloHit);


    if (m_isolatedCaloHitList.end() == iter)

        return STATUS_CODE_NOT_FOUND;


    m_isolatedCaloHitList.erase(iter);


    const float electromagneticEnergy(pCaloHit->GetElectromagneticEnergy());

    const float hadronicEnergy(pCaloHit->GetHadronicEnergy());


    m_electromagneticEnergy -= electromagneticEnergy;

    m_hadronicEnergy -= hadronicEnergy;

    m_isolatedElectromagneticEnergy -= electromagneticEnergy;

    m_isolatedHadronicEnergy -= hadronicEnergy;


    return STATUS_CODE_SUCCESS;

}


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


void Cluster::UpdateFitToAllHitsCache() const

{

    (void) ClusterFitHelper::FitFullCluster(this, m_fitToAllHitsResult);

    m_isFitUpToDate = true;

}


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


void Cluster::UpdateInitialDirectionCache() const

{

    if (m_orderedCaloHitList.empty())

    {

        m_initialDirection.SetValues(0.f, 0.f, 0.f);

        m_isDirectionUpToDate = false;

        throw StatusCodeException(STATUS_CODE_NOT_INITIALIZED);

    }


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

    CaloHitList *const pCaloHitList(m_orderedCaloHitList.begin()->second);


    for (const CaloHit *const pCaloHit : *pCaloHitList)

        initialDirection += pCaloHit->GetExpectedDirection();


    m_initialDirection = initialDirection.GetUnitVector();

    m_isDirectionUpToDate = true;

}


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


void Cluster::UpdateLayerHitTypeCache(const unsigned int pseudoLayer, InputHitType &layerHitType) const

{

    OrderedCaloHitList::const_iterator listIter = m_orderedCaloHitList.find(pseudoLayer);


    if ((m_orderedCaloHitList.end() == listIter) || (listIter->second->empty()))

        throw StatusCodeException(STATUS_CODE_INVALID_PARAMETER);


    HitTypeToEnergyMap hitTypeToEnergyMap;


    for (const CaloHit *const pCaloHit : *listIter->second)

    {

        HitTypeToEnergyMap::iterator mapIter = hitTypeToEnergyMap.find(pCaloHit->GetHitType());


        if (hitTypeToEnergyMap.end() != mapIter)

        {

            mapIter->second += pCaloHit->GetHadronicEnergy();

            continue;

        }


        if (!hitTypeToEnergyMap.insert(HitTypeToEnergyMap::value_type(pCaloHit->GetHitType(), pCaloHit->GetHadronicEnergy())).second)

            throw StatusCodeException(STATUS_CODE_FAILURE);

    }


    float highestEnergy(0.f);


    for (HitTypeToEnergyMap::value_type &mapEntry : hitTypeToEnergyMap)

    {

        if (mapEntry.second > highestEnergy)

        {

            layerHitType = mapEntry.first;

            highestEnergy = mapEntry.second;

        }

    }

}


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


void Cluster::UpdateEnergyCorrectionsCache(const Pandora &pandora) const

{

    const EnergyCorrections *const pEnergyCorrections(pandora.GetPlugins()->GetEnergyCorrections());

    const ParticleId *const pParticleId(pandora.GetPlugins()->GetParticleId());


    float correctedElectromagneticEnergy(0.f), correctedHadronicEnergy(0.f), trackComparisonEnergy(0.f);

    PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, pEnergyCorrections->MakeEnergyCorrections(this, correctedElectromagneticEnergy,

        correctedHadronicEnergy));


    if (pParticleId->IsEmShower(this))

    {

        trackComparisonEnergy = correctedElectromagneticEnergy;

    }

    else

    {

        trackComparisonEnergy = correctedHadronicEnergy;

    }


    if (!(m_correctedElectromagneticEnergy = correctedElectromagneticEnergy) || !(m_correctedHadronicEnergy = correctedHadronicEnergy) ||

        !(m_trackComparisonEnergy = trackComparisonEnergy))

    {

        throw StatusCodeException(STATUS_CODE_FAILURE);

    }

}


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


void Cluster::UpdatePhotonIdCache(const Pandora &pandora) const

{

    const bool passPhotonId(pandora.GetPlugins()->GetParticleId()->IsPhoton(this));


    if (!(m_passPhotonId = passPhotonId))

        throw StatusCodeException(STATUS_CODE_FAILURE);

}


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


void Cluster::UpdateShowerLayerCache(const Pandora &pandora) const

{

    const ShowerProfilePlugin *const pShowerProfilePlugin(pandora.GetPlugins()->GetShowerProfilePlugin());


    unsigned int showerStartLayer(std::numeric_limits<unsigned int>::max());

    pShowerProfilePlugin->CalculateShowerStartLayer(this, showerStartLayer);


    if (!(m_showerStartLayer = showerStartLayer))

        throw StatusCodeException(STATUS_CODE_FAILURE);

}


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


void Cluster::UpdateShowerProfileCache(const Pandora &pandora) const

{

    const ShowerProfilePlugin *const pShowerProfilePlugin(pandora.GetPlugins()->GetShowerProfilePlugin());


    float showerProfileStart(std::numeric_limits<float>::max()), showerProfileDiscrepancy(std::numeric_limits<float>::max());

    pShowerProfilePlugin->CalculateLongitudinalProfile(this, showerProfileStart, showerProfileDiscrepancy);


    if (!(m_showerProfileStart = showerProfileStart) || !(m_showerProfileDiscrepancy = showerProfileDiscrepancy))

        throw StatusCodeException(STATUS_CODE_FAILURE);

}


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


StatusCode Cluster::ResetProperties()

{

    if (!m_orderedCaloHitList.empty())

        m_orderedCaloHitList.Reset();


    m_isolatedCaloHitList.clear();


    m_nCaloHits = 0;

    m_nPossibleMipHits = 0;

    m_nCaloHitsInOuterLayer = 0;


    m_sumXYZByPseudoLayer.clear();


    m_electromagneticEnergy = 0;

    m_hadronicEnergy = 0;


    m_innerPseudoLayer.Reset();

    m_outerPseudoLayer.Reset();


    m_particleId = UNKNOWN_PARTICLE_TYPE;


    this->ResetOutdatedProperties();

    return STATUS_CODE_SUCCESS;

}


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


void Cluster::ResetOutdatedProperties()

{

    m_isFitUpToDate = false;

    m_isDirectionUpToDate = false;

    m_initialDirection.SetValues(0.f, 0.f, 0.f);

    m_fitToAllHitsResult.Reset();

    m_showerStartLayer.Reset();

    m_passPhotonId.Reset();

    m_showerProfileStart.Reset();

    m_showerProfileDiscrepancy.Reset();

    m_correctedElectromagneticEnergy.Reset();

    m_correctedHadronicEnergy.Reset();

    m_trackComparisonEnergy.Reset();

    m_innerLayerHitType.Reset();

    m_outerLayerHitType.Reset();

    m_xMin.Reset();

    m_xMax.Reset();

}


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


StatusCode Cluster::AddHitsFromSecondCluster(const Cluster *const pCluster)

{

    if (this == pCluster)

        return STATUS_CODE_NOT_ALLOWED;


    const OrderedCaloHitList &orderedCaloHitList(pCluster->GetOrderedCaloHitList());

    PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, m_orderedCaloHitList.Add(orderedCaloHitList));


    const CaloHitList &isolatedCaloHitList(pCluster->GetIsolatedCaloHitList());

    for (const CaloHit *const pCaloHit : isolatedCaloHitList)

    {

        if (m_isolatedCaloHitList.end() != std::find(m_isolatedCaloHitList.begin(), m_isolatedCaloHitList.end(), pCaloHit))

            return STATUS_CODE_ALREADY_PRESENT;


        m_isolatedCaloHitList.push_back(pCaloHit);

    }


    this->ResetOutdatedProperties();


    m_nCaloHits += pCluster->GetNCaloHits();

    m_nPossibleMipHits += pCluster->GetNPossibleMipHits();

    m_nCaloHitsInOuterLayer += pCluster->GetNHitsInOuterLayer();


    m_electromagneticEnergy += pCluster->GetElectromagneticEnergy();

    m_hadronicEnergy += pCluster->GetHadronicEnergy();


    // Loop over pseudo layers in second cluster

    for (const OrderedCaloHitList::value_type &layerEntry : orderedCaloHitList)

    {

        const unsigned int pseudoLayer(layerEntry.first);

        OrderedCaloHitList::const_iterator currentIter = m_orderedCaloHitList.find(pseudoLayer);


        SimplePoint &mypoint = m_sumXYZByPseudoLayer[pseudoLayer];

        const SimplePoint &theirpoint = pCluster->m_sumXYZByPseudoLayer.at(pseudoLayer);


        if ((m_orderedCaloHitList.end() != currentIter) && (currentIter->second->size() > 1))

        {

            mypoint.m_xyzPositionSums[0] += theirpoint.m_xyzPositionSums[0];

            mypoint.m_xyzPositionSums[1] += theirpoint.m_xyzPositionSums[1];

            mypoint.m_xyzPositionSums[2] += theirpoint.m_xyzPositionSums[2];

            mypoint.m_nHits += theirpoint.m_nHits;

        }

        else

        {

            mypoint.m_xyzPositionSums[0] = theirpoint.m_xyzPositionSums[0];

            mypoint.m_xyzPositionSums[1] = theirpoint.m_xyzPositionSums[1];

            mypoint.m_xyzPositionSums[2] = theirpoint.m_xyzPositionSums[2];

            mypoint.m_nHits = theirpoint.m_nHits;

        }

    }


    m_innerPseudoLayer = m_orderedCaloHitList.begin()->first;

    m_outerPseudoLayer = m_orderedCaloHitList.rbegin()->first;

    return STATUS_CODE_SUCCESS;

}


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


StatusCode Cluster::AddTrackAssociation(const Track *const pTrack)

{

    if (!pTrack)

        return STATUS_CODE_INVALID_PARAMETER;


    if (m_associatedTrackList.end() != std::find(m_associatedTrackList.begin(), m_associatedTrackList.end(), pTrack))

        return STATUS_CODE_ALREADY_PRESENT;


    m_associatedTrackList.push_back(pTrack);

    return STATUS_CODE_SUCCESS;

}


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


StatusCode Cluster::RemoveTrackAssociation(const Track *const pTrack)

{

    TrackList::iterator iter = std::find(m_associatedTrackList.begin(), m_associatedTrackList.end(), pTrack);


    if (m_associatedTrackList.end() == iter)

        return STATUS_CODE_NOT_FOUND;


    m_associatedTrackList.erase(iter);

    return STATUS_CODE_SUCCESS;

}


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


void Cluster::RemoveTrackSeed()

{

    m_pTrackSeed = nullptr;

    this->UpdateInitialDirectionCache();

}


} // namespace pandora

CaloHit.h
Header file for the calo hit class.

Cluster.h
Header file for the cluster class.

EnergyCorrectionsPlugin.h
Header file for the calo hit plugin class.

Pandora.h
Header file for the pandora class.

ParticleIdPlugin.h
Header file for the particle id plugin class.

PdgTable.h

PluginManager.h
Header file for the pandora plugin manager class.

ShowerProfilePlugin.h

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

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

Track.h
Header file for the track class.

object_creation::ObjectCreationHelper::Metadata
METADATA Metadata
Definition ObjectCreation.h:39

object_creation::ObjectCreationHelper::Parameters
PARAMETERS Parameters
Definition ObjectCreation.h:38

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::IsInOuterSamplingLayer
bool IsInOuterSamplingLayer() const
Whether cell is in one of the outermost detector sampling layers.
Definition CaloHit.h:469

pandora::CaloHit::GetPseudoLayer
unsigned int GetPseudoLayer() const
Get pseudo layer for the calo hit.
Definition CaloHit.h:462

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

pandora::CaloHit::IsPossibleMip
bool IsPossibleMip() const
Whether the calo hit is flagged as a possible mip hit.
Definition CaloHit.h:504

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

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

pandora::CartesianVector::SetValues
void SetValues(float x, float y, float z)
Set the values of cartesian vector components.
Definition CartesianVector.h:250

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

pandora::CartesianVector::GetUnitVector
CartesianVector GetUnitVector() const
Get a unit vector in the direction of the cartesian vector.
Definition CartesianVector.cc:67

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::ClusterFitHelper::FitFullCluster
static StatusCode FitFullCluster(const Cluster *const pCluster, ClusterFitResult &clusterFitResult)
Fit all points in a cluster.
Definition ClusterFitHelper.cc:86

pandora::ClusterFitResult
ClusterFitResult class.
Definition ClusterFitHelper.h:102

pandora::ClusterFitResult::Reset
void Reset()
Reset the cluster fit result.
Definition ClusterFitHelper.h:436

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

pandora::Cluster::m_isolatedElectromagneticEnergy
double m_isolatedElectromagneticEnergy
Sum of electromagnetic energy measures of isolated calo hits, units GeV.
Definition Cluster.h:436

pandora::Cluster::m_nCaloHitsInOuterLayer
unsigned int m_nCaloHitsInOuterLayer
Keep track of the number of calo hits in the outermost layers.
Definition Cluster.h:433

pandora::Cluster::AddHitsFromSecondCluster
StatusCode AddHitsFromSecondCluster(const Cluster *const pCluster)
Add the calo hits from a second cluster to this.
Definition Cluster.cc:608

pandora::Cluster::UpdatePhotonIdCache
void UpdatePhotonIdCache(const Pandora &pandora) const
Update photon if flag.
Definition Cluster.cc:524

pandora::Cluster::SimplePoint::m_xyzPositionSums
double m_xyzPositionSums[3]
The sum of the x, y and z hit positions in the pseudo layer.
Definition Cluster.h:422

pandora::Cluster::SimplePoint::m_nHits
unsigned int m_nHits
The number of hits in the pseudo layer.
Definition Cluster.h:423

pandora::Cluster::m_showerProfileStart
InputFloat m_showerProfileStart
The cluster shower profile start, units radiation lengths.
Definition Cluster.h:453

pandora::Cluster::GetInitialDirection
const CartesianVector & GetInitialDirection() const
Get the initial direction of the cluster.
Definition Cluster.cc:56

pandora::Cluster::m_pTrackSeed
const Track * m_pTrackSeed
Address of the track with which the cluster is seeded.
Definition Cluster.h:439

pandora::Cluster::m_isFitUpToDate
bool m_isFitUpToDate
Whether the fit to all calo hits is up to date.
Definition Cluster.h:447

pandora::Cluster::m_innerPseudoLayer
InputUInt m_innerPseudoLayer
The innermost pseudo layer in the cluster.
Definition Cluster.h:441

pandora::Cluster::UpdateShowerProfileCache
void UpdateShowerProfileCache(const Pandora &pandora) const
Update shower profile and comparison with expectation for a photon.
Definition Cluster.cc:547

pandora::Cluster::GetHadronicEnergy
float GetHadronicEnergy() const
Get the sum of hadronic energy measures of all constituent calo hits, units GeV.
Definition Cluster.h:526

pandora::Cluster::GetCorrectedElectromagneticEnergy
float GetCorrectedElectromagneticEnergy(const Pandora &pandora) const
Get the corrected electromagnetic estimate of the cluster energy, units GeV.
Definition Cluster.cc:96

pandora::Cluster::m_particleId
int m_particleId
The particle id flag.
Definition Cluster.h:438

pandora::Cluster::m_xMin
InputFloat m_xMin
Cached cluster minimum in x.
Definition Cluster.h:457

pandora::Cluster::m_isDirectionUpToDate
bool m_isDirectionUpToDate
Whether the initial direction of the cluster is up to date.
Definition Cluster.h:445

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

pandora::Cluster::m_hadronicEnergy
double m_hadronicEnergy
The sum of hadronic energy measures of constituent calo hits, units GeV.
Definition Cluster.h:435

pandora::Cluster::PassPhotonId
bool PassPhotonId(const Pandora &pandora) const
Whether the cluster passes the photon id.
Definition Cluster.cc:126

pandora::Cluster::m_isolatedCaloHitList
CaloHitList m_isolatedCaloHitList
The list of isolated hits, which contribute only towards cluster energy.
Definition Cluster.h:430

pandora::Cluster::HitTypeToEnergyMap
std::map< HitType, float > HitTypeToEnergyMap
The hit type to energy map typedef.
Definition Cluster.h:427

pandora::Cluster::UpdateFitToAllHitsCache
void UpdateFitToAllHitsCache() const
Update result of linear fit to all calo hits in cluster.
Definition Cluster.cc:431

pandora::Cluster::GetNHitsInOuterLayer
unsigned int GetNHitsInOuterLayer() const
Get the number of hits in the outer sampling layers.
Definition Cluster.h:512

pandora::Cluster::GetNPossibleMipHits
unsigned int GetNPossibleMipHits() const
Get the number of calo hits in the cluster that have been flagged as possible mip hits.
Definition Cluster.h:498

pandora::Cluster::m_correctedElectromagneticEnergy
InputFloat m_correctedElectromagneticEnergy
The corrected electromagnetic estimate of the cluster energy, units GeV.
Definition Cluster.h:448

pandora::Cluster::~Cluster
virtual ~Cluster()
Destructor.
Definition Cluster.cc:269

pandora::Cluster::AlterMetadata
StatusCode AlterMetadata(const object_creation::Cluster::Metadata &metadata)
Alter the metadata information stored in a cluster.
Definition Cluster.cc:275

pandora::Cluster::GetShowerProfileStart
float GetShowerProfileStart(const Pandora &pandora) const
Get the cluster shower profile start, units radiation lengths.
Definition Cluster.cc:149

pandora::Cluster::GetCentroid
const CartesianVector GetCentroid(const unsigned int pseudoLayer) const
Get unweighted centroid for cluster at a particular pseudo layer, calculated using cached values of h...
Definition Cluster.cc:37

pandora::Cluster::GetElectromagneticEnergy
float GetElectromagneticEnergy() const
Get the sum of electromagnetic energy measures of all constituent calo hits, units GeV.
Definition Cluster.h:519

pandora::Cluster::GetOrderedCaloHitList
const OrderedCaloHitList & GetOrderedCaloHitList() const
Get the ordered calo hit list.
Definition Cluster.h:470

pandora::Cluster::m_sumXYZByPseudoLayer
PointByPseudoLayerMap m_sumXYZByPseudoLayer
Construct to allow rapid calculation of centroid in each pseudolayer.
Definition Cluster.h:440

pandora::Cluster::m_passPhotonId
InputBool m_passPhotonId
Whether the cluster passes the photon id.
Definition Cluster.h:451

pandora::Cluster::AddTrackAssociation
StatusCode AddTrackAssociation(const Track *const pTrack)
Add an association between the cluster and a track.
Definition Cluster.cc:666

pandora::Cluster::RemoveIsolatedCaloHit
StatusCode RemoveIsolatedCaloHit(const CaloHit *const pCaloHit)
Remove an isolated calo hit from the cluster.
Definition Cluster.cc:409

pandora::Cluster::m_correctedHadronicEnergy
InputFloat m_correctedHadronicEnergy
The corrected hadronic estimate of the cluster energy, units GeV.
Definition Cluster.h:449

pandora::Cluster::UpdateShowerLayerCache
void UpdateShowerLayerCache(const Pandora &pandora) const
Update the pseudo layer at which shower commences.
Definition Cluster.cc:534

pandora::Cluster::GetOuterLayerHitType
HitType GetOuterLayerHitType() const
Get the typical outer layer hit type.
Definition Cluster.cc:86

pandora::Cluster::m_electromagneticEnergy
double m_electromagneticEnergy
The sum of electromagnetic energy measures of constituent calo hits, units GeV.
Definition Cluster.h:434

pandora::Cluster::m_associatedTrackList
TrackList m_associatedTrackList
The list of tracks associated with the cluster.
Definition Cluster.h:460

pandora::Cluster::AddCaloHit
StatusCode AddCaloHit(const CaloHit *const pCaloHit)
Add a calo hit to the cluster.
Definition Cluster.cc:288

pandora::Cluster::m_outerLayerHitType
InputHitType m_outerLayerHitType
The typical outer layer hit type.
Definition Cluster.h:456

pandora::Cluster::m_initialDirection
CartesianVector m_initialDirection
The initial direction of the cluster.
Definition Cluster.h:444

pandora::Cluster::RemoveTrackSeed
void RemoveTrackSeed()
Remove the track seed, changing the initial direction measurement.
Definition Cluster.cc:693

pandora::Cluster::m_innerLayerHitType
InputHitType m_innerLayerHitType
The typical inner layer hit type.
Definition Cluster.h:455

pandora::Cluster::GetTrackComparisonEnergy
float GetTrackComparisonEnergy(const Pandora &pandora) const
Get the best energy estimate to use when comparing cluster energy to associated track momentum,...
Definition Cluster.cc:116

pandora::Cluster::Cluster
Cluster(const object_creation::Cluster::Parameters &parameters)
Constructor.
Definition Cluster.cc:232

pandora::Cluster::RemoveTrackAssociation
StatusCode RemoveTrackAssociation(const Track *const pTrack)
Remove an association between the cluster and a track.
Definition Cluster.cc:680

pandora::Cluster::GetInnerLayerHitType
HitType GetInnerLayerHitType() const
Get the typical inner layer hit type.
Definition Cluster.cc:76

pandora::Cluster::UpdateEnergyCorrectionsCache
void UpdateEnergyCorrectionsCache(const Pandora &pandora) const
Update cluster corrected energy values.
Definition Cluster.cc:497

pandora::Cluster::GetCorrectedHadronicEnergy
float GetCorrectedHadronicEnergy(const Pandora &pandora) const
Get the corrected hadronic estimate of the cluster energy, units GeV.
Definition Cluster.cc:106

pandora::Cluster::GetFitToAllHitsResult
const ClusterFitResult & GetFitToAllHitsResult() const
Get the result of a linear fit to all calo hits in the cluster.
Definition Cluster.cc:66

pandora::Cluster::GetTrackSeed
const Track * GetTrackSeed() const
Get the address of the track with which the cluster is seeded.
Definition Cluster.cc:27

pandora::Cluster::GetIsolatedCaloHitList
const CaloHitList & GetIsolatedCaloHitList() const
Get the isolated calo hit list.
Definition Cluster.h:477

pandora::Cluster::AddIsolatedCaloHit
StatusCode AddIsolatedCaloHit(const CaloHit *const pCaloHit)
Add an isolated calo hit to the cluster.
Definition Cluster.cc:390

pandora::Cluster::ResetProperties
StatusCode ResetProperties()
Reset all cluster properties.
Definition Cluster.cc:560

pandora::Cluster::GetClusterSpanX
void GetClusterSpanX(float &xmin, float &xmax) const
Get minimum and maximum X positions of the calo hits in this cluster.
Definition Cluster.cc:169

pandora::Cluster::m_nCaloHits
unsigned int m_nCaloHits
The number of calo hits.
Definition Cluster.h:431

pandora::Cluster::GetClusterSpanZ
void GetClusterSpanZ(const float xmin, const float xmax, float &zmin, float &zmax) const
Get upper and lower Z positions of the calo hits in a cluster in range xmin to xmax.
Definition Cluster.cc:198

pandora::Cluster::m_trackComparisonEnergy
InputFloat m_trackComparisonEnergy
The appropriate corrected energy to use in comparisons with track momentum, units GeV.
Definition Cluster.h:450

pandora::Cluster::GetShowerProfileDiscrepancy
float GetShowerProfileDiscrepancy(const Pandora &pandora) const
Get the cluster shower profile discrepancy.
Definition Cluster.cc:159

pandora::Cluster::m_outerPseudoLayer
InputUInt m_outerPseudoLayer
The outermost pseudo layer in the cluster.
Definition Cluster.h:442

pandora::Cluster::ResetOutdatedProperties
void ResetOutdatedProperties()
Reset those cluster properties that must be recalculated upon addition/removal of a calo hit.
Definition Cluster.cc:587

pandora::Cluster::m_xMax
InputFloat m_xMax
Cached cluster maximum in x.
Definition Cluster.h:458

pandora::Cluster::m_nPossibleMipHits
unsigned int m_nPossibleMipHits
The number of calo hits that have been flagged as possible mip hits.
Definition Cluster.h:432

pandora::Cluster::m_isolatedHadronicEnergy
double m_isolatedHadronicEnergy
Sum of hadronic energy measures of isolated calo hits, units GeV.
Definition Cluster.h:437

pandora::Cluster::UpdateInitialDirectionCache
void UpdateInitialDirectionCache() const
Update cluster initial direction.
Definition Cluster.cc:439

pandora::Cluster::m_fitToAllHitsResult
ClusterFitResult m_fitToAllHitsResult
The result of a linear fit to all calo hits in the cluster.
Definition Cluster.h:446

pandora::Cluster::GetShowerStartLayer
unsigned int GetShowerStartLayer(const Pandora &pandora) const
Get the pseudo layer at which shower commences.
Definition Cluster.cc:139

pandora::Cluster::UpdateLayerHitTypeCache
void UpdateLayerHitTypeCache(const unsigned int pseudoLayer, InputHitType &layerHitType) const
Update typical hit type for specified layer.
Definition Cluster.cc:460

pandora::Cluster::m_showerProfileDiscrepancy
InputFloat m_showerProfileDiscrepancy
The cluster shower profile discrepancy.
Definition Cluster.h:454

pandora::Cluster::m_orderedCaloHitList
OrderedCaloHitList m_orderedCaloHitList
The ordered calo hit list.
Definition Cluster.h:429

pandora::Cluster::RemoveCaloHit
StatusCode RemoveCaloHit(const CaloHit *const pCaloHit)
Remove a calo hit from the cluster.
Definition Cluster.cc:340

pandora::Cluster::m_showerStartLayer
InputUInt m_showerStartLayer
The pseudo layer at which shower commences.
Definition Cluster.h:452

pandora::Cluster::SimplePoint
SimplePoint class.
Definition Cluster.h:420

pandora::EnergyCorrections
EnergyCorrections class.
Definition EnergyCorrectionsPlugin.h:46

pandora::EnergyCorrections::MakeEnergyCorrections
StatusCode MakeEnergyCorrections(const Cluster *const pCluster, float &correctedElectromagneticEnergy, float &correctedHadronicEnergy) const
Make an ordered list of energy corrections to a cluster.
Definition EnergyCorrectionsPlugin.cc:18

pandora::OrderedCaloHitList
Calo hit lists arranged by pseudo layer.
Definition OrderedCaloHitList.h:25

pandora::OrderedCaloHitList::end
const_iterator end() const
Returns a const iterator referring to the past-the-end element in the ordered calo hit list.
Definition OrderedCaloHitList.h:197

pandora::OrderedCaloHitList::begin
const_iterator begin() const
Returns a const iterator referring to the first element in the ordered calo hit list.
Definition OrderedCaloHitList.h:190

pandora::OrderedCaloHitList::Reset
void Reset()
Reset the ordered calo hit list, emptying its contents.
Definition OrderedCaloHitList.cc:118

pandora::OrderedCaloHitList::Remove
StatusCode Remove(const OrderedCaloHitList &rhs)
Remove the hits in a second ordered calo hit list from this list.
Definition OrderedCaloHitList.cc:53

pandora::OrderedCaloHitList::const_iterator
TheList::const_iterator const_iterator
Definition OrderedCaloHitList.h:29

pandora::OrderedCaloHitList::rbegin
const_reverse_iterator rbegin() const
Returns a const reverse iterator referring to the first element in the ordered calo hit list.
Definition OrderedCaloHitList.h:211

pandora::OrderedCaloHitList::Add
StatusCode Add(const OrderedCaloHitList &rhs)
Add the hits from a second ordered calo hit list to this list.
Definition OrderedCaloHitList.cc:38

pandora::OrderedCaloHitList::empty
bool empty() const
Returns whether the map container is empty (i.e. whether its size is 0)
Definition OrderedCaloHitList.h:231

pandora::OrderedCaloHitList::find
const_iterator find(const unsigned int index) const
Searches the container for an element with specified layer and returns an iterator to it if found,...
Definition OrderedCaloHitList.h:204

pandora::OrderedCaloHitList::value_type
TheList::value_type value_type
Definition OrderedCaloHitList.h:28

pandora::Pandora
Pandora class.
Definition Pandora.h:40

pandora::PandoraInputType< HitType >

pandora::PandoraInputType::Set
void Set(const T &t)
Set the value held by the pandora type.
Definition PandoraInputTypes.h:175

pandora::PandoraInputType::Reset
void Reset()
Reset the pandora type.
Definition PandoraInputTypes.h:201

pandora::PandoraInputType::IsInitialized
bool IsInitialized() const
Whether the pandora type is initialized.
Definition PandoraInputTypes.h:213

pandora::PandoraInputType::Get
const T & Get() const
Get the value held by the pandora type.
Definition PandoraInputTypes.h:190

pandora::ParticleId
ParticleId class.
Definition ParticleIdPlugin.h:51

pandora::ParticleId::IsEmShower
bool IsEmShower(const T *const pT) const
Provide identification of whether a cluster or pfo is an electromagnetic shower.
Definition ParticleIdPlugin.cc:24

pandora::ShowerProfilePlugin
ShowerProfilePlugin class.
Definition ShowerProfilePlugin.h:21

pandora::ShowerProfilePlugin::CalculateShowerStartLayer
virtual void CalculateShowerStartLayer(const Cluster *const pCluster, unsigned int &showerStartLayer) const =0
Get the layer at which shower can be considered to start; this function evaluates the the starting po...

pandora::ShowerProfilePlugin::CalculateLongitudinalProfile
virtual void CalculateLongitudinalProfile(const Cluster *const pCluster, float &profileStart, float &profileDiscrepancy) const =0
Calculate longitudinal shower profile for a cluster and compare it with the expected profile for a ph...

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

pandora::Track
Track class.
Definition Track.h:26

pandora
Definition LArContent.h:12

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

pandora::UNKNOWN_PARTICLE_TYPE
@ UNKNOWN_PARTICLE_TYPE
Definition PdgTable.h:103

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

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