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 <tracking/trackFindingCDC/topology/WireNeighborPair.h>
#include <tracking/trackFindingCDC/topology/WireLine.h>
 
#include <tracking/trackFindingCDC/topology/ISuperLayer.h>
#include <tracking/trackFindingCDC/topology/ILayer.h>
#include <tracking/trackFindingCDC/topology/IWire.h>
 
#include <tracking/trackFindingCDC/topology/WireNeighborKind.h>
#include <tracking/trackFindingCDC/topology/EStereoKind.h>
#include <tracking/trackFindingCDC/topology/EWirePosition.h>
 
#include <tracking/trackFindingCDC/geometry/Vector3D.h>
#include <tracking/trackFindingCDC/geometry/Vector2D.h>
 
#include <tracking/trackFindingCDC/utilities/MayBePtr.h>
 
#include <cdc/dataobjects/WireID.h>
 
#include <iostream>
 
namespace Belle2 {
  class CDCHit;
}
 
namespace Belle2 {
  namespace TrackFindingCDC {
 
    // 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; }
 
      Vector2D getWirePos2DAtZ(const double z) const
      { return getWireLine().sagPos2DAtZ(z); }
 
      Vector3D getWirePos3DAtZ(const double z) const
      { return getWireLine().sagPos3DAtZ(z); }
 
      double getDistance(const Vector3D& pos3D) const
      { return getWireLine().sagDistance(pos3D); }
 
      Vector3D getClosest(const Vector3D& pos3D) const
      { return getWireLine().sagClosest3D(pos3D); }
 
      double getDriftLength(const Vector3D& pos3D) const
      { return isInCell(pos3D) ? getDistance(pos3D) : NAN; }
 
      const Vector3D& getRefPos3D() const
      { return getWireLine().refPos3D(); }
 
      const Vector2D& getRefPos2D() const
      { return getWireLine().refPos2D(); }
 
      double getRefZ() const
      { return getWireLine().refZ(); }
 
      double getTanStereoAngle() const
      { return getWireLine().tanTheta(); }
 
      double getStereoAngle() const
      { return getWireLine().theta(); }
 
      Vector3D getWireVector() const
      { return getWireLine().wireVector(); }
 
      Vector2D getMovePerZ() const
      { return getWireLine().nominalMovePerZ(); }
 
      Vector2D getMovePerZAtZ(double z) const
      { return getWireLine().sagMovePerZ(z); }
 
      double getRefCylindricalR() const
      { return m_refCylindricalR; }
 
      double getMinCylindricalR() const
      { return getWireLine().nominalPerigee2D().norm(); }
 
      double getForwardCylindricalR() const
      { return getWireLine().forwardCylindricalR(); };
 
      double getBackwardCylindricalR() const
      { return getWireLine().forwardCylindricalR(); };
 
      double getForwardZ() const
      { return getWireLine().forwardZ(); }
 
      double getBackwardZ() const
      { return getWireLine().backwardZ(); }
 
      Vector3D getForwardPos3D() const
      { return getWireLine().forward3D(); }
 
      Vector3D getBackwardPos3D() const
      { return getWireLine().backward3D(); }
 
      bool isInCell(const Vector3D& pos3D) const;
 
      bool isInCellZBounds(const Vector3D& 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;
 
      MayBePtr<const CDCWire> getNeighborCCW() const;
 
      MayBePtr<const CDCWire> getNeighborCW() const;
 
      MayBePtr<const CDCWire> getNeighborCCWInwards() const;
 
      MayBePtr<const CDCWire> getNeighborCWInwards() const;
 
      MayBePtr<const CDCWire> getNeighborCCWOutwards() const;
 
      MayBePtr<const CDCWire> getNeighborCWOutwards() const;
      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;
 
    };
  }
}