PndHelixPropagator.h

Go to the documentation of this file.

//****************************************************************************
//*                   This file is part of PandaRoot.                        *
//*                                                                          *
//*            PandaRoot is distributed under the terms of the               *
//*              GNU General Public License (GPL) version 3,                 *
//*                 copied verbatim in the file "LICENSE".                   *
//*                                                                          *
//*  Copyright (C) 2006 - 2024 FAIR GmbH and copyright holders of PandaRoot  *
//*     The copyright holders are listed in the file "COPYRIGHTHOLDERS".     *
//*               The authors are listed in the file "AUTHORS".              *
//****************************************************************************

/*
 * PndHelixPropagator.h
 *
 *  Created on: Sep 23, 2013
 *  Updated: April 2021
 *      Author: stockman, Gaiser
 */

#ifndef PNDHELIXPROPAGATOR_H_
#define PNDHELIXPROPAGATOR_H_

#include <utility>
#include "TVector3.h"
#include "FairTrackPar.h"
#include "PndPropagator.h"
#include "FairLogger.h"
#include "FairField.h"
#include "FairLogger.h"

class PndHelixPropagator : public PndPropagator {
 protected:
  Double_t fFieldStrength;    
  Double_t fCharge;           
  Bool_t fBackPropagate;      

  Double_t fDeltaPhi;         
  FairField *fMagneticField;  

  Double_t fA, fB, fC, fD;

  Double_t Radius()
  {
    return fInitialMomentum.Perp() / (fFieldStrength * 0.3) * 100;
  }

  TVector3 FindCircleCenter();

 public:
  PndHelixPropagator();             
  PndHelixPropagator(const TString &name, const TString &title);
  PndHelixPropagator(Double_t fieldStrength, TVector3 origin, TVector3 momentum, Double_t charge);
  virtual ~PndHelixPropagator() {}; 

  Double_t FindDistanceToPCAXYProjection(FairTrackPar *TStart);

  Bool_t FindPCA(FairTrackPar* TStart);
  
  Bool_t FindPCAOnHelix();

  Bool_t FindPCAOnStraightLine();

  Bool_t Propagate(FairTrackPar* TStart, FairTrackPar* TEnd, Int_t charge);

  FairTrackPar PropagateToZ(Double_t zpos);

  FairTrackPar PropagateToXYPos(TVector2 xypos);

  FairTrackPar PropagateToS(Double_t arclength);

  FairTrackPar PropagateByAngle(Double_t step);

  Bool_t SetPCAPropagation(Int_t pca_mode = 1,
                           Int_t dir = 1,
                           [[gnu::unused]] FairTrackPar* par = nullptr)
  {
    if (dir >= 0) fBackPropagate = kFALSE;
    else fBackPropagate = kTRUE;
    if (pca_mode != 1) { // TODO: add other propagation modes -> propagation to wire, volume, and plane
      LOG(info) << "PndHelixPropagator::SetPCAPropagation: only propagation to point implemented at the moment";
      return kFALSE;
    }
    fPcaMode = pca_mode;
    return kTRUE;
  }

  Bool_t SetDestinationPlane([[gnu::unused]] const TVector3& v0,
                             [[gnu::unused]] const TVector3& v1,
                             [[gnu::unused]] const TVector3& v2)
  {
    LOG(info) << "PndHelixPropagator: Propagation to plane not implemented yet";
    return kFALSE;
  }

  Bool_t SetOriginPlane([[gnu::unused]] const TVector3& v0, [[gnu::unused]] const TVector3& v1)
  {
    LOG(info) << "PndHelixPropagator: Propagation from plane not implemented yet";
    return kFALSE;
  }

  Bool_t SetDestinationVolume([[gnu::unused]] std::string volName,
                              [[gnu::unused]] Int_t copyNo,
                              [[gnu::unused]] Int_t option)
  {
    LOG(info) << "PndHelixPropagator: Propagation to volume not implemented yet";
    return kFALSE;
  }

  Bool_t SetDestinationLength([[gnu::unused]] Float_t length)
  {
    LOG(info) << "PndHelixPropagator: Propagation to given track length not implemented yet";
    return kFALSE;
  };

  void Init(FairTrackPar* TStart);

  void SetFieldStrength(Double_t field_strength) { fFieldStrength = field_strength; };
  
  void SetMagneticField(FairField *field) { fMagneticField = field; };

  Double_t GetDeltaPhi() { return fDeltaPhi; };

  TVector3 GetPoint() { return fPoint; };

  Int_t GetPcaMode() { return fPcaMode; };

  ClassDef(PndHelixPropagator, 1)
};

#endif /* PNDHELIXPROPAGATOR_H_ */