CDCWireSuperLayer.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/CDCWireLayer.h>
#include <cdc/topology/WireNeighborPair.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 <tracking/trackingUtilities/utilities/VectorRange.h>
#include <tracking/trackingUtilities/utilities/MayBePtr.h>
 
namespace Belle2 {
  namespace CDC {

    class CDCWireSuperLayer
      : public TrackingUtilities::ConstVectorRange<CDCWireLayer> {
 
    public:
      using Super = TrackingUtilities::ConstVectorRange<CDCWireLayer>;

      CDCWireSuperLayer() : m_innerRefZ(0.0), m_outerRefZ(0.0), m_refTanLambda(0.0)
      {};

      explicit CDCWireSuperLayer(const TrackingUtilities::ConstVectorRange<CDCWireLayer>& wireLayers);

      CDCWireSuperLayer(const CDCWireSuperLayer& wireSuperLayer) = delete;

      CDCWireSuperLayer(CDCWireSuperLayer&& wireSuperLayer) = default;

      void operator=(const CDCWireSuperLayer& wireSuperLayer) = delete;
 
    public:
      static void initialize();


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



      bool isValidILayer(ILayer iLayer) const
      { return 0 <= iLayer and iLayer < int(size()); }

      const CDCWireLayer& getWireLayer(ILayer iLayer) const
      {
        return at(iLayer);
      }



      bool isValidIWire(ILayer iLayer, IWire iWire) const
      { return isValidILayer(iLayer) and getWireLayer(iLayer).isValidIWire(iWire); }

      const CDCWire& getWire(ILayer iLayer, IWire iWire) const
      { return getWireLayer(iLayer).getWire(iWire); }

 


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

      EStereoKind getStereoKind() const
      { return front().getStereoKind(); }

      double getInnerCylindricalR() const
      { return front().getInnerCylindricalR(); }

      double getOuterCylindricalR() const
      { return back().getOuterCylindricalR(); }

      double getMiddleCylindricalR() const
      { return (getOuterCylindricalR() + getInnerCylindricalR()) / 2.0; }
 

      double getInnerRefZ() const
      { return m_innerRefZ; }

      double getOuterRefZ() const
      { return m_outerRefZ; }

      double getRefTanLambda() const
      { return m_refTanLambda; }



      WireNeighborKind getNeighborKind(ILayer iLayer,
                                       IWire iWire,
                                       ILayer iOtherLayer,
                                       IWire iOtherWire) const;

      TrackingUtilities::MayBePtr<const CDCWire> getPrimaryNeighbor(short oClockDirection,
          ILayer iLayer,
          IWire iWire) const
      {
        oClockDirection = TrackingUtilities::modulo(oClockDirection, 12);
        switch (oClockDirection) {
          case 1:
            return getNeighborCWOutwards(iLayer, iWire);
          case 3:
            return getNeighborCW(iLayer, iWire);
          case 5:
            return getNeighborCWInwards(iLayer, iWire);
          case 7:
            return getNeighborCCWInwards(iLayer, iWire);
          case 9:
            return getNeighborCCW(iLayer, iWire);
          case 11:
            return getNeighborCCWOutwards(iLayer, iWire);
          default:
            return nullptr;
        }
      }

      WireNeighborPair getNeighborsOutwards(ILayer iLayer, IWire iWire) const;

      WireNeighborPair getNeighborsInwards(ILayer iLayer, IWire iWire) const;

      TrackingUtilities::MayBePtr<const CDCWire> getNeighborCCWOutwards(ILayer iLayer, IWire iWire) const
      { return getNeighborsOutwards(iLayer, iWire).first; }  // not optimal since a second wire gets fetched additionally

      TrackingUtilities::MayBePtr<const CDCWire> getNeighborCWOutwards(ILayer iLayer, IWire iWire) const
      { return getNeighborsOutwards(iLayer, iWire).second; }  // not optimal since a second wire gets fetched additionally

      TrackingUtilities::MayBePtr<const CDCWire> getNeighborCW(ILayer iLayer, IWire iWire) const
      { return &(getWireLayer(iLayer).getNeighborCW(iWire)); }

      TrackingUtilities::MayBePtr<const CDCWire> getNeighborCCW(ILayer iLayer, IWire iWire) const
      { return &(getWireLayer(iLayer).getNeighborCCW(iWire)); }

      TrackingUtilities::MayBePtr<const CDCWire> getNeighborCCWInwards(ILayer iLayer, IWire iWire) const
      { return getNeighborsInwards(iLayer, iWire).first; }  // not optimal since a second wire gets fetched additionally

      TrackingUtilities::MayBePtr<const CDCWire> getNeighborCWInwards(ILayer iLayer, IWire iWire) const
      { return getNeighborsInwards(iLayer, iWire).second; }  // not optimal since a second wire gets fetched additionally


      TrackingUtilities::MayBePtr<const CDCWire> getSecondaryNeighbor(short oClockDirection,
          ILayer iLayer,
          IWire iWire) const
      {
        oClockDirection = TrackingUtilities::modulo(oClockDirection, 12);
        switch (oClockDirection) {
          case 0:
            return getSecondNeighborTwelveOClock(iLayer, iWire);
          case 1:
            return getSecondNeighborOneOClock(iLayer, iWire);
          case 2:
            return getSecondNeighborTwoOClock(iLayer, iWire);
          case 3:
            return getSecondNeighborThreeOClock(iLayer, iWire);
          case 4:
            return getSecondNeighborFourOClock(iLayer, iWire);
          case 5:
            return getSecondNeighborFiveOClock(iLayer, iWire);
          case 6:
            return getSecondNeighborSixOClock(iLayer, iWire);
          case 7:
            return getSecondNeighborSevenOClock(iLayer, iWire);
          case 8:
            return getSecondNeighborEightOClock(iLayer, iWire);
          case 9:
            return getSecondNeighborNineOClock(iLayer, iWire);
          case 10:
            return getSecondNeighborTenOClock(iLayer, iWire);
          case 11:
            return getSecondNeighborElevenOClock(iLayer, iWire);
          default:
            return nullptr;
        }
      }

      TrackingUtilities::MayBePtr<const CDCWire> getSecondNeighborOneOClock(ILayer iLayer, IWire iWire) const
      { return isValidILayer(iLayer + 2) ? &(getWireLayer(iLayer + 2).getWireWrappedAround(iWire - 1)) : nullptr;  }
 

      TrackingUtilities::MayBePtr<const CDCWire> getSecondNeighborTwoOClock(ILayer iLayer, IWire iWire) const
      { return getNeighborCWOutwards(iLayer, iWire - 1); }

      TrackingUtilities::MayBePtr<const CDCWire> getSecondNeighborThreeOClock(ILayer iLayer, IWire iWire) const
      { return getNeighborCW(iLayer, iWire - 1); }

      TrackingUtilities::MayBePtr<const CDCWire> getSecondNeighborFourOClock(ILayer iLayer, IWire iWire) const
      { return getNeighborCWInwards(iLayer, iWire - 1); }
 

      TrackingUtilities::MayBePtr<const CDCWire> getSecondNeighborFiveOClock(ILayer iLayer, IWire iWire) const
      { return isValidILayer(iLayer - 2) ? &(getWireLayer(iLayer - 2).getWireWrappedAround(iWire - 1)) : nullptr;  }

      TrackingUtilities::MayBePtr<const CDCWire> getSecondNeighborSixOClock(ILayer iLayer, IWire iWire) const
      { return isValidILayer(iLayer - 2) ? &(getWireLayer(iLayer - 2).getWireWrappedAround(iWire)) : nullptr;  }

      TrackingUtilities::MayBePtr<const CDCWire> getSecondNeighborSevenOClock(ILayer iLayer, IWire iWire) const
      { return isValidILayer(iLayer - 2) ? &(getWireLayer(iLayer - 2).getWireWrappedAround(iWire + 1)) : nullptr;  }
 

      TrackingUtilities::MayBePtr<const CDCWire> getSecondNeighborEightOClock(ILayer iLayer, IWire iWire) const
      { return getNeighborCCWInwards(iLayer, iWire + 1); }

      TrackingUtilities::MayBePtr<const CDCWire> getSecondNeighborNineOClock(ILayer iLayer, IWire iWire) const
      { return getNeighborCCW(iLayer, iWire + 1); }

      TrackingUtilities::MayBePtr<const CDCWire> getSecondNeighborTenOClock(ILayer iLayer, IWire iWire) const
      { return getNeighborCCWOutwards(iLayer, iWire + 1); }
 

      TrackingUtilities::MayBePtr<const CDCWire> getSecondNeighborElevenOClock(ILayer iLayer, IWire iWire) const
      { return isValidILayer(iLayer + 2) ? &(getWireLayer(iLayer + 2).getWireWrappedAround(iWire + 1)) : nullptr;  }

      TrackingUtilities::MayBePtr<const CDCWire> getSecondNeighborTwelveOClock(ILayer iLayer, IWire iWire) const
      { return isValidILayer(iLayer + 2) ? &(getWireLayer(iLayer + 2).getWireWrappedAround(iWire)) : nullptr;  }

 
    private:
      double m_innerRefZ;

      double m_outerRefZ;

      double m_refTanLambda;
 
    };
 
  }
}