BmnGlobalTracking.h

Go to the documentation of this file.

/* * \file BmnGlobalTracking.h
 * \author Sergey Merts <Sergey.Merts@gmail.com>
 * \date 2014
 * \brief BMN task for global track reconstruction.
 **/
 
#ifndef BmnGlobalTracking_H_
#define BmnGlobalTracking_H_
 
#include "AkimaFunction.h"
#include "BmnCSCHit.h"
#include "BmnCSCStationSet.h"
#include "BmnGemTrack.h"
#include "BmnGlobalTrack.h"
#include "BmnHit.h"
#include "BmnKalmanFilter.h"
#include "BmnNdetEvent.h"
#include "BmnScWallEvent.h"
#include "BmnSiliconHit.h"
#include "BmnSiliconStationSet.h"
#include "BmnTask.h"
#include "BmnTofHit.h"
#include "BmnVertex.h"
#include "CbmKFTrack.h"
#include "CbmMCTrack.h"
#include "CbmStsHit.h"
#include "CbmStsTrack.h"
#include "CbmTofPoint.h"
#include "CbmVertex.h"
#include "FairMCPoint.h"
#include "FairRootManager.h"
#include "FairRunAna.h"
#include "FairRuntimeDb.h"
#include "TClonesArray.h"
#include "TFitResult.h"
#include "TFitResultPtr.h"
#include "TGraph.h"
#include "TH1F.h"
#include "TH2F.h"
#include "TMath.h"
 
#include <TStopwatch.h>
#include <string>
#include <vector>
using namespace std;
 
struct Stage3Key
{
    Int_t chamber;
    std::string particle;
    std::string zone;
 
    Bool_t operator<(const Stage3Key& other) const
    {
        if (chamber != other.chamber)
            return chamber < other.chamber;
        if (particle != other.particle)
            return particle < other.particle;
        return zone < other.zone;
    }
};
 
struct AkimaContainer
{
    std::map<Int_t, AkimaFunction*> dx_stage1_pos;
    std::map<Int_t, AkimaFunction*> dx_stage1_neg;
    std::map<Int_t, AkimaFunction*> dy_stage1_pos;
    std::map<Int_t, AkimaFunction*> dy_stage1_neg;
 
    std::map<Int_t, AkimaFunction*> dx_stage2_mean_pos;
    std::map<Int_t, AkimaFunction*> dx_stage2_mean_neg;
    std::map<Int_t, AkimaFunction*> dy_stage2_mean_pos;
    std::map<Int_t, AkimaFunction*> dy_stage2_mean_neg;
 
    std::map<Int_t, AkimaFunction*> dx_stage2_sigma_pos;
    std::map<Int_t, AkimaFunction*> dx_stage2_sigma_neg;
    std::map<Int_t, AkimaFunction*> dy_stage2_sigma_pos;
    std::map<Int_t, AkimaFunction*> dy_stage2_sigma_neg;
 
    std::map<Stage3Key, AkimaFunction*> dx_stage3_mean;
    std::map<Stage3Key, AkimaFunction*> dx_stage3_sigma;
    std::map<Stage3Key, AkimaFunction*> dy_stage3_mean;
    std::map<Stage3Key, AkimaFunction*> dy_stage3_sigma;
 
    Int_t loaded_count = 0;
};
 
class BmnGlobalTracking : public BmnTask
{
  public:
    /**
     * \brief Constructor.
     */
    BmnGlobalTracking();
 
    /**
     * \brief Destructor.
     */
    virtual ~BmnGlobalTracking();
 
    /**
     * \brief Inherited from FairTask.
     */
    virtual InitStatus Init();
 
    /**
     * \brief Inherited from FairTask.
     */
    virtual void Exec(Option_t* opt);
 
    /**
     * \brief Inherited from FairTask.
     */
    virtual void Finish();
 
    virtual void OnlineWrite(const std::unique_ptr<TTree>& resultTree);
 
    void SetPeriodNumber(Short_t p) { fPeriod = p; }
 
    void SetInnerTracksBranchName(TString name) { fInnerTrackBranchName = name; }
 
  private:
    /*
     * \brief Calculate length of the global track
     */
    Double_t CalculateLength(CbmStsTrack* tr);
 
    // INPUT ARRAYS
    TClonesArray* fCscHits;        //!
    TClonesArray* fTof1Hits;       //!
    TClonesArray* fTof2Hits;       //!
    TClonesArray* fStsHits;        //!
    TClonesArray* fStsTracks;      //!
    TClonesArray* fGlobalTracks;   //!
    BmnScWallEvent* fScWall;       //!
    BmnNdetEvent* fNdet;           //!
 
    TString fInnerTrackBranchName;
 
    Short_t fPeriod;
 
    Int_t fEventNo;   // event counter
 
    CbmVertex* fVertex;   //! vertex information
 
    BmnKalmanFilter* fKalman;   //!
    Double_t fTime;
 
    Long_t fNMatchedTof400;
    Long_t fNMatchedTof700;
    Long_t fNInnerTracks;
    Long_t fNGoodInnerTracks;
 
    AkimaContainer fAkima400;
    AkimaContainer fAkima700;
 
    void PrintStatistics();
 
    BmnStatus MatchingTOF(Bool_t tof400);
    BmnStatus MatchingScWall();
    BmnStatus MatchingNdet();
    map<Float_t, pair<Int_t, Int_t>> FindPairsTof(TClonesArray* tracks, TClonesArray* hits, Bool_t tof400);
 
    Double_t MagFieldIntegral(FairTrackParam& par, Double_t zMin, Double_t zMax, Double_t step);
    BmnStatus UpdateMomentum(BmnGlobalTrack* tr);
 
    void LoadAllAkimaCorrections(const TString& filename, Bool_t isTOF400);
    Float_t GetAkimaCorrection(Int_t chamber,
                               Float_t qp,
                               Bool_t isDx,
                               const TString& stage,
                               Bool_t isTOF400,
                               const TString& particle = "",
                               const TString& zone = "");
    Float_t GetAkimaSigma(Int_t chamber,
                          Float_t qp,
                          Bool_t isDx,
                          const TString& stage,
                          Bool_t isTOF400,
                          const TString& particle = "",
                          const TString& zone = "");
 
    std::string GetRegionFromQP(Float_t qp);
 
    Float_t AdjustQP(Float_t qp, Bool_t isTOF400 = false);
 
    BmnGlobalTracking(const BmnGlobalTracking&);
 
    ClassDef(BmnGlobalTracking, 1);
};
 
#endif /* BmnGlobalTracking_H_ */