LArProtoShower.h

Go to the documentation of this file.

#ifndef LAR_PROTO_SHOWER_H
#define LAR_PROTO_SHOWER_H 1

#include "Pandora/PandoraInternal.h"

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

namespace lar_content
{

class ShowerCore
{
public:
    ShowerCore();

    ShowerCore(const pandora::CartesianVector &startPosition);

    const pandora::CartesianVector &GetStartPosition() const;

private:
    pandora::CartesianVector m_startPosition; 
};

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

inline ShowerCore::ShowerCore(const pandora::CartesianVector &startPosition) :
    m_startPosition(startPosition)
{
}

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

inline ShowerCore::ShowerCore() :
    m_startPosition(0.f, 0.f, 0.f)
{
}

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

inline const pandora::CartesianVector &ShowerCore::GetStartPosition() const
{
    return m_startPosition;
}

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

class ConnectionPathway
{
public:
    ConnectionPathway();

    ConnectionPathway(const pandora::CartesianVector &startPosition, const pandora::CartesianVector &startDirection);

    const pandora::CartesianVector &GetStartPosition() const;

    const pandora::CartesianVector &GetStartDirection() const;

private:
    pandora::CartesianVector m_startPosition;  
    pandora::CartesianVector m_startDirection; 
};

typedef std::vector<ConnectionPathway> ConnectionPathwayVector;

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

inline ConnectionPathway::ConnectionPathway(const pandora::CartesianVector &startPosition, const pandora::CartesianVector &startDirection) :
    m_startPosition(startPosition),
    m_startDirection(startDirection)
{
}

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

inline ConnectionPathway::ConnectionPathway() :
    m_startPosition(0.f, 0.f, 0.f),
    m_startDirection(0.f, 0.f, 0.f)
{
}

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

inline const pandora::CartesianVector &ConnectionPathway::GetStartPosition() const
{
    return m_startPosition;
}

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

inline const pandora::CartesianVector &ConnectionPathway::GetStartDirection() const
{
    return m_startDirection;
}

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

class ProtoShower
{
public:
    ProtoShower(const ShowerCore &showerCore, const ConnectionPathway &connectionPathway, const pandora::CaloHitList &spineHitList,
        const pandora::CaloHitList &ambiguousHitList, const pandora::CartesianPointVector &ambiguousDirectionVector,
        const pandora::CaloHitList &hitsToAdd);

    ProtoShower(const ProtoShower &protoShower);

    const ShowerCore &GetShowerCore() const;

    const ConnectionPathway &GetConnectionPathway() const;

    const pandora::CaloHitList &GetSpineHitList() const;

    const pandora::CaloHitList &GetAmbiguousHitList() const;

    void AddAmbiguousHit(const pandora::CaloHit *const ambiguousHit);

    const pandora::CartesianPointVector &GetAmbiguousDirectionVector() const;

    void AddAmbiguousDirection(const pandora::CartesianVector &ambiguousDirection);

    const pandora::CaloHitList &GetHitsToAddList() const;

    void SetHitsToAddList(const pandora::CaloHitList &hitsToAddList);

    void AddHitToAdd(const pandora::CaloHit *const hitToAdd);

private:
    const ShowerCore m_showerCore;                            
    const ConnectionPathway m_connectionPathway;              
    pandora::CaloHitList m_spineHitList;                      
    pandora::CaloHitList m_ambiguousHitList;                  
    pandora::CartesianPointVector m_ambiguousDirectionVector; 
    pandora::CaloHitList m_hitsToAdd;                         
};

typedef std::vector<ProtoShower> ProtoShowerVector;

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

inline ProtoShower::ProtoShower(const ShowerCore &showerCore, const ConnectionPathway &connectionPathway,
    const pandora::CaloHitList &spineHitList, const pandora::CaloHitList &ambiguousHitList,
    const pandora::CartesianPointVector &ambiguousDirectionVector, const pandora::CaloHitList &hitsToAdd) :
    m_showerCore(showerCore),
    m_connectionPathway(connectionPathway),
    m_spineHitList(spineHitList),
    m_ambiguousHitList(ambiguousHitList),
    m_ambiguousDirectionVector(ambiguousDirectionVector),
    m_hitsToAdd(hitsToAdd)
{
}

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

inline ProtoShower::ProtoShower(const ProtoShower &protoShower) :
    m_showerCore(ShowerCore(protoShower.GetShowerCore().GetStartPosition())),
    m_connectionPathway(
        ConnectionPathway(protoShower.GetConnectionPathway().GetStartPosition(), protoShower.GetConnectionPathway().GetStartDirection())),
    m_spineHitList(protoShower.GetSpineHitList()),
    m_ambiguousHitList(protoShower.GetAmbiguousHitList()),
    m_ambiguousDirectionVector(protoShower.GetAmbiguousDirectionVector()),
    m_hitsToAdd(protoShower.GetHitsToAddList())
{
}

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

inline const ShowerCore &ProtoShower::GetShowerCore() const
{
    return m_showerCore;
}

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

inline const ConnectionPathway &ProtoShower::GetConnectionPathway() const
{
    return m_connectionPathway;
}

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

inline const pandora::CaloHitList &ProtoShower::GetSpineHitList() const
{
    return m_spineHitList;
}

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

inline const pandora::CaloHitList &ProtoShower::GetAmbiguousHitList() const
{
    return m_ambiguousHitList;
}

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

inline void ProtoShower::AddAmbiguousHit(const pandora::CaloHit *const ambiguousHit)
{
    m_ambiguousHitList.push_back(ambiguousHit);
}

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

inline const pandora::CartesianPointVector &ProtoShower::GetAmbiguousDirectionVector() const
{
    return m_ambiguousDirectionVector;
}

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

inline void ProtoShower::AddAmbiguousDirection(const pandora::CartesianVector &ambiguousDirection)
{
    m_ambiguousDirectionVector.push_back(ambiguousDirection);
}

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

inline const pandora::CaloHitList &ProtoShower::GetHitsToAddList() const
{
    return m_hitsToAdd;
}

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

inline void ProtoShower::SetHitsToAddList(const pandora::CaloHitList &hitsToAddList)
{
    m_hitsToAdd = hitsToAddList;
}

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

inline void ProtoShower::AddHitToAdd(const pandora::CaloHit *const hitToAdd)
{
    m_hitsToAdd.push_back(hitToAdd);
}

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

enum Consistency
{
    POSITION,
    DIRECTION,
    X_PROJECTION
};

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

class ProtoShowerMatch
{
public:
    ProtoShowerMatch();

    ProtoShowerMatch(const ProtoShower &protoShowerU, const ProtoShower &protoShowerV, const ProtoShower &protoShowerW, const Consistency consistencyType);

    const ProtoShower &GetProtoShowerU() const;

    const ProtoShower &GetProtoShowerV() const;

    const ProtoShower &GetProtoShowerW() const;

    ProtoShower &GetProtoShowerToModify(const pandora::HitType hitType);

    const Consistency &GetConsistencyType() const;

private:
    ProtoShower m_protoShowerU;    
    ProtoShower m_protoShowerV;    
    ProtoShower m_protoShowerW;    
    Consistency m_consistencyType; 
};

typedef std::vector<ProtoShowerMatch> ProtoShowerMatchVector;

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

inline ProtoShowerMatch::ProtoShowerMatch(
    const ProtoShower &protoShowerU, const ProtoShower &protoShowerV, const ProtoShower &protoShowerW, const Consistency consistencyType) :
    m_protoShowerU(protoShowerU),
    m_protoShowerV(protoShowerV),
    m_protoShowerW(protoShowerW),
    m_consistencyType(consistencyType)
{
}

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

inline const ProtoShower &ProtoShowerMatch::GetProtoShowerU() const
{
    return m_protoShowerU;
}

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

inline const ProtoShower &ProtoShowerMatch::GetProtoShowerV() const
{
    return m_protoShowerV;
}

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

inline const ProtoShower &ProtoShowerMatch::GetProtoShowerW() const
{
    return m_protoShowerW;
}

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

inline ProtoShower &ProtoShowerMatch::GetProtoShowerToModify(const pandora::HitType hitType)
{
    return hitType == pandora::TPC_VIEW_U ? m_protoShowerU : (hitType == pandora::TPC_VIEW_V ? m_protoShowerV : m_protoShowerW);
}

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

inline const Consistency &ProtoShowerMatch::GetConsistencyType() const
{
    return m_consistencyType;
}

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

} // namespace lar_content

#endif // #ifndef LAR_PROTO_SHOWER_H