CDCWireTopology.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/CDCWireSuperLayer.h>
#include <tracking/trackFindingCDC/topology/CDCWireLayer.h>
 
#include <tracking/trackFindingCDC/topology/WireNeighborKind.h>
#include <tracking/trackFindingCDC/topology/WireNeighborPair.h>
#include <tracking/trackFindingCDC/topology/CDCWire.h>
 
#include <tracking/trackFindingCDC/topology/ISuperLayer.h>
#include <tracking/trackFindingCDC/topology/ILayer.h>
#include <tracking/trackFindingCDC/topology/IWire.h>
#include <tracking/trackFindingCDC/topology/EWirePosition.h>
 
#include <tracking/trackFindingCDC/utilities/MayBePtr.h>
 
#include <cdc/dataobjects/WireID.h>
 
#include <vector>
 
namespace Belle2 {
  namespace TrackFindingCDC {
 
    class CDCWireTopology  {
 
    public:
      static CDCWireTopology& getInstance();
 
    public:
      CDCWireTopology()
      { initialize(); }
 
      CDCWireTopology(const CDCWireTopology& wireTopology) = delete;
 
      void operator=(const CDCWireTopology& wireTopology) = delete;
 
    public:
      static const IWire c_NWires = 14336;
 
      static const ILayer c_NLayers = 56;
 
      static const ISuperLayer c_NSuperLayers = 9;
 
    private:
      void initialize();
 
    public:
      void reinitialize(EWirePosition wirePosition, bool ignoreWireSag);
 
    public:
 
      bool isValidWireID(const WireID& wireID) const
      { return isValidIWire(wireID.getISuperLayer(), wireID.getILayer(), wireID.getIWire()); }
 
      bool isValidIWire(ILayer iCLayer, IWire iWire) const
      { return isValidICLayer(iCLayer) and getWireLayer(iCLayer).isValidIWire(iWire); }
 
      bool isValidIWire(ISuperLayer iSuperLayer, ILayer iLayer, IWire iWire) const
      { return isValidISuperLayer(iSuperLayer) and getWireSuperLayer(iSuperLayer).isValidIWire(iLayer, iWire); }
 
      const CDCWire& getWire(const WireID& wireId) const
      { return getWireLayer(wireId.getICLayer()).getWire(wireId.getIWire()) ; }
 
      const CDCWire& getWire(ILayer iCLayer, IWire iWire) const
      { return getWireLayer(iCLayer).getWire(iWire) ; }
 
      const CDCWire& getWire(ISuperLayer iSuperLayer, ILayer iLayer , IWire iWire) const
      { return getWireSuperLayer(iSuperLayer).getWireLayer(iLayer).getWire(iWire) ; }
 
      const std::vector<Belle2::TrackFindingCDC::CDCWire>& getWires() const
      { return m_wires; }
 
 
      ILayer getNLayers() const
      { return getWireLayers().size(); }
 
      bool isValidICLayer(ILayer iCLayer) const
      { return 0 <= iCLayer and iCLayer < int(getWireLayers().size()); }
 
      bool isValidILayer(ISuperLayer iSuperLayer, ILayer iLayer) const
      { return isValidISuperLayer(iSuperLayer) and getWireSuperLayer(iSuperLayer).isValidILayer(iLayer); }
 
      const CDCWireLayer& getWireLayer(const WireID& wireId) const
      { return getWireLayer(wireId.getICLayer()); }
 
      const CDCWireLayer& getWireLayer(ILayer iCLayer) const
      { return m_wireLayers[ iCLayer - m_FirstLayerOffset ]; }
 
      const CDCWireLayer& getWireLayer(ISuperLayer iSuperLayer, ILayer iLayer) const
      { return getWireSuperLayer(iSuperLayer).getWireLayer(iLayer); }
 
      const std::vector<Belle2::TrackFindingCDC::CDCWireLayer>& getWireLayers() const
      { return m_wireLayers; }
 
 
      ISuperLayer getNSuperLayers() const
      { return getWireSuperLayers().size(); }
 
      bool isValidISuperLayer(ISuperLayer iSuperLayer) const
      { return 0 <= iSuperLayer and iSuperLayer < int(getWireSuperLayers().size()); }
 
      ISuperLayer getISuperLayerAtCylindricalR(double cylindricalR);
 
      const CDCWireSuperLayer& getWireSuperLayer(const WireID& wireID) const
      { return getWireSuperLayer(wireID.getISuperLayer()); }
 
      const CDCWireSuperLayer& getWireSuperLayer(ISuperLayer iSuperLayer) const
      {
        return m_wireSuperLayers[iSuperLayer];
      }
 
      const std::vector<Belle2::TrackFindingCDC::CDCWireSuperLayer>& getWireSuperLayers() const
      { return m_wireSuperLayers; }
 
      WireNeighborKind getNeighborKind(const WireID& wireID, const WireID& otherWireID) const;
 
      bool arePrimaryNeighbors(const WireID& wireID, const WireID& otherWireID) const
      { return getNeighborKind(wireID, otherWireID).getCellDistance() == 1; }
 
      bool areSeconaryNeighbors(const WireID& wireID, const WireID& otherWireID) const
      { return getNeighborKind(wireID, otherWireID).getCellDistance() == 2; }
 
      MayBePtr<const CDCWire> getPrimaryNeighbor(short oClockDirection, const WireID& wireID) const
      { return getPrimaryNeighbor(oClockDirection, wireID.getISuperLayer(), wireID.getILayer(), wireID.getIWire()); }
 
      WireNeighborPair getNeighborsOutwards(const WireID& wireID) const
      { return getNeighborsOutwards(wireID.getISuperLayer(), wireID.getILayer(), wireID.getIWire()); }
 
      WireNeighborPair getNeighborsInwards(const WireID& wireID) const
      { return getNeighborsInwards(wireID.getISuperLayer(), wireID.getILayer(), wireID.getIWire()); }
 
      MayBePtr<const CDCWire> getNeighborCCWOutwards(const WireID& wireID) const
      { return getNeighborCCWOutwards(wireID.getISuperLayer(), wireID.getILayer(), wireID.getIWire()); }
 
      MayBePtr<const CDCWire> getNeighborCWOutwards(const WireID& wireID) const
      { return getNeighborCWOutwards(wireID.getISuperLayer(), wireID.getILayer(), wireID.getIWire()); }
 
      MayBePtr<const CDCWire> getNeighborCCW(const WireID& wireID) const
      { return getNeighborCCW(wireID.getISuperLayer(), wireID.getILayer(), wireID.getIWire()); }
 
      MayBePtr<const CDCWire> getNeighborCW(const WireID& wireID) const
      { return getNeighborCW(wireID.getISuperLayer(), wireID.getILayer(), wireID.getIWire()); }
 
      MayBePtr<const CDCWire> getNeighborCCWInwards(const WireID& wireID) const
      { return getNeighborCCWInwards(wireID.getISuperLayer(), wireID.getILayer(), wireID.getIWire()); }
 
      MayBePtr<const CDCWire> getNeighborCWInwards(const WireID& wireID) const
      { return getNeighborCWInwards(wireID.getISuperLayer(), wireID.getILayer(), wireID.getIWire()); }
      MayBePtr<const CDCWire> getPrimaryNeighbor(short oClockDirection,
                                                 ISuperLayer iSuperLayer,
                                                 ILayer iLayer,
                                                 IWire iWire) const
      { return getWireSuperLayer(iSuperLayer).getPrimaryNeighbor(oClockDirection, iLayer, iWire);}
 
 
      WireNeighborPair getNeighborsOutwards(ISuperLayer iSuperLayer,
                                            ILayer iLayer,
                                            IWire iWire) const
      { return getWireSuperLayer(iSuperLayer).getNeighborsOutwards(iLayer, iWire); }
 
      WireNeighborPair getNeighborsInwards(ISuperLayer iSuperLayer,
                                           ILayer iLayer,
                                           IWire iWire) const
      { return getWireSuperLayer(iSuperLayer).getNeighborsInwards(iLayer, iWire); }
 
      MayBePtr<const CDCWire> getNeighborCCWOutwards(ISuperLayer iSuperLayer,
                                                     ILayer iLayer,
                                                     IWire iWire) const
      { return getWireSuperLayer(iSuperLayer).getNeighborCCWOutwards(iLayer, iWire); }
 
      MayBePtr<const CDCWire> getNeighborCWOutwards(ISuperLayer iSuperLayer,
                                                    ILayer iLayer,
                                                    IWire iWire) const
      { return getWireSuperLayer(iSuperLayer).getNeighborCWOutwards(iLayer, iWire); }
 
      MayBePtr<const CDCWire> getNeighborCCW(ISuperLayer iSuperLayer,
                                             ILayer iLayer,
                                             IWire iWire) const
      { return getWireSuperLayer(iSuperLayer).getNeighborCCW(iLayer, iWire); }
 
      MayBePtr<const CDCWire> getNeighborCW(ISuperLayer iSuperLayer,
                                            ILayer iLayer,
                                            IWire iWire) const
      { return getWireSuperLayer(iSuperLayer).getNeighborCW(iLayer, iWire); }
 
      MayBePtr<const CDCWire> getNeighborCCWInwards(ISuperLayer iSuperLayer,
                                                    ILayer iLayer,
                                                    IWire iWire) const
      { return getWireSuperLayer(iSuperLayer).getNeighborCCWInwards(iLayer, iWire); }
 
      MayBePtr<const CDCWire> getNeighborCWInwards(ISuperLayer iSuperLayer,
                                                   ILayer iLayer,
                                                   IWire iWire) const
      { return getWireSuperLayer(iSuperLayer).getNeighborCWInwards(iLayer, iWire); }
      MayBePtr<const CDCWire> getSecondaryNeighbor(short oClockDirection, const WireID& wireID) const
      { return getSecondaryNeighbor(oClockDirection, wireID.getISuperLayer(), wireID.getILayer(), wireID.getIWire()); }
 
      MayBePtr<const CDCWire> getSecondNeighborOneOClock(const WireID& wireID) const
      { return getSecondNeighborOneOClock(wireID.getISuperLayer(), wireID.getILayer(), wireID.getIWire()); }
 
      MayBePtr<const CDCWire> getSecondNeighborTwoOClock(const WireID& wireID) const
      { return getSecondNeighborTwoOClock(wireID.getISuperLayer(), wireID.getILayer(), wireID.getIWire()); }
 
      MayBePtr<const CDCWire> getSecondNeighborThreeOClock(const WireID& wireID) const
      { return getSecondNeighborThreeOClock(wireID.getISuperLayer(), wireID.getILayer(), wireID.getIWire()); }
 
      MayBePtr<const CDCWire> getSecondNeighborFourOClock(const WireID& wireID) const
      { return getSecondNeighborFourOClock(wireID.getISuperLayer(), wireID.getILayer(), wireID.getIWire()); }
 
      MayBePtr<const CDCWire> getSecondNeighborFiveOClock(const WireID& wireID) const
      { return getSecondNeighborFiveOClock(wireID.getISuperLayer(), wireID.getILayer(), wireID.getIWire()); }
 
      MayBePtr<const CDCWire> getSecondNeighborSixOClock(const WireID& wireID) const
      { return getSecondNeighborSixOClock(wireID.getISuperLayer(), wireID.getILayer(), wireID.getIWire()); }
 
      MayBePtr<const CDCWire> getSecondNeighborSevenOClock(const WireID& wireID) const
      { return getSecondNeighborSevenOClock(wireID.getISuperLayer(), wireID.getILayer(), wireID.getIWire()); }
 
      MayBePtr<const CDCWire> getSecondNeighborEightOClock(const WireID& wireID) const
      { return getSecondNeighborEightOClock(wireID.getISuperLayer(), wireID.getILayer(), wireID.getIWire()); }
 
      MayBePtr<const CDCWire> getSecondNeighborNineOClock(const WireID& wireID) const
      { return getSecondNeighborNineOClock(wireID.getISuperLayer(), wireID.getILayer(), wireID.getIWire()); }
 
      MayBePtr<const CDCWire> getSecondNeighborTenOClock(const WireID& wireID) const
      { return getSecondNeighborTenOClock(wireID.getISuperLayer(), wireID.getILayer(), wireID.getIWire()); }
 
      MayBePtr<const CDCWire> getSecondNeighborElevenOClock(const WireID& wireID) const
      { return getSecondNeighborElevenOClock(wireID.getISuperLayer(), wireID.getILayer(), wireID.getIWire()); }
 
      MayBePtr<const CDCWire> getSecondNeighborTwelveOClock(const WireID& wireID) const
      { return getSecondNeighborTwelveOClock(wireID.getISuperLayer(), wireID.getILayer(), wireID.getIWire()); }
      MayBePtr<const CDCWire> getSecondaryNeighbor(short oClockDirection,
                                                   ISuperLayer iSuperLayer,
                                                   ILayer iLayer,
                                                   IWire iWire) const
      { return getWireSuperLayer(iSuperLayer).getSecondaryNeighbor(oClockDirection, iLayer, iWire);}
 
      MayBePtr<const CDCWire> getSecondNeighborOneOClock(ISuperLayer iSuperLayer,
                                                         ILayer iLayer,
                                                         IWire  iWire) const
      { return getWireSuperLayer(iSuperLayer).getSecondNeighborOneOClock(iLayer, iWire); }
 
      MayBePtr<const CDCWire> getSecondNeighborTwoOClock(ISuperLayer iSuperLayer,
                                                         ILayer iLayer,
                                                         IWire  iWire) const
      { return getWireSuperLayer(iSuperLayer).getSecondNeighborTwoOClock(iLayer, iWire); }
 
      MayBePtr<const CDCWire> getSecondNeighborThreeOClock(ISuperLayer iSuperLayer,
                                                           ILayer iLayer,
                                                           IWire  iWire) const
      { return getWireSuperLayer(iSuperLayer).getSecondNeighborThreeOClock(iLayer, iWire); }
 
      MayBePtr<const CDCWire> getSecondNeighborFourOClock(ISuperLayer iSuperLayer,
                                                          ILayer iLayer,
                                                          IWire  iWire) const
      { return getWireSuperLayer(iSuperLayer).getSecondNeighborFourOClock(iLayer, iWire); }
 
      MayBePtr<const CDCWire> getSecondNeighborFiveOClock(ISuperLayer iSuperLayer,
                                                          ILayer iLayer,
                                                          IWire  iWire) const
      { return getWireSuperLayer(iSuperLayer).getSecondNeighborFiveOClock(iLayer, iWire); }
 
      MayBePtr<const CDCWire> getSecondNeighborSixOClock(ISuperLayer iSuperLayer,
                                                         ILayer iLayer,
                                                         IWire  iWire) const
      { return getWireSuperLayer(iSuperLayer).getSecondNeighborSixOClock(iLayer, iWire); }
 
      MayBePtr<const CDCWire> getSecondNeighborSevenOClock(ISuperLayer iSuperLayer,
                                                           ILayer iLayer,
                                                           IWire  iWire) const
      { return getWireSuperLayer(iSuperLayer).getSecondNeighborSevenOClock(iLayer, iWire); }
 
      MayBePtr<const CDCWire> getSecondNeighborEightOClock(ISuperLayer iSuperLayer,
                                                           ILayer iLayer,
                                                           IWire  iWire) const
      { return getWireSuperLayer(iSuperLayer).getSecondNeighborEightOClock(iLayer, iWire); }
 
      MayBePtr<const CDCWire> getSecondNeighborNineOClock(ISuperLayer iSuperLayer,
                                                          ILayer iLayer,
                                                          IWire  iWire) const
      { return getWireSuperLayer(iSuperLayer).getSecondNeighborNineOClock(iLayer, iWire); }
 
      MayBePtr<const CDCWire> getSecondNeighborTenOClock(ISuperLayer iSuperLayer,
                                                         ILayer iLayer,
                                                         IWire  iWire) const
      { return getWireSuperLayer(iSuperLayer).getSecondNeighborTenOClock(iLayer, iWire); }
 
      MayBePtr<const CDCWire> getSecondNeighborElevenOClock(ISuperLayer iSuperLayer,
                                                            ILayer iLayer,
                                                            IWire  iWire) const
      { return getWireSuperLayer(iSuperLayer).getSecondNeighborElevenOClock(iLayer, iWire); }
 
      MayBePtr<const CDCWire> getSecondNeighborTwelveOClock(ISuperLayer iSuperLayer,
                                                            ILayer iLayer,
                                                            IWire  iWire) const
      { return getWireSuperLayer(iSuperLayer).getSecondNeighborTwelveOClock(iLayer, iWire); }
    public:
      double getOuterCylindricalR() const
      { return m_wireLayers.back().getOuterCylindricalR(); }
 
      double getInnerCylindricalR() const
      { return m_wireLayers.front().getInnerCylindricalR(); }
 
    private:
      std::vector<Belle2::TrackFindingCDC::CDCWire> m_wires;
 
      std::vector<Belle2::TrackFindingCDC::CDCWireLayer> m_wireLayers;
 
      std::vector<Belle2::TrackFindingCDC::CDCWireSuperLayer> m_wireSuperLayers;
 
      ILayer m_FirstLayerOffset = 0;
 
    };
  }
}