KDTreeLinkerToolsT.h

Go to the documentation of this file.

#ifndef LC_KD_TREE_LINKER_TOOLS_TEMPLATED_H
#define LC_KD_TREE_LINKER_TOOLS_TEMPLATED_H 1

#include "Api/PandoraContentApi.h"

#include "Objects/CaloHit.h"
#include "Objects/Track.h"
#include "Objects/CartesianVector.h"

#include "Pandora/PandoraInternal.h"

#include <array>

using namespace std;

namespace pandora { class Algorithm; }

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

namespace april_content
{

template<unsigned DIM>
class KDTreeBoxT
{
public:
    KDTreeBoxT();

    template<typename... Ts>
    KDTreeBoxT(Ts... dimargs);

    std::array<float, DIM>      dimmin;     
    std::array<float, DIM>      dimmax;     
};

typedef KDTreeBoxT<2> KDTreeBox;
typedef KDTreeBoxT<3> KDTreeCube;
typedef KDTreeBoxT<4> KDTreeTesseract;

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

template<typename DATA, unsigned DIM>
class KDTreeNodeInfoT
{
public:
    KDTreeNodeInfoT();

    template<typename... Ts>
    KDTreeNodeInfoT(const DATA &d, Ts... dimargs);

    DATA                        data;       
    std::array<float, DIM>      dims;       
};

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

template <typename DATA, unsigned DIM>
class KDTreeNodeT
{
public:
    KDTreeNodeT();

    void setAttributs(const KDTreeBoxT<DIM> &regionBox, const KDTreeNodeInfoT<DATA, DIM> &infoToStore);

    void setAttributs(const KDTreeBoxT<DIM> &regionBox);

    KDTreeNodeInfoT<DATA, DIM>  info;       
    KDTreeNodeT<DATA, DIM>     *left;       
    KDTreeNodeT<DATA, DIM>     *right;      
    KDTreeBoxT<DIM>             region;     
};

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

template<typename T> 
class kdtree_type_adaptor
{
public:
    static const pandora::CartesianVector &position(const T *const t);
};

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

std::pair<float,float> minmax(const float a, const float b);

template<typename T>
KDTreeCube fill_and_bound_3d_kd_tree(const MANAGED_CONTAINER<const T*> &points, std::vector<KDTreeNodeInfoT<const T*, 3> > &nodes);

template<typename T>
KDTreeCube fill_and_bound_3d_kd_tree_by_index(const std::vector<const T*> &points, std::vector<KDTreeNodeInfoT<unsigned, 3> > &nodes);

template<typename T>
KDTreeCube fill_and_bound_3d_kd_tree(const pandora::Algorithm *const caller, const MANAGED_CONTAINER<const T*> &points,
    std::vector<KDTreeNodeInfoT<const T*, 3> > &nodes, bool passthru = false);

KDTreeTesseract fill_and_bound_4d_kd_tree(const pandora::Algorithm *const caller, const MANAGED_CONTAINER<const pandora::CaloHit*> &points,
    std::vector<KDTreeNodeInfoT<const pandora::CaloHit*, 4> > &nodes, bool passthru = false);

KDTreeCube build_3d_kd_search_region(const pandora::CaloHit *const point, const float x_span, const float y_span, const float z_span);

KDTreeTesseract build_4d_kd_search_region(const pandora::CaloHit *const point, const float x_span, const float y_span, const float z_span, const float search_layer);

KDTreeTesseract build_4d_kd_search_region(const pandora::CartesianVector &pos, const float x_span, const float y_span, const float z_span, const float search_layer);

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

template<unsigned DIM>
inline KDTreeBoxT<DIM>::KDTreeBoxT()
{
}

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

template<unsigned DIM>
template<typename... Ts>
inline KDTreeBoxT<DIM>::KDTreeBoxT(Ts... dimargs)
{
    static_assert(sizeof...(dimargs) == 2 * DIM, "Constructor requires 2*DIM args");
    std::vector<float> dims = {dimargs...};

    for (unsigned i = 0; i < DIM; ++i)
    {
        dimmin[i] = dims[2 * i];
        dimmax[i] = dims[2 * i + 1];
    }
}

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

template<typename DATA, unsigned DIM>
inline KDTreeNodeInfoT<DATA, DIM>::KDTreeNodeInfoT() :
    data()
{
}

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

template<typename DATA, unsigned DIM>
template<typename... Ts>
inline KDTreeNodeInfoT<DATA, DIM>::KDTreeNodeInfoT(const DATA &d, Ts... dimargs) : 
    data(d),
    dims{ {dimargs...} }
{
}

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

template <typename DATA, unsigned DIM>
inline KDTreeNodeT<DATA, DIM>::KDTreeNodeT() :
    left(nullptr),
    right(nullptr)
{
}

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

template <typename DATA, unsigned DIM>
inline void KDTreeNodeT<DATA, DIM>::setAttributs(const KDTreeBoxT<DIM> &regionBox, const KDTreeNodeInfoT<DATA, DIM> &infoToStore)
{
    info = infoToStore;
    region = regionBox;
}

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

template <typename DATA, unsigned DIM>
inline void KDTreeNodeT<DATA, DIM>::setAttributs(const KDTreeBoxT<DIM> &regionBox) 
{
    region = regionBox;
}

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

template<>
inline const pandora::CartesianVector &kdtree_type_adaptor<const pandora::Track>::position(const pandora::Track *const t)
{
    return t->GetTrackStateAtCalorimeter().GetPosition();
}

template<>
inline const pandora::CartesianVector &kdtree_type_adaptor<const pandora::CaloHit>::position(const pandora::CaloHit *const t)
{
    return t->GetPositionVector(); 
}

template<>
inline const pandora::CartesianVector &kdtree_type_adaptor<const pandora::CartesianVector>::position(const pandora::CartesianVector *const t)
{
    return *t;
}

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

template<typename T>
KDTreeCube fill_and_bound_3d_kd_tree(const MANAGED_CONTAINER<const T*> &points, std::vector<KDTreeNodeInfoT<const T*, 3> > &nodes)
{
    std::array<float, 3> minpos{ {0.f, 0.f, 0.f} }, maxpos{ {0.f, 0.f, 0.f} };

    unsigned i = 0;

    for (const T *const point : points)
    {
        const pandora::CartesianVector &pos = kdtree_type_adaptor<const T>::position(point);
        nodes.emplace_back(point, pos.GetX(), pos.GetY(), pos.GetZ());

        if (0 == i)
        {
            minpos[0] = pos.GetX(); minpos[1] = pos.GetY(); minpos[2] = pos.GetZ();
            maxpos[0] = pos.GetX(); maxpos[1] = pos.GetY(); maxpos[2] = pos.GetZ();
        }
        else
        {
            minpos[0] = std::min(pos.GetX(), minpos[0]);
            minpos[1] = std::min(pos.GetY(), minpos[1]);
            minpos[2] = std::min(pos.GetZ(), minpos[2]);
            maxpos[0] = std::max(pos.GetX(), maxpos[0]);
            maxpos[1] = std::max(pos.GetY(), maxpos[1]);
            maxpos[2] = std::max(pos.GetZ(), maxpos[2]);
        }

        ++i;
    }

    return KDTreeCube(minpos[0], maxpos[0], minpos[1], maxpos[1], minpos[2], maxpos[2]);
}

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

template<typename T>
KDTreeCube fill_and_bound_3d_kd_tree_by_index(const std::vector<const T*> &points, std::vector<KDTreeNodeInfoT<unsigned, 3> > &nodes)
{
    std::array<float, 3> minpos{ {0.f, 0.f, 0.f} }, maxpos{ {0.f, 0.f, 0.f} };

    unsigned i = 0;

    for (const T *const point : points)
    {
        const pandora::CartesianVector &pos = kdtree_type_adaptor<const T>::position(point);
        nodes.emplace_back(i, pos.GetX(), pos.GetY(), pos.GetZ());

        if (0 == i)
        {
            minpos[0] = pos.GetX(); minpos[1] = pos.GetY(); minpos[2] = pos.GetZ();
            maxpos[0] = pos.GetX(); maxpos[1] = pos.GetY(); maxpos[2] = pos.GetZ();
        }
        else
        {
            minpos[0] = std::min(pos.GetX(), minpos[0]);
            minpos[1] = std::min(pos.GetY(), minpos[1]);
            minpos[2] = std::min(pos.GetZ(), minpos[2]);
            maxpos[0] = std::max(pos.GetX(), maxpos[0]);
            maxpos[1] = std::max(pos.GetY(), maxpos[1]);
            maxpos[2] = std::max(pos.GetZ(), maxpos[2]);
        }

        ++i;
    }

    return KDTreeCube(minpos[0], maxpos[0], minpos[1], maxpos[1], minpos[2], maxpos[2]);
}

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

template<typename T>
KDTreeCube fill_and_bound_3d_kd_tree(const pandora::Algorithm *const caller, const MANAGED_CONTAINER<const T*> &points,
    std::vector<KDTreeNodeInfoT<const T*, 3> > &nodes, bool passthru)
{
    std::array<float, 3> minpos{ {0.f, 0.f, 0.f} }, maxpos{ {0.f, 0.f, 0.f} };

    unsigned i = 0;

    for (const T *const point : points)
    {
        if (!passthru && !PandoraContentApi::IsAvailable(*caller, point))
            continue;

        const pandora::CartesianVector &pos = kdtree_type_adaptor<const T>::position(point);
        nodes.emplace_back(point, pos.GetX(), pos.GetY(), pos.GetZ());

        if (0 == i)
        {
            minpos[0] = pos.GetX(); minpos[1] = pos.GetY(); minpos[2] = pos.GetZ();
            maxpos[0] = pos.GetX(); maxpos[1] = pos.GetY(); maxpos[2] = pos.GetZ();
        }
        else
        {
            minpos[0] = std::min(pos.GetX(), minpos[0]);
            minpos[1] = std::min(pos.GetY(), minpos[1]);
            minpos[2] = std::min(pos.GetZ(), minpos[2]);
            maxpos[0] = std::max(pos.GetX(), maxpos[0]);
            maxpos[1] = std::max(pos.GetY(), maxpos[1]);
            maxpos[2] = std::max(pos.GetZ(), maxpos[2]);
        }

        ++i;
    }

    return KDTreeCube(minpos[0], maxpos[0], minpos[1], maxpos[1], minpos[2], maxpos[2]);
}

} // namespace lc_content

#endif // LC_KD_TREE_LINKER_TOOLS_TEMPLATED_H