CDCWireSuperLayer.h

/**************************************************************************
 * BASF2 (Belle Analysis Framework 2)                                     *
 * Copyright(C) 2012 - Belle II Collaboration                             *
 *                                                                        *
 * Author: The Belle II Collaboration                                     *
 * Contributors: Oliver Frost                                             *
 *                                                                        *
 * This software is provided "as is" without any warranty.                *
 **************************************************************************/
#pragma once
 
#include <tracking/trackFindingCDC/topology/CDCWireLayer.h>
#include <tracking/trackFindingCDC/topology/WireNeighborPair.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/utilities/VectorRange.h>
#include <tracking/trackFindingCDC/utilities/MayBePtr.h>
 
namespace Belle2 {
  namespace TrackFindingCDC {
 
    class CDCWireSuperLayer
      : public ConstVectorRange<CDCWireLayer> {
 
    public:
      using Super = ConstVectorRange<CDCWireLayer>;
 
      explicit CDCWireSuperLayer(const ConstVectorRange<CDCWireLayer>& wireLayers);
 
      CDCWireSuperLayer(const CDCWireSuperLayer& wireSuperLayer) = delete;
 
      CDCWireSuperLayer(CDCWireSuperLayer&& wireSuperLayer) = default;
 
      void operator=(const CDCWireSuperLayer& wireSuperLayer) = delete;
 
    public:
      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
      {
        // cppcheck-suppress returnTempReference
        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;
 
      MayBePtr<const CDCWire> getPrimaryNeighbor(short oClockDirection,
                                                 ILayer iLayer,
                                                 IWire iWire) const
      {
        oClockDirection = 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;
 
      MayBePtr<const CDCWire> getNeighborCCWOutwards(ILayer iLayer, IWire iWire) const
      { return getNeighborsOutwards(iLayer, iWire).first; }  // not optimal since a second wire gets fetched additionally
 
      MayBePtr<const CDCWire> getNeighborCWOutwards(ILayer iLayer, IWire iWire) const
      { return getNeighborsOutwards(iLayer, iWire).second; }  // not optimal since a second wire gets fetched additionally
 
      MayBePtr<const CDCWire> getNeighborCW(ILayer iLayer, IWire iWire) const
      { return &(getWireLayer(iLayer).getNeighborCW(iWire)); }
 
      MayBePtr<const CDCWire> getNeighborCCW(ILayer iLayer, IWire iWire) const
      { return &(getWireLayer(iLayer).getNeighborCCW(iWire)); }
 
      MayBePtr<const CDCWire> getNeighborCCWInwards(ILayer iLayer, IWire iWire) const
      { return getNeighborsInwards(iLayer, iWire).first; }  // not optimal since a second wire gets fetched additionally
 
      MayBePtr<const CDCWire> getNeighborCWInwards(ILayer iLayer, IWire iWire) const
      { return getNeighborsInwards(iLayer, iWire).second; }  // not optimal since a second wire gets fetched additionally
      MayBePtr<const CDCWire> getSecondaryNeighbor(short oClockDirection,
                                                   ILayer iLayer,
                                                   IWire iWire) const
      {
        oClockDirection = 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;
        }
      }
 
      MayBePtr<const CDCWire> getSecondNeighborOneOClock(ILayer iLayer, IWire iWire) const
      { return isValidILayer(iLayer + 2) ? &(getWireLayer(iLayer + 2).getWireWrappedAround(iWire - 1)) : nullptr;  }
 
 
      MayBePtr<const CDCWire> getSecondNeighborTwoOClock(ILayer iLayer, IWire iWire) const
      { return getNeighborCWOutwards(iLayer, iWire - 1); }
 
      MayBePtr<const CDCWire> getSecondNeighborThreeOClock(ILayer iLayer, IWire iWire) const
      { return getNeighborCW(iLayer, iWire - 1); }
 
      MayBePtr<const CDCWire> getSecondNeighborFourOClock(ILayer iLayer, IWire iWire) const
      { return getNeighborCWInwards(iLayer, iWire - 1); }
 
 
      MayBePtr<const CDCWire> getSecondNeighborFiveOClock(ILayer iLayer, IWire iWire) const
      { return isValidILayer(iLayer - 2) ? &(getWireLayer(iLayer - 2).getWireWrappedAround(iWire - 1)) : nullptr;  }
 
      MayBePtr<const CDCWire> getSecondNeighborSixOClock(ILayer iLayer, IWire iWire) const
      { return isValidILayer(iLayer - 2) ? &(getWireLayer(iLayer - 2).getWireWrappedAround(iWire)) : nullptr;  }
 
      MayBePtr<const CDCWire> getSecondNeighborSevenOClock(ILayer iLayer, IWire iWire) const
      { return isValidILayer(iLayer - 2) ? &(getWireLayer(iLayer - 2).getWireWrappedAround(iWire + 1)) : nullptr;  }
 
 
      MayBePtr<const CDCWire> getSecondNeighborEightOClock(ILayer iLayer, IWire iWire) const
      { return getNeighborCCWInwards(iLayer, iWire + 1); }
 
      MayBePtr<const CDCWire> getSecondNeighborNineOClock(ILayer iLayer, IWire iWire) const
      { return getNeighborCCW(iLayer, iWire + 1); }
 
      MayBePtr<const CDCWire> getSecondNeighborTenOClock(ILayer iLayer, IWire iWire) const
      { return getNeighborCCWOutwards(iLayer, iWire + 1); }
 
 
      MayBePtr<const CDCWire> getSecondNeighborElevenOClock(ILayer iLayer, IWire iWire) const
      { return isValidILayer(iLayer + 2) ? &(getWireLayer(iLayer + 2).getWireWrappedAround(iWire + 1)) : nullptr;  }
 
      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;
 
    };
 
  }
}