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

#ifndef PndSTETask_H_
#define PndSTETask_H_

#include "FairTask.h"
#include "FairMultiLinkedData.h"
#include "PndRiemannTrack.h"
#include "PndSTESettings.h"

class TClonesArray;
class FairMultiLinkedData;

class PndSTETask : public FairTask, public PndSTESettings {
 public:
  PndSTETask() : FairTask("Mvd Tracker Task"){};

  virtual ~PndSTETask(){};

  virtual InitStatus Init();

  virtual void Exec(Option_t *opt);

  virtual void FinishEvent();

  void SetPersistence(bool val) { fPersistence = val; };

  void SetInputTrackBranchName(TString trackName) { fInputTrackBranchName = trackName; };

  void SetInputTrackCandBranchName(TString trackName) { fInputTrackCandBranchName = trackName; };

  void SetInputRiemannTrackBranchName(TString trackName) { fInputRiemannTrackBranchName = trackName; };

  void SetOutputBranchNamePrefix(TString trackName) { fOutBranchNamePrefix = trackName; };

  // void SetRunTimeBased(bool val) { fRunTimeBased = val; };

  // void RemoveShortTracks(bool val) { fRemoveShortTracks = val; };

  // void FilterTracks(std::vector<TClonesArray *>, std::vector<TClonesArray *>, std::vector<TClonesArray *>);

  void InitHitArray(TString branchName);

  void InitTrackArray(TString branchName);

  void InitRiemannTrackArray(TString branchName);

  void InitTrackCandArray(TString branchName);

  void AddHitBranch(TString branchName) { fHitBranchName.push_back(branchName); };

 private:
  bool fPersistence = true;

  // double fClusterTime = 250.0;

  // bool fRunTimeBased = false;

  // bool fRemoveShortTracks = true;

  TString fOutBranchNamePrefix = "SttExtrapolated"; // Default output track branchname prefix
  TString fInBranchNamePrefix = "NoNameGiven";      // Default input track branch name prefix

  std::vector<TString> fHitBranchName; // Vector of input hit branch names

  std::vector<TClonesArray *> fMvdHitsPixelArray; // Input Mvd Hit Pixel Array
  std::vector<TClonesArray *> fMvdHitsStripArray; // Input Mvd Hit Strip Array
  std::vector<TClonesArray *> fGemHitsArray;      // Input Gem hit array
  std::vector<TClonesArray *> fBtofHitsArray;     // Input Btof array

  std::vector<TClonesArray *> fPndTrackCandArray;    // Input track cand branch from previous tracking
  std::vector<TClonesArray *> fPndTrackArray;        // Input track branch from previous tracking
  std::vector<TClonesArray *> fPndRiemannTrackArray; // Input RiemannTrack branch from previous tracking

  // Output branches
  TClonesArray *fOutTrackArray;        // Output track array
  TClonesArray *fOutTrackCandArray;    // Output track cand array
  TClonesArray *fOutRiemannTrackArray; // Output Riemann track array

  // Input branches
  TString fInputTrackBranchName;        // Input track branch name
  TString fInputTrackCandBranchName;    // Input track cand branch name
  TString fInputRiemannTrackBranchName; // Input Riemann track branch name

  TClonesArray *fEventHeader;

  double fSumTime; // For timing information

  // The three following vectors of TClones arrays are used if the tracks are filtered
  // TClonesArray *fPndTrackCandFileteredArray;   // Input track cand branch from previous tracking
  // TClonesArray *fPndRiemannTrackFilteredArray; // Input RiemannTrack branch from previous tracking
  // TClonesArray *fPndTrackFilteredArray;        // Input track branch from previous tracking
  // std::vector<TClonesArray *> fFilteredArrays; // Vector to put the previous three arrays in

  ClassDef(PndSTETask, 1);
};

#endif /*PndSTETask_H_*/