PhotonState.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 <top/reconstruction_cpp/RaytracerBase.h>
#include <top/reconstruction_cpp/func.h>
#include <Math/Vector3D.h>
#include <Math/Point3D.h>
 
 
namespace Belle2 {
  namespace TOP {
 
    class PhotonState {
 
    public:
 
      enum EType {
        c_Undefined = 0,     
        c_BarSegment = 1,    
        c_MirrorSegment = 2, 
        c_Prism = 3          
      };
 
      PhotonState()
      {}
 
      PhotonState(const ROOT::Math::XYZPoint& position, const ROOT::Math::XYZVector& direction);
 
      PhotonState(const ROOT::Math::XYZPoint& position, double kx, double ky, double kz);
 
      PhotonState(const ROOT::Math::XYZPoint& position, const ROOT::Math::XYZVector& trackDir, double thc, double fic);
 
      PhotonState& flipKy() {m_ky = -m_ky; return *this;}
 
      static void setMaxPropagationLen(double maxLen) {s_maxLen = maxLen;}
 
      ROOT::Math::XYZPoint getPosition() const {return ROOT::Math::XYZPoint(m_x, m_y, m_z);}
 
      double getX() const {return m_x;}
 
      double getY() const {return m_y;}
 
      double getZ() const {return m_z;}
 
      double getUnfoldedX(double x) const {return func::unfold(x, m_nx, m_A);}
 
      double getUnfoldedY(double y) const {return (func::unfold(y - m_y0, m_ny, m_B) + m_y0);}
 
      double getXD() const {return getUnfoldedX(m_x);}
 
      double getYD() const {return m_yD;}
 
      double getZD() const {return m_zD;}
 
      ROOT::Math::XYZVector getDirection() const {return ROOT::Math::XYZVector(m_kx, m_ky, m_kz);}
 
      double getKx() const {return m_kx;}
 
      double getKy() const {return m_ky;}
 
      double getKz() const {return m_kz;}
 
      double getPropagationLen() const {return m_propLen;}
 
      int getNx() const {return m_nx;}
 
      int getNy() const {return m_ny;}
 
      double getA() const {return m_A;}
 
      double getB() const {return m_B;}
 
      EType getSegmentType() const {return m_type;}
 
      bool getPropagationStatus() const {return m_status;}
 
      bool getTotalReflStatus(double cosTotal) const
      {
        return ((m_nx == 0 or m_cosx < cosTotal) and (m_ny == 0 or m_cosy < cosTotal));
      }
 
      bool isInside(const RaytracerBase::BarSegment& bar) const;
 
      bool isInside(const RaytracerBase::BarSegment& bar, const RaytracerBase::Mirror& mirror) const;
 
      bool isInside(const RaytracerBase::Prism& prism) const;
 
      void propagate(const RaytracerBase::BarSegment& bar);
 
      void propagateSemiLinear(const RaytracerBase::BarSegment& bar, const RaytracerBase::Mirror& mirror);
 
      void propagateExact(const RaytracerBase::BarSegment& bar, const RaytracerBase::Mirror& mirror);
 
      void propagate(const RaytracerBase::Prism& prism);
 
    private:
 
      double m_x = 0; 
      double m_y = 0; 
      double m_z = 0; 
      double m_kx = 0; 
      double m_ky = 0; 
      double m_kz = 0; 
      double m_propLen = 0; 
      int m_nx = 0; 
      int m_ny = 0; 
      double m_cosx = 0; 
      double m_cosy = 0; 
      double m_A = 0; 
      double m_B = 0; 
      double m_y0 = 0; 
      double m_yD = 0; 
      double m_zD = 0; 
      EType m_type = c_Undefined; 
      bool m_status = false; 
      static double s_maxLen; 
    };
 
  } // namespace TOP
} // namespace Belle2