CDCWireLayer.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/CDCWire.h>
#include <tracking/trackFindingCDC/topology/ISuperLayer.h>
#include <tracking/trackFindingCDC/topology/ILayer.h>
#include <tracking/trackFindingCDC/topology/IWire.h>
#include <tracking/trackFindingCDC/topology/EStereoKind.h>
 
#include <tracking/trackFindingCDC/numerics/ERotation.h>
#include <tracking/trackFindingCDC/utilities/VectorRange.h>
 
namespace Belle2 {
  namespace TrackFindingCDC {
 
    class CDCWireLayer
      : public ConstVectorRange<CDCWire> {
 
    private:
      using Super = ConstVectorRange<CDCWire>;
 
    public:
      static const CDCWireLayer* getInstance(ILayer iCLayer);
 
      static const CDCWireLayer* getInstance(ISuperLayer iSuperLayer, ILayer iLayer);
      explicit CDCWireLayer(const ConstVectorRange<CDCWire>& wireRange);
 
 
      CDCWireLayer(const CDCWireLayer& wireLayer) = delete;
 
      CDCWireLayer(CDCWireLayer&& wireLayer) = default;
 
      void operator=(const CDCWireLayer& wireLayer) = delete;
 
    public:
      void initialize();
 
      ILayer getICLayer() const
      { return front().getICLayer(); }
 
      ILayer getILayer() const
      { return front().getILayer(); }
 
      ISuperLayer getISuperLayer() const
      { return front().getISuperLayer(); }
      ERotation getShift() const
      { return m_shift; }
 
      ERotation getShiftDelta(const CDCWireLayer& baseLayer) const
      { return static_cast<ERotation>(getShift() - baseLayer.getShift()); }
      bool isValidIWire(IWire iWire) const
      { return 0 <= iWire and iWire < IWire(size()); }
 
      const CDCWire& getWire(IWire iWire) const
      {
        // cppcheck-suppress returnTempReference
        return at(iWire);
      }
 
      const CDCWire& getClosestWire(const Vector3D& pos3D) const;
      const CDCWire& getWireWrappedAround(IWire iWire) const
      { return getWire(IWireUtil::wrappedAround(iWire, size())); }
 
      const CDCWire& getNeighborCCW(IWire iWire) const
      { return getWireWrappedAround(iWire + 1); }
 
      const CDCWire& getNeighborCW(IWire iWire) const
      { return getWireWrappedAround(iWire - 1); }
 
      const CDCWire& getSecondNeighborCCW(IWire iWire) const
      { return getWireWrappedAround(iWire + 2); }
 
      const CDCWire& getSecondNeighborCW(IWire iWire) const
      { return getWireWrappedAround(iWire - 2); }
      bool isAxial() const
      { return front().isAxial(); }
 
      EStereoKind getStereoKind() const
      { return front().getStereoKind(); }
 
      double getTanStereoAngle() const
      { return m_tanStereoAngle; }
 
      double getStereoAngle() const
      { return std::atan(getTanStereoAngle()); }
 
      double getMinCylindricalR() const
      { return m_minCylindricalR; }
 
      double getRefCylindricalR() const
      { return m_refCylindricalR; }
 
      double getRefZ() const
      { return m_refZ; }
 
      double getForwardCylindricalR() const
      { return m_forwardCylindricalR; };
 
      double getBackwardCylindricalR() const
      { return m_backwardCylindricalR; };
 
      double getForwardZ() const
      { return m_forwardZ; }
 
      double getBackwardZ() const
      { return m_backwardZ; }
 
      double getInnerCylindricalR() const
      { return m_innerCylindricalR; }
 
      double getOuterCylindricalR() const
      { return m_outerCylindricalR; }
 
      double getRadialCellWidth() const
      { return getOuterCylindricalR() - getInnerCylindricalR(); }
 
      double getLateralCellWidth() const
      { return getOuterCylindricalR() * 2 * M_PI / size(); }
    private:
      ERotation m_shift = ERotation::c_Invalid;
 
 
      double m_tanStereoAngle = 0.0;
 
      double m_minCylindricalR = 0.0;
 
      double m_refCylindricalR = 0.0;
 
      double m_refZ = 0.0;
 
      double m_forwardCylindricalR = 0.0;
 
      double m_backwardCylindricalR = 0.0;
 
      double m_forwardZ = 0.0;
 
      double m_backwardZ = 0.0;
 
 
      double m_innerCylindricalR = 0.0;
 
      double m_outerCylindricalR = 0.0;
 
 
    };
 
  }
}