FairTrackParH.h

Go to the documentation of this file.

/********************************************************************************
 *    Copyright (C) 2014 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH    *
 *                                                                              *
 *              This software is distributed under the terms of the             *
 *              GNU Lesser General Public Licence (LGPL) version 3,             *
 *                  copied verbatim in the file "LICENSE"                       *
 ********************************************************************************/
// Class for the representation of a track as helix (SC system)
//
// Authors: M. Al-Turany, A. Fontana, L. Lavezzi and A. Rotondi
//
//
// GEANE parameters (q/p, lambda, phi, y_perp, z_perp) of Helix track
// The Helix can be constructed using the Helix parameter (1/p, lambda, phi,y_perp,z_perp) in SC reference
// and the covariance matrix. Or using position and momentum in LAB referance.

#ifndef FAIRSTSTRACKPARH
#define FAIRSTSTRACKPARH 1

#include <Rtypes.h>        // for THashConsistencyHolder, ClassDef
#include <RtypesCore.h>    // for Double_t, Int_t, Option_t
#include <TVector3.h>      // for TVector3
#include "FairTrackPar.h"  // for FairTrackPar
class FairTrackParP;  // lines 25-25
class TBuffer;
class TClass;
class TMemberInspector;


class FairTrackParH : public FairTrackPar
{
  public:
    FairTrackParH();

    FairTrackParH(Double_t x,
                  Double_t y,
                  Double_t z,
                  Double_t lambda,
                  Double_t phi,
                  Double_t qp,
                  Double_t CovMatrix[15]);

    FairTrackParH(TVector3 pos, TVector3 Mom, TVector3 posErr, TVector3 MomErr, Int_t q);

    FairTrackParH(FairTrackPar& Trkbase);

    // FairTrackParH(FairTrackParH &Trk);

    FairTrackParH(FairTrackParP* parab, Int_t& ierr);

    virtual ~FairTrackParH();

    //   void Print();
    virtual void Print(Option_t* option = "") const;

    Double_t GetLambda() { return fLm; };
    Double_t GetPhi() { return fPhi; };
    Double_t GetDLambda(); 
    Double_t GetDPhi();    
    void GetCov(Double_t* Cov)
    {
        for (Int_t i = 0; i < 15; i++) {
            Cov[i] = fCovMatrix[i];
        }
    }
    void GetCovQ(Double_t* CovQ);
    // MARS
    void GetMARSCov(Double_t Cov66[6][6])
    {
        for (Int_t i = 0; i < 6; i++)
            for (Int_t j = 0; j < 6; j++) {
                Cov66[i][j] = fCovMatrix66[i][j];
            }
    }
    Double_t GetDX_sc();                 
    Double_t GetDY_sc();                 
    Double_t GetDZ_sc();                 
    Double_t GetX_sc() { return fX_sc; } 
    Double_t GetY_sc() { return fY_sc; } 
    Double_t GetZ_sc() { return fZ_sc; } 
                                         // Double_t GetDPx() ;   /**Get error in Px (in SC frame)*/
                                         // Double_t GetDPy() ;   /**Get error in Py (in SC frame)*/
                                         // Double_t GetDPz() ;   /**Get error in Pz (in SC frame)*/
                                         //  Double_t GetDQp() ;   /**Get error in Q/P*/
    Double_t GetX();                     
    Double_t GetY();                     
    Double_t GetZ();                     
    void SetLambda(Double_t Lm) { fLm = Lm; };
    void SetPhi(Double_t Phi) { fPhi = Phi; };

    void SetDLambda(Double_t DLm) { fDLm = DLm; };
    void SetDPhi(Double_t DPhi) { fDPhi = DPhi; };

    void SetX_sc(Double_t x) { fX_sc = x; } 
    void SetY_sc(Double_t y) { fY_sc = y; } 
    void SetZ_sc(Double_t z) { fZ_sc = z; } 
    void SetCov(Double_t* Cov)
    {
        for (Int_t i = 0; i < 15; i++) {
            fCovMatrix[i] = Cov[i];
        }
    }
    void SetTrackPar(Double_t x,
                     Double_t y,
                     Double_t z,
                     Double_t Px,
                     Double_t Py,
                     Double_t Pz,
                     Int_t Q,
                     Double_t CovMatrix[15]);

    void
        SetTrackPar(Double_t x, Double_t y, Double_t z, Double_t pq, Double_t lm, Double_t phi, Double_t CovMatrix[15]);
    void Reset();
    ClassDef(FairTrackParH, 1);

  private:
    Double_t fLm;
    Double_t fPhi;
    Double_t fDLm;
    Double_t fDPhi;
    Double_t fX_sc, fY_sc, fZ_sc;
    Double_t fDX_sc, fDY_sc, fDZ_sc;
    Double_t fCovMatrix[15];
    // in MARS
    Double_t fCovMatrix66[6][6];

    void CalCov();


    Double_t cLm, sLm, cphi, sphi;   
};

#endif