CDCWireHit.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.                  *
 **************************************************************************/
#pragma once
 
#include <tracking/trackFindingCDC/topology/EStereoKind.h>
#include <tracking/trackFindingCDC/topology/ISuperLayer.h>
#include <tracking/trackFindingCDC/topology/ILayer.h>
 
#include <tracking/trackFindingCDC/ca/AutomatonCell.h>
 
#include <tracking/trackFindingCDC/numerics/ERightLeft.h>
#include <tracking/trackFindingCDC/numerics/Index.h>
 
#include <tracking/trackFindingCDC/utilities/FunctorTag.h>
 
#include <cdc/dataobjects/WireID.h>
 
#include <utility>
#include <iosfwd>
#include <cassert>
 
namespace Belle2 {
  class CDCHit;
  namespace CDC {
    class TDCCountTranslatorBase;
    class ADCCountTranslatorBase;
  }
  namespace TrackFindingCDC {
    class CDCTrajectory2D;
    class CDCWireSuperLayer;
    class CDCWire; // IWYU pragma: keep
    class Circle2D;
    class Vector3D;
    class Vector2D;
 
    class CDCWireHit {
    public:
      static CDC::TDCCountTranslatorBase& getTDCCountTranslator();
 
      static CDC::ADCCountTranslatorBase& getADCCountTranslator();
 
      static constexpr const double c_simpleDriftLengthVariance = 0.000169;
 
      CDCWireHit() = default;
 
      CDCWireHit(const CDCHit* ptrHit,
                 double driftLength,
                 double driftLengthVariance = c_simpleDriftLengthVariance,
                 double chargeDeposit = 0,
                 double driftTime = 0);
 
      explicit CDCWireHit(const CDCHit* ptrHit,
                          CDC::TDCCountTranslatorBase* ptrTDCCountTranslator = nullptr,
                          CDC::ADCCountTranslatorBase* ptrADCCountTranslator = nullptr);
 
      CDCWireHit(const WireID& wireID,
                 double driftLength,
                 double driftLengthVariance = c_simpleDriftLengthVariance,
                 double chargeDeposit = 0);
 
      bool operator==(const CDCWireHit& rhs) const
      {
        return getWireID() == rhs.getWireID() and getRefDriftLength() == rhs.getRefDriftLength();
      }
 
      bool operator<(const CDCWireHit& rhs) const
      {
        return
          std::make_pair(getWireID().getEWire(), getRefDriftLength()) <
          std::make_pair(rhs.getWireID().getEWire(), rhs.getRefDriftLength());
      }
 
      friend bool operator<(const CDCWireHit& wireHit, const CDCWire& wire)
      {
        return &wireHit.getWire() < &wire;
      }
 
      // Same as above but the other way round.
      friend bool operator<(const CDCWire& wire, const CDCWireHit& wireHit)
      {
        return &wire < &wireHit.getWire();
      }
 
      // Same as above but with CDCWireHit as a pointer.
      friend bool operator<(const CDCWireHit* wireHit, const CDCWire& wire)
      {
        assert(wireHit);
        return *wireHit < wire;
      }
 
      // Same as above but the other way round and with CDCWireHit as a pointer.
      friend bool operator<(const CDCWire& wire, const CDCWireHit* wireHit)
      {
        assert(wireHit);
        return wire < *wireHit;
      }
 
      bool operator<(const CDCHit& hit);
 
      friend bool operator<(const CDCWireHit& wireHit, const CDCHit& hit);
 
      // Same as above but the other way round.
      friend bool operator<(const CDCHit& hit, const CDCWireHit& wireHit);
 
      const CDCHit* getHit() const
      {
        return m_hit;
      }
 
      Index getStoreIHit() const;
 
      const CDCWire& getWire() const
      {
        // if (not m_wire) return attachWire();
        if (not m_wire) return attachWire();
        return *m_wire;
      }
 
      const CDCWire& attachWire() const;
 
      const WireID& getWireID() const
      {
        return m_wireID;
      }
 
      EStereoKind getStereoKind() const
      {
        return ISuperLayerUtil::getStereoKind(getISuperLayer());
      }
 
      bool isAxial() const
      {
        return ISuperLayerUtil::isAxial(getISuperLayer());
      }
 
      ISuperLayer getISuperLayer() const
      {
        return getWireID().getISuperLayer();
      }
 
      ILayer getILayer() const
      {
        return getWireID().getILayer();
      }
 
      const Vector2D& getRefPos2D() const;
 
      const Vector3D& getRefPos3D() const;
 
      double getRefCylindricalR() const;
 
      double getRefDriftLength() const
      {
        return m_refDriftLength;
      }
 
      double getRefDriftLengthVariance() const
      {
        return m_refDriftLengthVariance;
      }
 
      double getRefChargeDeposit() const
      {
        return m_refChargeDeposit;
      }
 
      bool isOnWire(const CDCWire& wire) const
      {
        return &getWire() == &wire;
      }
 
      Vector2D reconstruct2D(const CDCTrajectory2D& trajectory2D) const;
 
      Vector3D reconstruct3D(const CDCTrajectory2D& trajectory2D, ERightLeft rlInfo, double z = 0) const;
 
      Circle2D conformalTransformed(const Vector2D& relativeTo) const;
 
      AutomatonCell& getAutomatonCell() const
      {
        return m_automatonCell;
      }
 
      AutomatonCell* operator->() const
      {
        return &m_automatonCell;
      }
 
      int getISuperCluster() const
      {
        return m_iSuperCluster;
      }
 
      void setISuperCluster(int iSuperCluster)
      {
        m_iSuperCluster = iSuperCluster;
      }
 
      double getDriftTime() const
      {
        return m_refDriftTime;
      }
 
    private:
      WireID m_wireID;
 
      mutable CDCWire const* m_wire = nullptr; 
 
      mutable AutomatonCell m_automatonCell{1};
 
      double m_refDriftLength = 0;
 
      double m_refDriftLengthVariance = c_simpleDriftLengthVariance;
 
      double m_refChargeDeposit = 0.0;
 
      int m_iSuperCluster = -1;
 
      double m_refDriftTime = 0.0f;
 
      const CDCHit* m_hit = nullptr;
    };
 
    struct GetWireHit {
      operator FunctorTag();
 
      template<class T, class SFINAE = decltype(&T::getWireHit)>
      const CDCWireHit & operator()(const T& t) const
      {
        return t.getWireHit();
      }
 
      const CDCWireHit& operator()(const CDCWireHit& wireHit) const
      {
        return wireHit;
      }
    };
 
    std::ostream& operator<<(std::ostream& output, const CDCWireHit& wirehit);
 
    bool operator<(const CDCWireHit& wireHit, const CDCHit& hit);
 
    bool operator<(const CDCHit& hit, const CDCWireHit& wireHit);;
 
    bool operator<(const CDCWireHit& wireHit, const CDCWireSuperLayer& wireSuperLayer);
 
    // Same as above but the other way round.
    bool operator<(const CDCWireSuperLayer& wireSuperLayer, const CDCWireHit& wireHit);
  }
}