PndMCTrackInfo.h

Go to the documentation of this file.

// -------------------------------------------------------------------------
// -----                      PndMCTrackInfo header file                   -----
// -----                  Created 16/09/19  by T.Stockmann             -----
// -------------------------------------------------------------------------

#ifndef PNDMCTRACKINFO_H
#define PNDMCTRACKINFO_H 1

#include "FairMultiLinkedData_Interface.h"
#include "PndPidProbability.h"

#include "TVector3.h"
#include <iostream>
#include <map>

class PndMCTrackInfo : public FairMultiLinkedData_Interface {

 public:
  PndMCTrackInfo();

  virtual ~PndMCTrackInfo();

  void Print(std::ostream &out = std::cout);

  friend std::ostream &operator<<(std::ostream &out, PndMCTrackInfo &track)
  {
    track.Print(out);
    return out;
  }

  std::vector<int> GetDaughters();
  TVector3 GetDecayVertex() const { return fDecayVertex; }
  Double_t GetDecayTime() const { return fDecayTime; }

  Int_t GetStage() const { return fStage; }

  std::vector<int> GetPIDMothers() const { return fPIDMothers; }

  std::vector<int> GetPIDDaughters() const { return fPIDDaughters; }

  int GetPID() const { return fPID; }

  Int_t GetNHits(TString branchName);

  int GetMVDPoints() const { return fMVDPoints; }
  int GetSTTPoints() const { return fSTTPoints; }
  int GetGEMPoints() const { return fGEMPoints; }
  int GetFTSPoints() const { return fFTSPoints; }
  int GetTotalPoints() const { return fTotalPoints; }

  int GetTypeCount(int type)
  {
    if (fTypeCount.count(type) > 0) {
      return fTypeCount[type];
    } else {
      return -1;
    }
  };

  TVector2 GetDeltaMomentum(int type)
  {
    TVector2 result;
    if (fMomentumDifference.count(type) > 0) {
      return fMomentumDifference[type];
    }
    return result;
  }

  PndPidProbability GetPidProbability(int type)
  {
    PndPidProbability result;
    if (fPidProb.count(type) > 0) {
      return fPidProb[type];
    }
    return result;
  }

  // Setters
  void SetPID(int pid) { fPID = pid; }
  void AddDaughter(FairLink doughter);
  void AddPIDDaughter(int pid) { fPIDDaughters.push_back(pid); }
  void SetPIDMothers(std::vector<int> pid)
  {
    fPIDMothers = pid;
    fStage = fPIDMothers.size();
  }
  void SetDecayVertex(TVector3 vertex) { fDecayVertex = vertex; }
  void SetDecayTime(Double_t time) { fDecayTime = time; }
  void SetRecoMomentum(int branchType, TVector3 value) { fMomentumReco[branchType] = value; } // branchType typeID of branch containing the reconstructed track
  void SetDeltaMomentum(int branchType, double pt, double pl) { fMomentumDifference[branchType] = TVector2(pt, pl); }; // mc momentum - reco momentum
  void SetPidProbability(int branchType, PndPidProbability &value) { fPidProb[branchType] = value; }

  void FillPoints();
  void FillTypeCounts();

 protected:
 private:
  TVector3 fDecayVertex;
  Double_t fDecayTime;
  int fPID;
  std::vector<int> fPIDMothers;
  std::vector<int> fPIDDaughters;
  std::vector<int> fDaughters;
  Int_t fStage;
  Int_t fMVDPoints;
  Int_t fSTTPoints;
  Int_t fGEMPoints;
  Int_t fFTSPoints;
  Int_t fTotalPoints;
  std::map<int, TVector3> fMomentumReco;
  std::map<int, TVector2> fMomentumDifference; //< difference between p transversal and p longitudinal between reco track and MC track
  std::map<int, PndPidProbability> fPidProb;   //< pid probability from different algorithms

  std::map<int, int> fTypeCount; 

  ClassDef(PndMCTrackInfo, 5);
};

#endif