Link.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 relate TRGCDCCellHit and TRGCDCTrack objects.
//-----------------------------------------------------------------------------
 
#ifndef TRGCDCLink_FLAG_
#define TRGCDCLink_FLAG_
 
#include <cstring>
#include <vector>
#include "CLHEP/Geometry/Point3D.h"
#include "trg/cdc/Cell.h"
#include "trg/cdc/CellHit.h"
 
#ifdef TRGCDC_SHORT_NAMES
#define TCLink TRGCDCLink
#endif
 
namespace Belle2 {
  class TRGCDC;
  class TRGCDCTrack;
  class TRGCDCTrackMC;
  class TRGCDCWire;
  class TRGCDCSegment;
 
  class TRGCDCLink {
 
  public:
 
    TRGCDCLink(TRGCDCTrack* track = 0,
               const TRGCDCCellHit* hit = 0,
               const HepGeom::Point3D<double>& position = Point3D());
 
    TRGCDCLink(const TRGCDCLink&);
 
    virtual ~TRGCDCLink();
 
    static void removeAll(void);
 
    static void* operator new (size_t);
 
    static void operator delete (void*);
 
  public:// Selectors
 
    TRGCDCTrack* track(void) const;
 
    const TRGCDCCellHit* hit(void) const;
 
    const TRGCDCCell* cell(void) const;
 
    const TRGCDCWire* wire(void) const;
 
    const TRGCDCSegment* segment(void) const;
 
    double pull(void) const;
 
    const HepGeom::Point3D<double>& xyPosition(void) const;
 
    const HepGeom::Point3D<double>& positionOnWire(void) const;
 
    const HepGeom::Point3D<double>& positionOnTrack(void) const;
 
    double dPhi(void) const;
 
    unsigned leftRight(void) const;
 
    const HepGeom::Point3D<double>& position(void) const;
 
    double distance(void) const;
 
    TRGCDCLink* neighbor(unsigned n) const;
 
    TRGCDCLink* link(void) const;
 
  public:// tmp
//    const HepGeom::Point3D<double> & conf(void) const;
    const HepGeom::Point3D<double>& conf(const HepGeom::Point3D<double>& conf);
 
  public:// Modifiers
    void update(const HepGeom::Point3D<double>& onTrack,
                const HepGeom::Point3D<double>& onWire,
                unsigned leftRight,
                double pull);
 
    const TRGCDCCellHit* hit(const TRGCDCCellHit*);
 
    TRGCDCTrack* track(TRGCDCTrack*);
 
    const HepGeom::Point3D<double>& positionOnWire(const HepGeom::Point3D<double>&);
    const HepGeom::Point3D<double>& positionOnWire(double p[3]);
 
    const HepGeom::Point3D<double>& positionOnTrack(const HepGeom::Point3D<double>&);
    const HepGeom::Point3D<double>& positionOnTrack(double p[3]);
 
    double dPhi(double);
 
    const HepGeom::Point3D<double>& position(const HepGeom::Point3D<double>&);
 
    void neighbor(unsigned n, TRGCDCLink* neighbor);
 
    TRGCDCLink* link(TRGCDCLink*);
 
    unsigned leftRight(unsigned);
 
    double pull(double);
 
//    const unsigned fit2D(const unsigned &);
 
//    unsigned fit2D(void);
 
  public:// Drift distance
 
    float drift(void) const;
 
    float drift(unsigned) const;
 
    float drift(float, unsigned);
 
    float dDrift(void) const;
 
    float dDrift(unsigned) const;
 
    float dDrift(float, unsigned);
 
  public:// Utility functions
 
    void dump(const std::string& message = std::string(""),
              const std::string& prefix = std::string("")) const;
 
  public:// Static utility functions (for Belle2)
 
    static void separate(const std::vector<TRGCDCLink*>& links,
                         unsigned nLayers,
                         std::vector<TRGCDCLink*>* layers);
 
  public:// Static utility functions
 
    static const TRGCDCTrackMC& links2HEP(
      const std::vector<TRGCDCLink*>& links);
 
    static unsigned nSuperLayers(const std::vector<TRGCDCLink*>& links);
 
    static unsigned nSuperLayers(const std::vector<TRGCDCLink*>& links,
                                 unsigned minNHits);
 
    static unsigned nMissingAxialSuperLayers(
      const std::vector<TRGCDCLink*>& links);
 
    static unsigned nMissingStereoSuperLayers(
      const std::vector<TRGCDCLink*>& links);
 
    static unsigned nLayers(const std::vector<TRGCDCLink*>& links);
 
    static void nHits(const std::vector<TRGCDCLink*>& links,
                      unsigned* nHits);
 
    static void nHitsSuperLayer(const std::vector<TRGCDCLink*>& links,
                                unsigned* nHits);
 
    static void nHitsSuperLayer(const std::vector<TRGCDCLink*>& links,
                                std::vector<TRGCDCLink*>* list);
 
    static std::vector<TRGCDCLink*> axialHits(
      const std::vector<TRGCDCLink*>& links);
 
    static std::vector<TRGCDCLink*> stereoHits(
      const std::vector<TRGCDCLink*>& links);
 
    static unsigned nAxialHits(const std::vector<TRGCDCLink*>& links);
 
    static unsigned nStereoHits(const std::vector<TRGCDCLink*>& links);
 
    static unsigned width(const std::vector<TRGCDCLink*>&);
 
    static std::vector<TRGCDCLink*> edges(const std::vector<TRGCDCLink*>&);
 
    static std::vector<TRGCDCLink*> sameLayer(
      const std::vector<TRGCDCLink*>& list,
      const TRGCDCLink& a);
 
    static std::vector<TRGCDCLink*> sameLayer(
      const std::vector<TRGCDCLink*>& list,
      unsigned id);
 
    static std::vector<TRGCDCLink*> sameSuperLayer(
      const std::vector<TRGCDCLink*>& list,
      const TRGCDCLink& a);
 
    static std::vector<TRGCDCLink*> sameSuperLayer(
      const std::vector<TRGCDCLink*>& list,
      unsigned id);
 
    static unsigned superLayer(const std::vector<TRGCDCLink*>& list);
 
    static unsigned superLayer(const std::vector<TRGCDCLink*>& list,
                               unsigned minNHits);
 
    static TRGCDCLink* innerMost(const std::vector<TRGCDCLink*>& links);
 
    static TRGCDCLink* outerMost(const std::vector<TRGCDCLink*>& links);
 
    static std::vector<TRGCDCLink*> inOut(const std::vector<TRGCDCLink*>&);
 
    static void separateCores(const std::vector<TRGCDCLink*>& input,
                              std::vector<TRGCDCLink*>& cores,
                              std::vector<TRGCDCLink*>& nonCores);
 
    static std::vector<TRGCDCLink*> cores(
      const std::vector<TRGCDCLink*>& input);
 
    static void remove(std::vector<TRGCDCLink*>& list,
                       const std::vector<TRGCDCLink*>& links);
 
    static void dump(const std::vector<const TRGCDCLink*>& links,
                     const std::string& message = std::string(""),
                     const std::string& prefix = std::string(""));
 
    static void dump(const std::vector<TRGCDCLink*>& links,
                     const std::string& message = std::string(""),
                     const std::string& prefix = std::string(""));
 
    static void dump(const TRGCDCLink& link,
                     const std::string& message = std::string(""),
                     const std::string& prefix = std::string(""));
 
    static std::string layerUsage(const std::vector<TRGCDCLink*>& links);
 
  public:// Sorters
 
    static bool sortById(const TRGCDCLink* a, const TRGCDCLink* b);
 
    static int sortByX(const TRGCDCLink* a, const TRGCDCLink* b);
 
  private:
    friend class TRGCDC;
 
  public:
    static void initializeBuffers(void);
 
  private:
    static void clearBufferSL(void);
 
    void dump_base(const std::string& message = std::string(""),
                   const std::string& prefix = std::string("")) const;
 
  private:
 
    static std::vector<TRGCDCLink*> _all;
 
    TRGCDCTrack* _track;
 
    const TRGCDCCellHit* _hit;
 
    HepGeom::Point3D<double> _onTrack;
    HepGeom::Point3D<double> _onWire;
    HepGeom::Point3D<double> _position;
    double _dPhi;
    unsigned _leftRight;
    float _drift[2];
    float _dDrift[2];
 
    int _zStatus;
    int _zPair;
    double _pull;
    TRGCDCLink* _neighbor[7];
    TRGCDCLink* _link;
 
    HepGeom::Point3D<double> _conf;
 
    HepGeom::Point3D<double> _arcZ[4];
    unsigned _fit2D;
    //
    // for quick dicision
    //
    static bool ms_smallcell;
    static bool ms_superb;
 
    static unsigned _nL;
    static unsigned _nSL;
    static unsigned _nSLA;
    static unsigned* _nHitsSL;
 
#ifdef TRASAN_DEBUG
  public:
    static unsigned nTRGCDCLinks(void);
    static unsigned nTRGCDCLinksMax(void);
  private:
    static unsigned _nTRGCDCLinks;
    static unsigned _nTRGCDCLinksMax;
#endif
  };
 
//-----------------------------------------------------------------------------
 
  inline
  const TRGCDCCellHit*
  TRGCDCLink::hit(void) const
  {
    return _hit;
  }
 
  inline
  TRGCDCTrack*
  TRGCDCLink::track(void) const
  {
    return _track;
  }
 
  inline
  const TRGCDCCellHit*
  TRGCDCLink::hit(const TRGCDCCellHit* a)
  {
    return _hit = a;
  }
 
  inline
  TRGCDCTrack*
  TRGCDCLink::track(TRGCDCTrack* a)
  {
    return _track = a;
  }
 
  inline
  void
  TRGCDCLink::update(const HepGeom::Point3D<double>& onTrack,
                     const HepGeom::Point3D<double>& onWire,
                     unsigned leftRight,
                     double pull)
  {
    _onTrack = onTrack;
    _onWire = onWire;
    _leftRight = leftRight;
    _pull = pull;
  }
 
  inline
  double
  TRGCDCLink::pull(void) const
  {
    return _pull;
  }
 
  inline
  double
  TRGCDCLink::pull(double a)
  {
    return _pull = a;
  }
 
  inline
  const HepGeom::Point3D<double>&
  TRGCDCLink::positionOnWire(void) const
  {
    return _onWire;
  }
 
  inline
  const HepGeom::Point3D<double>&
  TRGCDCLink::positionOnTrack(void) const
  {
    return _onTrack;
  }
 
  inline
  const HepGeom::Point3D<double>&
  TRGCDCLink::positionOnWire(const HepGeom::Point3D<double>& a)
  {
    return _onWire = a;
  }
 
  inline
  const HepGeom::Point3D<double>&
  TRGCDCLink::positionOnWire(double p[3])
  {
    _onWire.setX(p[0]);
    _onWire.setY(p[1]);
    _onWire.setZ(p[2]);
    return _onWire;
  }
 
  inline
  const HepGeom::Point3D<double>&
  TRGCDCLink::positionOnTrack(const HepGeom::Point3D<double>& a)
  {
    return _onTrack = a;
  }
 
  inline
  const HepGeom::Point3D<double>&
  TRGCDCLink::positionOnTrack(double p[3])
  {
    _onTrack.setX(p[0]);
    _onTrack.setY(p[1]);
    _onTrack.setZ(p[2]);
    return _onTrack;
  }
 
  inline
  unsigned
  TRGCDCLink::leftRight(void) const
  {
    return _leftRight;
  }
 
  inline
  unsigned
  TRGCDCLink::leftRight(unsigned a)
  {
    return _leftRight = a;
  }
 
  inline
  double
  TRGCDCLink::dPhi(void) const
  {
    return _dPhi;
  }
 
  inline
  double
  TRGCDCLink::dPhi(double a)
  {
    return _dPhi = a;
  }
 
  inline
  const HepGeom::Point3D<double>&
  TRGCDCLink::position(void) const
  {
    return _position;
  }
 
  inline
  const HepGeom::Point3D<double>&
  TRGCDCLink::position(const HepGeom::Point3D<double>& a)
  {
    return _position = a;
  }
 
// inline
// const HepGeom::Point3D<double> &
// TRGCDCLink::conf(void) const {
//     return _conf;
// }
 
  inline
  const HepGeom::Point3D<double>&
  TRGCDCLink::conf(const HepGeom::Point3D<double>& a)
  {
    return _conf = a;
  }
 
  inline
  void
  TRGCDCLink::neighbor(unsigned n, TRGCDCLink* neighbor)
  {
    if (n < 7)
      _neighbor[n] = neighbor;
  }
 
  inline
  TRGCDCLink*
  TRGCDCLink::neighbor(unsigned n) const
  {
    if (n < 7)
      return _neighbor[n];
    return NULL;
  }
 
  inline
  TRGCDCLink*
  TRGCDCLink::link(void) const
  {
    return _link;
  }
 
  inline
  TRGCDCLink*
  TRGCDCLink::link(TRGCDCLink* a)
  {
    return _link = a;
  }
 
  inline
  double
  TRGCDCLink::distance(void) const
  {
    return (_onTrack - _onWire).mag();
  }
 
  inline
  const HepGeom::Point3D<double>&
  TRGCDCLink::xyPosition(void) const
  {
    return _hit->cell().xyPosition();
  }
 
// inline
// const unsigned
// TRGCDCLink::fit2D(const unsigned &f) {
//   return _fit2D = f;
// }
 
// inline
// unsigned
// TRGCDCLink::fit2D(void) {
//   return _fit2D;
// }
 
  inline
  float
  TRGCDCLink::drift(unsigned a) const
  {
    return _drift[a];
  }
 
  inline
  float
  TRGCDCLink::drift(float b, unsigned a)
  {
    return _drift[a] = b;
  }
 
  inline
  float
  TRGCDCLink::dDrift(unsigned a) const
  {
    return _dDrift[a];
  }
 
  inline
  float
  TRGCDCLink::dDrift(float b, unsigned a)
  {
    return _dDrift[a] = b;
  }
 
  inline
  float
  TRGCDCLink::drift(void) const
  {
    return (_drift[0] + _drift[1]) / 2.;
  }
 
  inline
  float
  TRGCDCLink::dDrift(void) const
  {
    return (_dDrift[0] + _dDrift[1]) / 2.;
  }
 
  inline
  void
  TRGCDCLink::clearBufferSL(void)
  {
    bzero(_nHitsSL, sizeof(unsigned) * _nSL);
  }
 
  inline
  const TRGCDCCell*
  TRGCDCLink::cell(void) const
  {
    if (_hit)
      return & _hit->cell();
    return 0;
  }
 
} // namespace Belle2
 
#endif /* TRGCDCLink_FLAG_ */