Cell.h

//-----------------------------------------------------------------------------
// $Id$
//-----------------------------------------------------------------------------
// Filename : Cell.h
// Section  : TRG CDC
// Owner    : Yoshihito Iwasaki
// Email    : yoshihito.iwasaki@kek.jp
//-----------------------------------------------------------------------------
// Description : A class to represent a cell (a wire or a track segment) in CDC.
//-----------------------------------------------------------------------------
// $Log$
//-----------------------------------------------------------------------------
 
#ifndef TRGCDCCell_FLAG_
#define TRGCDCCell_FLAG_
 
#include "CLHEP/Geometry/Vector3D.h"
#include "CLHEP/Geometry/Point3D.h"
#include "trg/trg/Signal.h"
#include "trg/cdc/Layer.h"
 
#ifdef TRGCDC_SHORT_NAMES
#define TCCell TRGCDCCell
#endif
 
namespace Belle2 {
  typedef HepGeom::Point3D<double>  Point3D;
  typedef HepGeom::Vector3D<double>  Vector3D;
 
  class TRGCDC;
  class TRGCDCCellHit;
 
  class TRGCDCCell {
 
  public:
    TRGCDCCell(unsigned id,
               unsigned localId,
               const TRGCDCLayer& layer,
               const HepGeom::Point3D<double>& forwardPosition,
               const HepGeom::Point3D<double>& backwardPosition);
 
    virtual ~TRGCDCCell();
 
  public:// Selectors
 
    unsigned id(void) const;
 
    unsigned localId(void) const;
 
    unsigned layerId(void) const;
 
    unsigned localLayerId(void) const;
 
    unsigned superLayerId(void) const;
 
    unsigned axialStereoLayerId(void) const;
 
    unsigned axialStereoSuperLayerId(void) const;
 
    const TRGCDCLayer& layer(void) const;
 
    unsigned state(void) const;
 
    bool axial(void) const;
 
    bool stereo(void) const;
 
//     /// returns a pointer to a neighbor wire. This function is expensive.
//     virtual const TRGCDCCell * const neighbor(unsigned) const = 0;
 
    int localIdDifference(const TRGCDCCell&) const;
 
    virtual std::string name(void) const = 0;
 
    virtual void dump(const std::string& message = std::string(""),
                      const std::string& prefix = std::string("")) const;
 
    virtual const TRGSignal& signal(void) const = 0;
 
  public:// Geometry
 
    const HepGeom::Point3D<double>& forwardPosition(void) const;
 
    const HepGeom::Point3D<double>& backwardPosition(void) const;
    double* backwardPosition(double p[3]) const;
 
    const HepGeom::Point3D<double>& xyPosition(void) const;
    double* xyPosition(double p[3]) const;
 
    const Vector3D& direction(void) const;
 
//     void wirePosition(float zPosition,
//                       HepGeom::Point3D<double>  & xyPosition,
//                       HepGeom::Point3D<double>  & backwardPosition,
//                       Vector3D & direction) const;
 
    float cellSize(void) const;
 
  public:// Utility functions
 
    virtual bool hasMember(const std::string& a) const;
 
  public:// event by event information.
 
    const TRGCDCCellHit* hit(void) const;
 
  public:// Obsolete functions from Belle
 
    bool innerPart(void) const;
 
    bool mainPart(void) const;
 
  public:// Modifiers
 
    unsigned state(unsigned newState);
 
    virtual void clear(void);
 
    const TRGCDCCellHit* hit(const TRGCDCCellHit*);
 
  private:
 
    const unsigned _id;
 
    const unsigned _localId;
 
    const TRGCDCLayer& _layer;
 
    const HepGeom::Point3D<double> _xyPosition;
 
    const HepGeom::Point3D<double> _forwardPosition;
 
    const HepGeom::Point3D<double> _backwardPosition;
 
    const Vector3D _direction;
 
    unsigned _state;
 
    const TRGCDCCellHit* _hit;
 
    friend class TRGCDC;
  };
 
//-----------------------------------------------------------------------------
 
  inline
  unsigned
  TRGCDCCell::id(void) const
  {
    return _id;
  }
 
  inline
  unsigned
  TRGCDCCell::localId(void) const
  {
    return _localId;
  }
 
  inline
  unsigned
  TRGCDCCell::layerId(void) const
  {
    return _layer.id();
  }
 
  inline
  unsigned
  TRGCDCCell::superLayerId(void) const
  {
    return _layer.superLayerId();
  }
 
  inline
  unsigned
  TRGCDCCell::localLayerId(void) const
  {
    return _layer.localLayerId();
  }
 
  inline
  const TRGCDCLayer&
  TRGCDCCell::layer(void) const
  {
    return _layer;
  }
 
  inline
  unsigned
  TRGCDCCell::state(void) const
  {
    return _state;
  }
 
  inline
  unsigned
  TRGCDCCell::state(unsigned a)
  {
    return _state = a;
  }
 
  inline
  bool
  TRGCDCCell::axial(void) const
  {
    return _layer.axial();
  }
 
  inline
  bool
  TRGCDCCell::stereo(void) const
  {
    return _layer.stereo();
  }
 
  inline
  unsigned
  TRGCDCCell::axialStereoLayerId(void) const
  {
    return _layer.axialStereoLayerId();
  }
 
  inline
  unsigned
  TRGCDCCell::axialStereoSuperLayerId(void) const
  {
    return _layer.axialStereoSuperLayerId();
  }
 
  inline
  bool
  TRGCDCCell::innerPart(void) const
  {
    std::cout << "TRGCDCCell::innerPart ... position not defined" << std::endl;
    if (layerId() < 14) return true;
    return false;
  }
 
  inline
  bool
  TRGCDCCell::mainPart(void) const
  {
    std::cout << "TRGCDCCell::mainPart ... position not defined" << std::endl;
    if (layerId() > 13) return true;
    return false;
  }
 
  inline
  float
  TRGCDCCell::cellSize(void) const
  {
    return _layer.cellSize();
  }
 
  inline
  void
  TRGCDCCell::clear(void)
  {
    _state = 0;
    _hit = 0;
  }
 
  inline
  const HepGeom::Point3D<double>&
  TRGCDCCell::forwardPosition(void) const
  {
    return _forwardPosition;
  }
 
  inline
  const HepGeom::Point3D<double>&
  TRGCDCCell::backwardPosition(void) const
  {
    return _backwardPosition;
  }
 
  inline
  double*
  TRGCDCCell::backwardPosition(double p[3]) const
  {
    p[0] = _backwardPosition.x();
    p[1] = _backwardPosition.y();
    p[2] = _backwardPosition.z();
    return p;
  }
 
  inline
  const HepGeom::Point3D<double>&
  TRGCDCCell::xyPosition(void) const
  {
    return _xyPosition;
  }
 
  inline
  double*
  TRGCDCCell::xyPosition(double a[3]) const
  {
    a[0] = _xyPosition.x();
    a[1] = _xyPosition.y();
    a[2] = 0.;
    return a;
  }
 
  inline
  const Vector3D&
  TRGCDCCell::direction(void) const
  {
    return _direction;
  }
 
  inline
  const TRGCDCCellHit*
  TRGCDCCell::hit(void) const
  {
    return _hit;
  }
 
  inline
  const TRGCDCCellHit*
  TRGCDCCell::hit(const TRGCDCCellHit* a)
  {
    return _hit = a;
  }
 
  inline
  bool
  TRGCDCCell::hasMember(const std::string& a) const
  {
    return name() == a;
  }
 
} // namespace Belle2
 
#endif /* TRGCDCCell_FLAG_ */