CDCWireLayer.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/CDCWire.h>
#include <cdc/topology/ISuperLayer.h>
#include <cdc/topology/ILayer.h>
#include <cdc/topology/IWire.h>
#include <cdc/topology/EStereoKind.h>
 
#include <tracking/trackingUtilities/numerics/ERotation.h>
#include <tracking/trackingUtilities/utilities/VectorRange.h>
 
namespace Belle2 {
  namespace CDC {

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

      static const CDCWireLayer* getInstance(ILayer iCLayer);

      static const CDCWireLayer* getInstance(ISuperLayer iSuperLayer, ILayer iLayer);

      explicit CDCWireLayer(const TrackingUtilities::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(); }

 


      TrackingUtilities::ERotation getShift() const
      { return m_shift; }

      TrackingUtilities::ERotation getShiftDelta(const CDCWireLayer& baseLayer) const
      { return static_cast<TrackingUtilities::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 ROOT::Math::XYZVector& 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:

      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;

      TrackingUtilities::ERotation m_shift = TrackingUtilities::ERotation::c_Invalid;
    };
 
  }
}