LArPandoraGeometryComponents.h

Go to the documentation of this file.

 
#ifndef LAR_PANDORA_GEOMETRY_COMPONENTS_H
#define LAR_PANDORA_GEOMETRY_COMPONENTS_H 1
 
#include "larcoreobj/SimpleTypesAndConstants/geo_types.h"
 
#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;
 
    static float GetMaxGapSize() noexcept;
 
  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,
                           const float centerX,
                           const float centerY,
                           const float centerZ,
                           const float widthX,
                           const float widthY,
                           const float widthZ);
 
    unsigned int GetCryostat() const;
 
    unsigned int GetTpc() const;
 
    float GetCenterX() const;
 
    float GetCenterY() const;
 
    float GetCenterZ() const;
 
    float GetWidthX() const;
 
    float GetWidthY() const;
 
    float GetWidthZ() const;
 
  private:
    unsigned int m_cryostat;
    unsigned int m_tpc;
    float m_centerX;
    float m_centerY;
    float m_centerZ;
    float m_widthX;
    float m_widthY;
    float m_widthZ;
  };
 
  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;
 
  //------------------------------------------------------------------------------------------------------------------------------------------
  //------------------------------------------------------------------------------------------------------------------------------------------
 
  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 float LArDetectorGap::GetMaxGapSize() noexcept
  {
    return 30.f; // TODO: 30cm should be fine but can we do better than a hard-coded number here?
  }
 
  //------------------------------------------------------------------------------------------------------------------------------------------
  //------------------------------------------------------------------------------------------------------------------------------------------
 
  inline LArDaughterDriftVolume::LArDaughterDriftVolume(const unsigned int cryostat,
                                                        const unsigned int tpc,
                                                        const float centerX,
                                                        const float centerY,
                                                        const float centerZ,
                                                        const float widthX,
                                                        const float widthY,
                                                        const float widthZ)
    : m_cryostat(cryostat)
    , m_tpc(tpc)
    , m_centerX(centerX)
    , m_centerY(centerY)
    , m_centerZ(centerZ)
    , m_widthX(widthX)
    , m_widthY(widthY)
    , m_widthZ(widthZ)
  {}
 
  //------------------------------------------------------------------------------------------------------------------------------------------
 
  inline unsigned int LArDaughterDriftVolume::GetCryostat() const { return m_cryostat; }
 
  //------------------------------------------------------------------------------------------------------------------------------------------
 
  inline unsigned int LArDaughterDriftVolume::GetTpc() const { return m_tpc; }
 
  //------------------------------------------------------------------------------------------------------------------------------------------
 
  inline float LArDaughterDriftVolume::GetCenterX() const { return m_centerX; }
 
  //------------------------------------------------------------------------------------------------------------------------------------------
 
  inline float LArDaughterDriftVolume::GetCenterY() const { return m_centerY; }
 
  //------------------------------------------------------------------------------------------------------------------------------------------
 
  inline float LArDaughterDriftVolume::GetCenterZ() const { return m_centerZ; }
 
  //------------------------------------------------------------------------------------------------------------------------------------------
 
  inline float LArDaughterDriftVolume::GetWidthX() const { return m_widthX; }
 
  //------------------------------------------------------------------------------------------------------------------------------------------
 
  inline float LArDaughterDriftVolume::GetWidthY() const { return m_widthY; }
 
  //------------------------------------------------------------------------------------------------------------------------------------------
 
  inline float LArDaughterDriftVolume::GetWidthZ() const { return m_widthZ; }
 
  //------------------------------------------------------------------------------------------------------------------------------------------
  //------------------------------------------------------------------------------------------------------------------------------------------
 
  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; }
 
  //------------------------------------------------------------------------------------------------------------------------------------------
 
  inline const LArDaughterDriftVolumeList& LArDriftVolume::GetTpcVolumeList() const
  {
    return m_tpcVolumeList;
  }
 
} // namespace lar_pandora
 
#endif // #ifndef LAR_PANDORA_GEOMETRY_H