PlaneGeo.h

Go to the documentation of this file.

////////////////////////////////////////////////////////////////////////
/// \file  Plane.h
/// \brief Encapsulate the construction of a single detector plane
///
/// \version $Id: PlaneGeo.h,v 1.5 2012-11-28 03:25:00 gsdavies Exp $
/// \author  messier@indiana.edu
////////////////////////////////////////////////////////////////////////
#ifndef GEO_PLANEGEO_H
#define GEO_PLANEGEO_H

#include <vector>
class TGeoNode;
class TGeoVolume;
class TGeoHMatrix;
class TGeoCombiTrans;

namespace geo {
  class CellGeo;
  /// Enumerate the possible locations of the cell readout
  typedef enum _readout {
    kTop,    ///< Vertical modules readout on the top
    kWest,   ///< Horizontal modules readout on the west
    kEast,   ///< Horizontal modules readout on the east
    kAnySide ///< Don't care which side the read out is on
  } Readout_t;
  /// Enumerate the possible plane projections
  typedef enum _plane_proj {
    kX,   ///< Vertical planes which measure X
    kY,   ///< Horizontal planes which measure Y
    kXorY ///< X or Y views
  } View_t;

  //......................................................................

  /// Geometry information for a single readout plane
  class PlaneGeo {
  public:
    /// Construct a representation of a single plane of the detector
    PlaneGeo(std::vector<const TGeoNode*>& n, unsigned int depth);
    ~PlaneGeo();

    /// Number of cells in this plane
    unsigned int Ncells() const { return fCell.size(); }

    /// Return the icell'th cell in the plane. Should start from
    /// bottom and count up in case of horizontals. Should count from
    /// west to east in case of verticals
    const CellGeo* Cell(int icell) const {
      if (icell < 0 || icell >= (int)fCell.size()) return 0;
      return fCell[icell]; }

    /// Which coordinate does this plane measure
    View_t View() const { return fView; }

    /// Transform point from local plane frame to world frame
    void LocalToWorld(const double* plane, double* world) const;

    /// Transform direction vector from local to world
    void LocalToWorldVect(const double* plane, double* world) const;

    /// Transform point from world frame to local plane frame
    void WorldToLocal(const double* world, double* plane) const;

    /// Transform direction vector from world to local
    void WorldToLocalVect(const double* world, double* plane) const;

    /// Translate plane and all cells in plane by dx, dy and dz
    /// Original transform will be stored in a separate TGeoHMatrix
    void TranslatePlane(double dx, double dy = 0, double dz = 0, 
                        double phi = 0, double theta= 0, double psi = 0);

    /// Translate plane using a previously defined TGeoCombiTrans
    /// Original transform will be stored in a separate TGeoHMatrix
    void TranslatePlane(TGeoCombiTrans* comb);

    /// Restore geometry to original
    void RestoreOriginal();

  private:
    void FindCells(std::vector<const TGeoNode*>& n, unsigned int depth);
    void MakeCell(std::vector<const TGeoNode*>& n, unsigned int depth);

  private:
    TGeoHMatrix*          fGeoMatrix;         ///< Plane to world transform
    TGeoHMatrix*          fGeoMatrixOriginal; ///< Original plane to world transform
    bool                  fIsOriginal;        ///< Is fGeoMatrix the original transform?
    Readout_t             fReadout;           ///< Which end is the readout on?
    View_t                fView;              ///< Does this plane measure X or Y?
    std::vector<CellGeo*> fCell;              ///< List of cells in this plane
  };
}

#endif
////////////////////////////////////////////////////////////////////////