CDCWire.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/WireNeighborPair.h>
#include <cdc/topology/WireLine.h>
 
#include <cdc/topology/ISuperLayer.h>
#include <cdc/topology/ILayer.h>
#include <cdc/topology/IWire.h>
 
#include <cdc/topology/WireNeighborKind.h>
#include <cdc/topology/EStereoKind.h>
#include <cdc/topology/EWirePosition.h>
 
#include <tracking/trackingUtilities/utilities/MayBePtr.h>
 
#include <cdc/dataobjects/WireID.h>
 
#include <Math/Vector2D.h>
#include <Math/Vector3D.h>
 
#include <iostream>
 
 
namespace Belle2 {
  class CDCHit;
  namespace CDC {
    // Forward declarations
    class CDCWireLayer;
    class CDCWireSuperLayer;

    class CDCWire {
 
    public:

      static const CDCWire* getInstance(const WireID& wireID);

      static const CDCWire* getInstance(ISuperLayer iSuperLayer, ILayer iLayer, IWire iWire);

      static const CDCWire* getInstance(const CDCHit& hit);

      explicit CDCWire(const WireID& wireID);

      CDCWire(ISuperLayer iSuperLayer, ILayer iLayer, IWire iWire);

      CDCWire(const CDCWire& wire) = delete;

      CDCWire(CDCWire&& wire) = default;

      void operator=(const CDCWire& wire) = delete;
 
    public:
      bool operator==(const CDCWire& other) const
      { return getWireID() == other.getWireID(); }

      bool operator<(const CDCWire& other) const
      { return getWireID() < other.getWireID(); }
 
    public:
      void initialize(EWirePosition wirePosition, bool ignoreWireSag);


      operator const Belle2::WireID& () const
      { return getWireID(); }

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

      unsigned short getEWire() const
      { return getWireID().getEWire(); }

      IWire getIWire() const
      { return getWireID().getIWire(); }

      ILayer getICLayer() const
      { return getWireID().getICLayer(); }

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

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



      bool isAxial() const
      { return getStereoKind() == EStereoKind::c_Axial; }

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

      const WireLine& getWireLine() const
      { return m_wireLine; }

      ROOT::Math::XYVector getWirePos2DAtZ(const double z) const
      { return getWireLine().sagPos2DAtZ(z); }

      ROOT::Math::XYZVector getWirePos3DAtZ(const double z) const
      { return getWireLine().sagPos3DAtZ(z); }

      double getDistance(const ROOT::Math::XYZVector& pos3D) const
      { return getWireLine().sagDistance(pos3D); }

      ROOT::Math::XYZVector getClosest(const ROOT::Math::XYZVector& pos3D) const
      { return getWireLine().sagClosest3D(pos3D); }

      double getDriftLength(const ROOT::Math::XYZVector& pos3D) const
      { return isInCell(pos3D) ? getDistance(pos3D) : NAN; }

      const ROOT::Math::XYZVector& getRefPos3D() const
      { return getWireLine().refPos3D(); }

      const ROOT::Math::XYVector& getRefPos2D() const
      { return getWireLine().refPos2D(); }

      double getRefZ() const
      { return getWireLine().refZ(); }

      double getTanStereoAngle() const
      { return getWireLine().tanTheta(); }

      double getStereoAngle() const
      { return getWireLine().theta(); }

      ROOT::Math::XYZVector getWireVector() const
      { return getWireLine().wireVector(); }

      ROOT::Math::XYVector getMovePerZ() const
      { return getWireLine().nominalMovePerZ(); }

      ROOT::Math::XYVector getMovePerZAtZ(double z) const
      { return getWireLine().sagMovePerZ(z); }

      double getRefCylindricalR() const
      { return m_refCylindricalR; }

      double getMinCylindricalR() const
      { return getWireLine().nominalPerigee2D().R(); }

      double getForwardCylindricalR() const
      { return getWireLine().forwardCylindricalR(); };

      double getBackwardCylindricalR() const
      { return getWireLine().forwardCylindricalR(); };

      double getForwardZ() const
      { return getWireLine().forwardZ(); }

      double getBackwardZ() const
      { return getWireLine().backwardZ(); }

      ROOT::Math::XYZVector getForwardPos3D() const
      { return getWireLine().forward3D(); }

      ROOT::Math::XYZVector getBackwardPos3D() const
      { return getWireLine().backward3D(); }

      bool isInCell(const ROOT::Math::XYZVector& pos3D) const;

      bool isInCellZBounds(const ROOT::Math::XYZVector& pos3D, const double factor = 1) const
      { return getBackwardZ() * factor < pos3D.z() and pos3D.z() < getForwardZ() * factor; }

      double getRadialCellWidth() const;

      double getLateralCellWidth() const;
 


      const CDCWireLayer& getWireLayer() const;

      const CDCWireSuperLayer& getWireSuperLayer() const;


      WireNeighborKind getNeighborKind(const CDCWire& wire) const;

      bool isPrimaryNeighborWith(const CDCWire& wire) const;

      WireNeighborPair getNeighborsInwards() const;

      WireNeighborPair getNeighborsOutwards() const;

      TrackingUtilities::MayBePtr<const CDCWire> getNeighborCCW() const;

      TrackingUtilities::MayBePtr<const CDCWire> getNeighborCW() const;

      TrackingUtilities::MayBePtr<const CDCWire> getNeighborCCWInwards() const;

      TrackingUtilities::MayBePtr<const CDCWire> getNeighborCWInwards() const;

      TrackingUtilities::MayBePtr<const CDCWire> getNeighborCCWOutwards() const;

      TrackingUtilities::MayBePtr<const CDCWire> getNeighborCWOutwards() const;

      TrackingUtilities::MayBePtr<const CDCWire> getSecondaryNeighbor(short oClockDirection) const;

      friend std::ostream& operator<<(std::ostream& output, const CDCWire& wire)
      { return (output << "CDCWire(" << wire.getISuperLayer() << "," << wire.getILayer() << "," << wire.getIWire() << ")") ; }
 
    private:
      WireID m_wireID;

      WireLine m_wireLine;

      double m_refCylindricalR;
 
    };
  }
}