LArPandoraGeometry.h

Go to the documentation of this file.

#ifndef LAR_PANDORA_GEOMETRY_H
#define LAR_PANDORA_GEOMETRY_H 1

#include <map>
#include <vector>

namespace lar_pandora
{

class LArDetectorGap
{
public:
    LArDetectorGap(const float x1, const float y1, const float z1, const float x2, const float y2, const float z2);

    float GetX1() const;

    float GetY1() const;

    float GetZ1() const;

    float GetX2() const;

    float GetY2() const;

    float GetZ2() const;

private:
    float   m_x1;
    float   m_y1;
    float   m_z1;
    float   m_x2;
    float   m_y2;
    float   m_z2;
};

typedef std::vector<LArDetectorGap> LArDetectorGapList;

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

class LArDaughterDriftVolume
{
public:
    LArDaughterDriftVolume(const unsigned int cryostat, const unsigned int tpc);

    unsigned int GetCryostat() const;

    unsigned int GetTpc() const;

private:
    unsigned int  m_cryostat;
    unsigned int  m_tpc;
};

typedef std::vector<LArDaughterDriftVolume> LArDaughterDriftVolumeList;

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

class LArDriftVolume
{
public:
    LArDriftVolume(const unsigned int volumeID, const bool isPositiveDrift,
        const float wirePitchU, const float wirePitchV, const float wirePitchW, const float wireAngleU, const float wireAngleV, const float wireAngleW,
        const float centerX, const float centerY, const float centerZ, const float widthX, const float widthY, const float widthZ,
        const float sigmaUVZ, const LArDaughterDriftVolumeList &tpcVolumeList);

    unsigned int GetVolumeID() const;

    bool IsPositiveDrift() const;

    float GetWirePitchU() const;

    float GetWirePitchV() const;

    float GetWirePitchW() const;

    float GetWireAngleU() const;

    float GetWireAngleV() const;

    float GetWireAngleW() const;

    float GetCenterX() const;

    float GetCenterY() const;

    float GetCenterZ() const;

    float GetWidthX() const;

    float GetWidthY() const;

    float GetWidthZ() const;

    float GetSigmaUVZ() const;

    const LArDaughterDriftVolumeList &GetTpcVolumeList() const;

private:
    unsigned int    m_volumeID;
    bool            m_isPositiveDrift;
    float           m_wirePitchU;
    float           m_wirePitchV;
    float           m_wirePitchW;
    float           m_wireAngleU;
    float           m_wireAngleV;
    float           m_wireAngleW;
    float           m_centerX;
    float           m_centerY;
    float           m_centerZ;
    float           m_widthX;
    float           m_widthY;
    float           m_widthZ;
    float           m_sigmaUVZ;

    LArDaughterDriftVolumeList m_tpcVolumeList;
};

typedef std::vector<LArDriftVolume> LArDriftVolumeList;
typedef std::map<unsigned int, LArDriftVolume> LArDriftVolumeMap;

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

class LArPandoraGeometry
{
public:
    static void LoadDetectorGaps(LArDetectorGapList &listOfGaps);

    static void LoadGeometry(LArDriftVolumeList &outputVolumeList, LArDriftVolumeMap &outputVolumeMap);

    static unsigned int GetVolumeID(const LArDriftVolumeMap &driftVolumeMap, const unsigned int cstat, const unsigned int tpc);

    static geo::View_t GetGlobalView(const unsigned int cstat, const unsigned int tpc, const geo::View_t hit_View);

private:
    static unsigned int GetTpcID(const unsigned int cstat, const unsigned int tpc);

    static bool ShouldSwitchUV(const unsigned int cstat, const unsigned int tpc);

    static bool ShouldSwitchUV(const bool isPositiveDrift);

    static void LoadGeometry(LArDriftVolumeList &driftVolumeList);

    static void LoadGlobalDaughterGeometry(const LArDriftVolumeList &driftVolumeList, LArDriftVolumeList &daughterVolumeList);
};

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

inline LArDetectorGap::LArDetectorGap(const float x1, const float y1, const float z1, const float x2, const float y2, const float z2) :
    m_x1(x1), m_y1(y1), m_z1(z1), m_x2(x2), m_y2(y2), m_z2(z2)
{
}

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

inline float LArDetectorGap::GetX1() const
{
    return m_x1;
}

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

inline float LArDetectorGap::GetY1() const
{
    return m_y1;
}

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

inline float LArDetectorGap::GetZ1() const
{
    return m_z1;
}

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

inline float LArDetectorGap::GetX2() const
{
    return m_x2;
}

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

inline float LArDetectorGap::GetY2() const
{
    return m_y2;
}

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

inline float LArDetectorGap::GetZ2() const
{
    return m_z2;
}

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

inline LArDaughterDriftVolume::LArDaughterDriftVolume(const unsigned int cryostat, const unsigned int tpc) :
    m_cryostat(cryostat), m_tpc(tpc)
{
}

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

inline unsigned int LArDaughterDriftVolume::GetCryostat() const
{
    return m_cryostat;
}

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

inline unsigned int LArDaughterDriftVolume::GetTpc() const
{
    return m_tpc;
}

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

inline unsigned int LArDriftVolume::GetVolumeID() const
{
    return m_volumeID;
}

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

inline bool LArDriftVolume::IsPositiveDrift() const
{
    return m_isPositiveDrift;
}

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

inline float LArDriftVolume::GetWirePitchU() const
{
    return m_wirePitchU;
}

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

inline float LArDriftVolume::GetWirePitchV() const
{
    return m_wirePitchV;
}

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

inline float LArDriftVolume::GetWirePitchW() const
{
    return m_wirePitchW;
}

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

inline float LArDriftVolume::GetWireAngleU() const
{
    return m_wireAngleU;
}

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

inline float LArDriftVolume::GetWireAngleV() const
{
    return m_wireAngleV;
}

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

inline float LArDriftVolume::GetWireAngleW() const
{
    return m_wireAngleW;
}

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

inline float LArDriftVolume::GetCenterX() const
{
    return m_centerX;
}

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

inline float LArDriftVolume::GetCenterY() const
{
    return m_centerY;
}

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

inline float LArDriftVolume::GetCenterZ() const
{
    return m_centerZ;
}

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

inline float LArDriftVolume::GetWidthX() const
{
    return m_widthX;
}

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

inline float LArDriftVolume::GetWidthY() const
{
    return m_widthY;
}

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

inline float LArDriftVolume::GetWidthZ() const
{
    return m_widthZ;
}

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

inline float LArDriftVolume::GetSigmaUVZ() const
{
    return m_sigmaUVZ;
}

} // namespace lar_pandora

#endif // #ifndef LAR_PANDORA_GEOMETRY_H