Wire.h

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
 
//-----------------------------------------------------------------------------
// Description : A class to represent a wire in CDC.
//-----------------------------------------------------------------------------
 
#ifndef TRGCDCWire_FLAG_
#define TRGCDCWire_FLAG_
 
#include <vector>
#include "CLHEP/Geometry/Vector3D.h"
#include "CLHEP/Geometry/Point3D.h"
#include "trg/trg/Signal.h"
#include "trg/cdc/Cell.h"
#include "trg/cdc/Layer.h"
 
#ifdef TRGCDC_SHORT_NAMES
#define TCWire TRGCDCWire
#endif
 
namespace Belle2 {
  typedef HepGeom::Point3D<double> Point3D;
  typedef HepGeom::Vector3D<double> Vector3D;
#define WireInnerLeft 0
#define WireInnerRight 1
#define WireLeft 2
#define WireRight 3
#define WireOuterLeft 4
#define WireOuterRight 5
#define MaxNeighbors 6
 
  class TRGCDC;
  class TRGCDCWireHit;
  class TRGCDCWireHitMC;
  class TRGCDCTrackSegment;
 
  class TRGCDCWire : public TRGCDCCell {
 
  public:
    TRGCDCWire(unsigned id,
               unsigned localId,
               const TRGCDCLayer&,
               const HepGeom::Point3D<double>& forwardPosition,
               const HepGeom::Point3D<double>& backwardPosition,
               const TRGClock& clock);
 
    virtual ~TRGCDCWire();
 
  public:// Selectors
 
    const TRGCDCWireHit* hit(void) const;
 
//     /// returns a pointer to a TRGCDCTrackSegment.
//     const TRGCDCTrackSegment * const segment(void) const;
 
    const TRGCDCWire* neighbor(unsigned) const;
 
    bool consective(const TRGCDCWire&) const;
 
    bool adjacent(const TRGCDCWire&) const;
 
    int localIdForPlus(void) const;
 
    int localIdForMinus(void) const;
 
    std::string name(void) const override;
 
    void dump(const std::string& message = std::string(""),
              const std::string& prefix = std::string("")) const override;
 
  public:// Modifiers
 
    void clear(void) override;
 
    const TRGCDCWireHit* hit(const TRGCDCWireHit*);
 
    const TRGCDCWireHitMC* hit(TRGCDCWireHitMC*);
 
    void addSignal(const TRGSignal& newSignal);
 
    void addSignal_adc(const TRGSignal& newSignal);
 
  public:// TRG
 
    const TRGSignal& signal(void) const override;
 
    const TRGSignal& signal_adc(void) const override;
 
  private:
 
//  std::vector<const TRGCDCWireHitMC * const> _mcHits;
    std::vector<const TRGCDCWireHitMC*> _mcHits;
 
    mutable TRGSignal _signal;
 
    mutable TRGSignal _signal_adc;
 
    friend class TRGCDC;
  };
 
//-----------------------------------------------------------------------------
 
  inline
  const TRGCDCWireHit*
  TRGCDCWire::hit(const TRGCDCWireHit* h)
  {
    //TODO only this strong retyping work, is it OK?
    return reinterpret_cast<const TRGCDCWireHit*>(TRGCDCCell::hit(reinterpret_cast<const TRGCDCCellHit*>(h)));
  }
 
  inline
  const TRGCDCWireHit*
  TRGCDCWire::hit(void) const
  {
    //TODO only this strong retyping work, is it OK?
    return reinterpret_cast<const TRGCDCWireHit*>(TRGCDCCell::hit());
  }
 
  inline
  const TRGCDCWireHitMC*
  TRGCDCWire::hit(TRGCDCWireHitMC* const a)
  {
    _mcHits.push_back(a);
    return a;
  }
 
  inline
  void
  TRGCDCWire::addSignal(const TRGSignal& newSignal)
  {
    _signal |= newSignal;
  }
 
  inline
  void
  TRGCDCWire::addSignal_adc(const TRGSignal& newSignal)
  {
    _signal_adc |= newSignal;
  }
 
  inline
  bool
  TRGCDCWire::consective(const TRGCDCWire& w) const
  {
    if (neighbor(2) == & w) return true;
    else if (neighbor(3) == & w) return true;
    return false;
  }
 
  inline
  bool
  TRGCDCWire::adjacent(const TRGCDCWire& w) const
  {
    for (unsigned i = 0; i < 7; i++)
      if (neighbor(i) == & w)
        return true;
    return false;
  }
 
  inline
  int
  TRGCDCWire::localIdForPlus(void) const
  {
    //
    // used in curl finder
    //
    // new version by NK
    //
    //ho  const TCDCLayer &l = *layer();
    //ho  const int nw = l.nWires();
 
    const TRGCDCLayer& l = this->layer();
    const unsigned nw = l.nCells();
    if (localId() + 1 == nw)
      return -1;
    else
      return localId();
  }
 
  inline
  int
  TRGCDCWire::localIdForMinus(void) const
  {
    //
    // used in curl finder
    //
    // new version by NK
    //
    //ho  const TRGCDCLayer &l = *layer();
    //ho const int nw = l.nWires();
 
    const TRGCDCLayer& l = this->layer();
    const unsigned nw = l.nCells();
    if (0 == localId())
      return nw;
    else
      return localId();
  }
 
  inline
  const TRGSignal&
  TRGCDCWire::signal(void) const
  {
    return _signal;
  }
 
  inline
  const TRGSignal&
  TRGCDCWire::signal_adc(void) const
  {
    return _signal_adc;
  }
 
} // namespace Belle2
 
#endif /* TRGCDCWire_FLAG_ */