PndMCTrackInfoTask.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".              *
//****************************************************************************

#pragma once

#include "PndPersistencyTask.h"
#include "PndMCTrackInfo.h"
#include "PndMCTrack.h"
#include "PndPidProbability.h"

#include "TClonesArray.h"

#include <string>
#include <vector>
#include <map>

class TClonesArray;

class PndMCTrackInfoTask : public PndPersistencyTask {
 public:
  PndMCTrackInfoTask();

  virtual ~PndMCTrackInfoTask();

  virtual void SetParContainers();
  virtual InitStatus Init();
  virtual InitStatus ReInit();

  virtual void Exec(Option_t *opt);

  virtual void FinishEvent();
  virtual void FinishTask();

  void SetMaxStage(int stage) { fMaxStage = stage; }

  void SetMaxStageNeutralCheck(int stage) { fMaxStageNeutralCheck = stage; }

  void SetMaxMomentumDifferenceNeutralCheck(double val) { fMaxNeutralMomDiff = val; }

  void AddPointBranchName(TString name) { fPointBranches[name]; }

  void AddTrackingBranchName(TString name) { fTrackingBranches[name]; }

  void AddCandidateBranchName(TString name) { fCandidateBranches[name]; }

  void AddPidBranchName(TString name) { fPidBranches[name]; }

//  void AddBranchName(TString name) { fBranches[name]; }

  void UseKalmanTracks() { fUseKalmanTracks = true; }
  void UsePidInfo() { fUsePidInfo = true; }
  void UseChargeCands() { fUseChargeCands = true; }

  void PrintPrimariesWithDaughters(int stage = 0);

 protected:
  void Register();
  void Reset();

  std::vector<int> GetPIDMothers(int motherID);
  void PrintDaughters(PndMCTrackInfo mother, int stage);
  void AssignPoints();
  void AssignTrackingBranches();
  void AssignCandidateBranches();
  void AssignPidBranches(int mcIndex, int chargedCandIndex);
  //  double GetPidProbability(PndPidProbability *prob, int pdgCode);
  void AssignBranches();
  void FillOutputArray();
  void FillPointInfo();
  void FillTypesNumbers();

  void AssignTClonesArrays(std::map<TString, TClonesArray *> &map);
  void AssignNeutralCand(TClonesArray *neutralbranch);

 private:
  TClonesArray *fMCTracks = nullptr;
  TClonesArray *fMCTrackInfo = nullptr;
  std::map<TString, TClonesArray *> fPointBranches;
  std::map<TString, TClonesArray *> fTrackingBranches;
  std::map<TString, TClonesArray *> fCandidateBranches;
  std::map<TString, TClonesArray *> fPidBranches;
//  std::map<TString, TClonesArray *> fBranches;
  std::map<int, PndMCTrackInfo> fTrackInfo;
  std::vector<int> fMCIdPhoton;  // needed to check for neutral candidates matching with photon momentum

  bool fUseKalmanTracks;
  bool fUsePidInfo;
  bool fUseChargeCands;
  double fMaxNeutralMomDiff;  // Maximum difference of (mcmomentum - recomomentum)/mcmomentum for neutrals
  int fMaxStageNeutralCheck;  // Maximum stage the check for matching neutral cand for photon is done (if equal to MaxStage the test is very time consuming)
  int fMaxStage;              

  ClassDef(PndMCTrackInfoTask, 8);
};