ARICHTrack.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.                  *
 **************************************************************************/
 
#ifndef ARICHTRACK_H
#define ARICHTRACK_H
 
#include <tracking/dataobjects/ExtHit.h>
#include <arich/dataobjects/ARICHPhoton.h>
#include <arich/dataobjects/ARICHAeroHit.h>
 
#include <Math/Vector2D.h>
 
#include <vector>
 
namespace Belle2 {

 
  class ARICHTrack : public RelationsObject {
  public:

    ARICHTrack()
    {}

    ARICHTrack(ROOT::Math::XYZVector position,
               ROOT::Math::XYZVector momentum)
    {
 
      m_x = (float) position.X();
      m_y = (float) position.Y();
      m_z = (float) position.Z();
      m_momentum = (float) momentum.R();
      momentum = momentum.Unit();
      m_dx = (float) momentum.X();
      m_dy = (float) momentum.Y();
      m_dz = (float) momentum.Z();
 
    }
 

    explicit ARICHTrack(const ARICHAeroHit* aeroHit)
    {
 
      ROOT::Math::XYZVector pos = aeroHit->getPosition();
      m_x = (float) pos.X();
      m_y = (float) pos.Y();
      m_z = (float) pos.Z();
 
      ROOT::Math::XYZVector mom = aeroHit->getMomentum();
      m_momentum = (float) mom.R();
      mom = mom.Unit();
      m_dx = (float) mom.X();
      m_dy = (float) mom.Y();
      m_dz = (float) mom.Z();
    }
 

    explicit ARICHTrack(const ExtHit* extHit)
    {
 
      ROOT::Math::XYZVector pos = extHit->getPosition();
      m_x = (float) pos.X();
      m_y = (float) pos.Y();
      m_z = (float) pos.Z();
 
      ROOT::Math::XYZVector mom = extHit->getMomentum();
      m_momentum = (float) mom.R();
      mom = mom.Unit();
      m_dx = (float) mom.X();
      m_dy = (float) mom.Y();
      m_dz = (float) mom.Z();
    }
 

    void setHapdWindowHit(const ExtHit* extHit)
    {
      ROOT::Math::XYZVector pos = extHit->getPosition();
      m_winX = (float) pos.X();
      m_winY = (float) pos.Y();
      m_hitWin = true;
    }

    void setHapdWindowHit(double x, double y)
    {
      m_winX = (float) x;
      m_winY = (float) y;
      m_hitWin = true;
    }
 

    ROOT::Math::XYZVector getPosition() const { return ROOT::Math::XYZVector(m_x, m_y, m_z);}

    ROOT::Math::XYZVector getDirection() const { return ROOT::Math::XYZVector(m_dx, m_dy, m_dz);}

    double getMomentum() const { return double(m_momentum);}

    bool hitsWindow() const { return m_hitWin;}

    ROOT::Math::XYVector windowHitPosition() const {return ROOT::Math::XYVector(m_winX, m_winY);}
 

    void  setReconstructedValues(ROOT::Math::XYZVector r, ROOT::Math::XYZVector dir, double p)
    {
      m_x = (float) r.X();
      m_y = (float) r.Y();
      m_z = (float) r.Z();
      m_dx = (float) dir.X();
      m_dy = (float) dir.Y();
      m_dz = (float) dir.Z();
      m_momentum = (float) p;
    }

    void addPhoton(ARICHPhoton photon)
    {
      m_photons.emplace_back(photon);
    }

    const std::vector<ARICHPhoton>& getPhotons() const { return m_photons; }
 
  private:
 
    std::vector<ARICHPhoton> m_photons; 
 
    float m_x = 0;     
    float m_y = 0;     
    float m_z = 0;     
    float m_dx = 0;   
    float m_dy = 0;   
    float m_dz = 0;   
    float m_momentum;        
 
    float m_winX = 0;     
    float m_winY = 0;     
    bool m_hitWin = 0;    
 
    ClassDef(ARICHTrack, 3); 
 
  };

} // namespace Belle2
 
#endif // ARICHTRACK_H