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 &startDirection);
 
    const pandora::CartesianVector &GetStartPosition() const;
 
    const pandora::CartesianVector &GetStartDirection() const;
 
private:
    pandora::CartesianVector m_startPosition;  
    pandora::CartesianVector m_startDirection; 
};
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline ShowerCore::ShowerCore(const pandora::CartesianVector &startPosition, const pandora::CartesianVector &startDirection) :
    m_startPosition(startPosition),
    m_startDirection(startDirection)
{
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline ShowerCore::ShowerCore() : m_startPosition(0.f, 0.f, 0.f), m_startDirection(0.f, 0.f, 0.f)
{
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline const pandora::CartesianVector &ShowerCore::GetStartPosition() const
{
    return m_startPosition;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline const pandora::CartesianVector &ShowerCore::GetStartDirection() const
{
    return m_startDirection;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------------------------------------------
 
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(), protoShower.GetShowerCore().GetStartDirection())),
    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