Helix.h

/*
 * HalHelix.h
 *
 *  Created on: 30-04-2022
 *      Author: Daniel Wielanek
 *      E-mail: daniel.wielanek@gmail.com
 *      Warsaw University of Technology, Faculty of Physics
 *      Based on AlixHelix paremetrizatioin with const Bz
 *      (https://github.com/alisw/AliRoot/blob/master/STEER/STEER/AliHelix.h)
 *      and MpdHelix
 *      (https://git.jinr.ru/hal/mpdroot//mpdbase/MpdHelix.h)
 */
#ifndef HALHELIX_H_
#define HALHELIX_H_
 
#include "HelixBase.h"
 
namespace Hal {
  class HelixZ : public HelixBase {
  public:
    HelixZ();
    HelixZ(const TVector3& x, const TVector3& mom, Double_t charge, Double_t conversion = 0.);
    inline void PathLength(Double_t r, Double_t& s1, Double_t& s2) const { BasePathLength(r, s1, s2); }
    inline void PathLength(Double_t r, Double_t x, Double_t y, Double_t& s1, Double_t& s2) const {
      BasePathLength(r, x, y, s1, s2);
    }
    inline void SetParams(const TVector3& x, const TVector3& mom, Double_t charge, Double_t conversion = 0.) {
      BaseSetParams(x, mom, charge, conversion);
    }
    inline void EvaluateFull(Double_t s, TVector3& mom, TVector3& pos) const { BaseFullEval(s, mom, pos); }
    inline Double_t GetXcenter() const { return BaseGetXcenter(); };
    inline Double_t GetYcenter() const { return BaseGetYcenter(); };
    inline Double_t GetZcenter() const { return 0; };
    inline Double_t GetStartX() const { return BaseGetStartX(); };
    inline Double_t GetStartY() const { return BaseGetStartY(); };
    inline Double_t GetStartZ() const { return BaseGetStartZ(); };
    inline Double_t PathLength(const TVector3& point, Bool_t scanPeriods = kTRUE) const {
      return BasePathLength(point, scanPeriods);
    }
    Double_t PathLength(Double_t x, Double_t y) const { return BasePathLength(x, y); }
    TVector3 EvalPos(Double_t s) const { return BasePosition(s); }
    TVector3 EvalMom(Double_t s) const { return BaseMomentum(s); };
    TVector3 GetStartPoint() const { return BaseGetStartPoint(); };
    inline Int_t Intersection(Double_t R, TVector3& x1, TVector3& x2) const { return BaseIntersection(R, x1, x2); }
    HelixZ& operator=(const HelixZ& helix);
    void Shift(Double_t x, Double_t y, Double_t z);
    void Print(Option_t* /*opt*/ = "") const { BasePrint(); };
    virtual ~HelixZ() {};
    ClassDef(HelixZ, 1)
  };
 
  class HelixX : public HelixBase {
  public:
    HelixX();
    HelixX(const TVector3& x, const TVector3& mom, Double_t charge, Double_t conversion = 0.);
    inline void PathLength(Double_t r, Double_t& s1, Double_t& s2) const { BasePathLength(r, s1, s2); }
    inline void PathLength(Double_t r, Double_t y, Double_t z, Double_t& s1, Double_t& s2) const {
      BasePathLength(r, y, z, s1, s2);
    }
    inline void SetParams(const TVector3& x, const TVector3& mom, Double_t charge, Double_t conversion = 0.) {
      BaseSetParams(x.Y(), x.Z(), x.X(), mom.Y(), mom.Z(), mom.X(), charge, conversion);
    }
    inline void EvaluateFull(Double_t s, TVector3& mom, TVector3& pos) const {
      BaseFullEval(s, mom, pos);
      mom.SetXYZ(mom.Z(), mom.X(), mom.Y());
      pos.SetXYZ(pos.Z(), pos.X(), pos.Y());
    }
    inline Double_t GetXcenter() const { return 0; };
    inline Double_t GetYcenter() const { return BaseGetXcenter(); };
    inline Double_t GetZcenter() const { return BaseGetYcenter(); };
    inline Double_t GetStartX() const { return BaseGetStartZ(); };
    inline Double_t GetStartY() const { return BaseGetStartX(); };
    inline Double_t GetStartZ() const { return BaseGetStartY(); };
    inline Double_t PathLength(TVector3 point, Bool_t scanPeriods = kTRUE) const {
      point.SetXYZ(point.Y(), point.Z(), point.X());
      return BasePathLength(point, scanPeriods);
    }
    Double_t PathLength(Double_t y, Double_t z) const { return BasePathLength(y, z); }
    TVector3 EvalPos(Double_t s) const {
      TVector3 res = BasePosition(s);
      res.SetXYZ(res.Z(), res.X(), res.Y());
      return res;
    }
    TVector3 EvalMom(Double_t s) const {
      TVector3 res = BaseMomentum(s);
      res.SetXYZ(res.Z(), res.X(), res.Y());
      return res;
    };
    TVector3 GetStartPoint() const {
      TVector3 res = BaseGetStartPoint();
      res.SetXYZ(res.Z(), res.X(), res.Y());
      return res;
    };
    inline Int_t Intersection(Double_t R, TVector3& x1, TVector3& x2) const {
      Int_t res = BaseIntersection(R, x1, x2);
      x1.SetXYZ(x1.Z(), x1.X(), x1.Y());
      x2.SetXYZ(x2.Z(), x2.X(), x2.Y());
      return res;
    }
    HelixX& operator=(const HelixX& helix);
    void Print(Option_t* /*opt*/ = "") const {};
    void Shift(Double_t x, Double_t y, Double_t z);
    virtual ~HelixX() {};
    ClassDef(HelixX, 1)
  };
 
  class HelixY : public HelixBase {
  public:
    HelixY();
    HelixY(const TVector3& x, const TVector3& mom, Double_t charge, Double_t conversion = 0.);
    inline void PathLength(Double_t r, Double_t& s1, Double_t& s2) const { BasePathLength(r, s1, s2); }
    inline void PathLength(Double_t r, Double_t z, Double_t x, Double_t& s1, Double_t& s2) const {
      BasePathLength(r, z, x, s1, s2);
    }
    inline void SetParams(const TVector3& x, const TVector3& mom, Double_t charge, Double_t conversion = 0.) {
      BaseSetParams(x.Z(), x.X(), x.Y(), mom.Z(), mom.X(), mom.Y(), charge, conversion);
    }
    inline void EvaluateFull(Double_t s, TVector3& mom, TVector3& pos) const {
      BaseFullEval(s, mom, pos);
      mom.SetXYZ(mom.Y(), mom.Z(), mom.X());
      pos.SetXYZ(pos.Y(), pos.Z(), pos.X());
    }
 
    inline Double_t GetXcenter() const { return BaseGetYcenter(); };
    inline Double_t GetYcenter() const { return 0; };
    inline Double_t GetZcenter() const { return BaseGetXcenter(); };
    inline Double_t GetStartX() const { return BaseGetStartY(); };
    inline Double_t GetStartY() const { return BaseGetStartZ(); };
    inline Double_t GetStartZ() const { return BaseGetStartX(); };
    inline Double_t PathLength(const TVector3& point, Bool_t scanPeriods = kTRUE) const {
      TVector3 p(point.Z(), point.X(), point.Y());
      return BasePathLength(p, scanPeriods);
    }
    Double_t PathLength(Double_t z, Double_t x) const { return BasePathLength(z, x); }
    TVector3 EvalPos(Double_t s) const {
      TVector3 res = BasePosition(s);
      res.SetXYZ(res.Y(), res.Z(), res.X());
      return res;
    }
    TVector3 EvalMom(Double_t s) const {
      TVector3 res = BaseMomentum(s);
      res.SetXYZ(res.Y(), res.Z(), res.X());
      return res;
    };
    TVector3 GetStartPoint() const {
      TVector3 res = BaseGetStartPoint();
      res.SetXYZ(res.Y(), res.Z(), res.X());
      return res;
    };
    inline Int_t Intersection(Double_t R, TVector3& x1, TVector3& x2) const {
      Int_t res = BaseIntersection(R, x1, x2);
      x1.SetXYZ(x1.Y(), x1.Z(), x1.X());
      x2.SetXYZ(x2.Y(), x2.Z(), x2.X());
      return res;
    }
    HelixY& operator=(const HelixY& helix);
    void Print(Option_t* /*opt*/ = "") const { BasePrint(); };
    void Shift(Double_t x, Double_t y, Double_t z);
    virtual ~HelixY() {};
    ClassDef(HelixY, 1)
  };
 
#ifdef HALHELIX_X
  typedef HelixX Helix;
#else
#ifdef HALHELIX_Y
  typedef HelixY Helix;
#else
  typedef HelixZ Helix;
#endif
#endif
}  // namespace Hal
#endif /* HALHELIX_H_ */