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 <cdc/topology/EStereoKind.h>
#include <cdc/topology/ISuperLayer.h>
#include <cdc/topology/ILayer.h>
 
#include <tracking/trackingUtilities/ca/AutomatonCell.h>
 
#include <tracking/trackingUtilities/numerics/ERightLeft.h>
#include <tracking/trackingUtilities/numerics/Index.h>
 
#include <tracking/trackingUtilities/utilities/FunctorTag.h>
 
#include <cdc/dataobjects/WireID.h>
 
#include <Math/Vector2D.h>
#include <Math/Vector3D.h>
 
#include <utility>
#include <iosfwd>
#include <cassert>
 
namespace Belle2 {
  class CDCHit;
  namespace CDC {
    class TDCCountTranslatorBase;
    class ADCCountTranslatorBase;
    class CDCWireSuperLayer;
    class CDCWire; // IWYU pragma: keep
  }
  namespace TrackingUtilities {
    class CDCTrajectory2D;
    class Circle2D;

    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 CDC::CDCWire& wire)
      {
        return &wireHit.getWire() < &wire;
      }

      // Same as above but the other way round.
      friend bool operator<(const CDC::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 CDC::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 CDC::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 CDC::CDCWire& getWire() const
      {
        // if (not m_wire) return attachWire();
        if (not m_wire) return attachWire();
        return *m_wire;
      }

      const CDC::CDCWire& attachWire() const;

      const WireID& getWireID() const
      {
        return m_wireID;
      }

      CDC::EStereoKind getStereoKind() const
      {
        return CDC::ISuperLayerUtil::getStereoKind(getISuperLayer());
      }

      bool isAxial() const
      {
        return CDC::ISuperLayerUtil::isAxial(getISuperLayer());
      }

      CDC::ISuperLayer getISuperLayer() const
      {
        return getWireID().getISuperLayer();
      }

      CDC::ILayer getILayer() const
      {
        return getWireID().getILayer();
      }

      const ROOT::Math::XYVector& getRefPos2D() const;

      const ROOT::Math::XYZVector& 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 CDC::CDCWire& wire) const
      {
        return &getWire() == &wire;
      }

      ROOT::Math::XYVector reconstruct2D(const CDCTrajectory2D& trajectory2D) const;

      ROOT::Math::XYZVector reconstruct3D(const CDCTrajectory2D& trajectory2D, ERightLeft rlInfo, double z = 0) const;

      Circle2D conformalTransformed(const ROOT::Math::XYVector& 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 CDC::CDCWire const* m_wire = nullptr; 

      const CDCHit* m_hit = nullptr;

      mutable AutomatonCell m_automatonCell{1};

      double m_refDriftLength = 0;

      double m_refDriftLengthVariance = c_simpleDriftLengthVariance;

      double m_refChargeDeposit = 0.0;

      double m_refDriftTime = 0.0f;

      int m_iSuperCluster = -1;
    };

    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 CDC::CDCWireSuperLayer& wireSuperLayer);

    // Same as above but the other way round.
    bool operator<(const CDC::CDCWireSuperLayer& wireSuperLayer, const CDCWireHit& wireHit);
  }
}