softrig/PndSoftTriggerTask.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 PndSoftTriggerTask_H
#define PndSoftTriggerTask_H 1

#include "FairTask.h"
#include "FairRootManager.h"

#include <map>
#include <vector>
#include <string>
#include "TLorentzVector.h"
#include "RhoCandList.h"
#include "TDatabasePDG.h"
#include "RhoVtxPoca.h"

class TClonesArray;
class TObjectArray;
class TH1F;
class TH2F;

class RhoMassParticleSelector;
class RhoEnergyParticleSelector;
class RhoMomentumParticleSelector;
class PndAnalysis;
class RhoCandList;
class RhoTuple;
class RhoCandidate;
class PndEventShape;
class TDatabasePDG;
class PndRhoTupleQA;
class PndSoftTriggerLine;

class PndSoftTriggerTask : public FairTask {

 public:
  // *** Default constructor
  PndSoftTriggerTask(double pmom, int mode = 0, int runnum = 0, TString trigfilename = "");

  // *** Destructor
  ~PndSoftTriggerTask();

  // *** Virtual method Init
  virtual InitStatus Init();

  // *** Virtual method Exec
  virtual void Exec(Option_t *opt);

  virtual void Finish();

  // *** set default settings for fast and full sim
  void SetFastSimDefaults();
  void SetFullSimDefaults();

  // *** read selection configuration from file
  void SetConfigurationFile(TString fname) { fCfgFileName = fname; }

  // switches between mass window only of full selection (selection defined in cfg file)
  // 0: detailed selection turned off
  // 1: exclusive mode (modes w/o detailed cut definitions are rejected)
  // 2: open mode (modes w/o detailed cut definitions just have to fulfill their mass window criterion)
  void ApplyFullSelection(int selmode = 1) { fApplyFullSelection = selmode; }

  // *** set max number of sigmas deviation for tag
  void SetTagNSigMode(int mode, double nsig);
  void SetTagNSigAll(double nsig);
  void SetAuxNSig(double nsig) { fNsigAux = nsig; }       // n sigma cut for KS, pi0, eta
  void SetDstMDiffCut(double cut) { fDstMDiffCut = cut; } // cut on delta M(D*, D); default = 10. GeV/c^2

  // *** set selection parameters for QA tuple
  void SetPi0QASelection(double min, double max)
  {
    fPi0QaMin = min;
    fPi0QaMax = max;
  }
  void SetKs0QASelection(double min, double max)
  {
    fKs0QaMin = min;
    fKs0QaMax = max;
  }
  void SetEtaQASelection(double min, double max)
  {
    fEtaQaMin = min;
    fEtaQaMax = max;
  }

  void SetQASelectionDefaults();

  // *** set mean and sigma for tagging algos
  void SetPi0SignalParams(double mean, double sigma)
  {
    fPi0Mean = mean;
    fPi0Sigma = sigma;
  }
  void SetKs0SignalParams(double mean, double sigma)
  {
    fKs0Mean = mean;
    fKs0Sigma = sigma;
  }
  void SetEtaSignalParams(double mean, double sigma)
  {
    fEtaMean = mean;
    fEtaSigma = sigma;
  }

  void SetSignalParamsDefaults();

  // *** pre selection of neutral and charged + PID cut
  void SetGammaMinE(double min) { fGammaMinE = min; }
  void SetTrackMinP(double min) { fTrackMinP = min; }
  void SetInitialPidCut(double cut) { fIniPidCut = cut; }

  // *** modifiers for PID selection string
  void SetPidAlgoAll(TString algo);

  void SetPidAlgoElectron(TString algo) { fAlgoElectron = algo; }
  void SetPidAlgoMuon(TString algo) { fAlgoMuon = algo; }
  void SetPidAlgoPion(TString algo) { fAlgoPion = algo; }
  void SetPidAlgoKaon(TString algo) { fAlgoKaon = algo; }
  void SetPidAlgoProton(TString algo) { fAlgoProton = algo; }

  // *** Switch Tagging methods
  void SetTagAll(bool tag = true);
  // mode code as in triggerlines configuration file
  void SetTagMode(int mode, bool tag = true);

  // *** Enable/Disable QA output
  void SetQAPi0(bool qa = true) { fQAPi0 = qa; }
  void SetQAEta(bool qa = true) { fQAEta = qa; }
  void SetQAKs0(bool qa = true) { fQAKs0 = qa; }
  void SetQAMc(bool qa = true) { fQAMc = qa; }
  void SetQAMctOnly(bool qa = true) { fQAMctOnly = qa; }

  void SetQAEvent(bool qa = true) { fQAEvent = qa; }

  void SetQAAll(bool qa = true);
  // mode code as in triggerlines configuration file
  void SetQAMode(int mode, bool qa = true);

  // passed to PndAnalysis: this also allows mct match, when some soft photons are missing in decay
  void McMatchAllowPhotos(int maxn = 1, double thresh = 0.05)
  {
    fPhotosMax = maxn;
    fPhotosThresh = thresh;
  }

  void SetVerbose(int verb = 10) { fVerbose = verb; }

 protected:
 private:
  // *** List preparation methods
  void FillGlobalLists();
  bool ReadConfiguration();
  bool ReadTriggerLines();

  // *** methods for full candidate selection
  int DoCombinatorics(RhoCandList &l, PndSoftTriggerLine *tl); // do combinatorics for certain trigger line
  void CombineList(RhoCandList &l, int mothpdg, int amothpdg, std::vector<int> &idx, std::vector<int> &aidx, bool cc = false);
  int AntiPdg(int pdg);                                            // gives pdg code of antiparticle if exists
  double GetVarValue(RhoCandidate *c, int id);                     // fill single candidate variable with index id
  void FillVarArray(RhoCandidate *c, int id, Bool_t tmva = false); // fill candidate variable array for selection
  void FillEventShapeVarArray();                                   // fill event shape variable array for selection

  bool AcceptCandidate(int mode, RhoCandidate *c, RhoParticleSelectorBase *sel = nullptr); // accept candidate for full selection
  bool AcceptDstCut(RhoCandidate *c);                                                      // accept the D* mass diff cut?
  double GetPocaVtx(RhoCandidate *c, double &dist, double &ctau);
  void GetAngles(RhoCandidate *c, double &oang, double &decang);

  // *** some helper functions
  int SelectTruePid(RhoCandList &l);
  int SelectPidProb(RhoCandList &l, int pididx, double cut);
  int MultPidProb(RhoCandList &l, int pididx, double prob);
  double DbMass(TString name)
  {
    if (fPdg->GetParticle(name))
      return fPdg->GetParticle(name)->Mass();
    else
      return 0.;
  }
  int SplitString(TString s, TString delim, TString *toks, int maxtoks);
  int DetermineRecoilMode(int &mode);
  TLorentzVector BoostCms(TLorentzVector in);
  int CodeVariable(TString v);

  // *** Created necessary composites
  int CreateKs0Cands(RhoTuple *n);

  // *** General tagging method
  int TagMode(PndSoftTriggerLine *tl, int &npre);

  // ----------------------------
  // *** global vars
  int fVerbose;        // create verbose output
  int fMode;           // the signal or background mode code, to be set in the constructor
  int fRecoilMode;     // recoil mode code (0 = %, 1=gamma, 2=pi0, 3=eta, 4=2pi0, 5=2eta, 6=pi+pi-, 7=2pipi0, 8=K+K-, 9=K0 K0b)
  int fRecoilCnt;      // recoil counter (1*Ngamma + 10*Npi0 + 100*Npi+ + 1000*NK+ + 10000*NK0 + 100000*Neta)
  int fEvtCount;       // global event counter
  int fRunNum;         // run number
  int fSigCount;       // counter, unused for the time being
  double fNsigTag;     // max number of sigmas deviation of candidate to be tagged
  double fNsigAux;     // max number of sigmas deviation for auxilliary particle = pi0, K_S, eta
  double fDstMDiffCut; // optional upper limit cut for D* -> DX decays on M(D*) - M(D) (explicit PDG codes 413, 423, 433)

  TString fCfgFileName;     // file containing the detailed selection cuts
  TString fTriggerFileName; // file containing the trigger setup
  Int_t fPhotosMax;         // passed over to PndAnalysis for MC match with photos on
  Double_t fPhotosThresh;   // passed over to PndAnalysis for MC match with photos on

  int fApplyFullSelection; // 0: detailed selection turned off
                           // 1: exclusive mode (modes w/o detailed cut definitions are rejected)
                           // 2: open mode (modes w/o detailed cut definitions just have to fulfill their mass window criterion)

  // *** initial pbar p system info
  TLorentzVector fIniP4;
  double fEcm;
  double fPbarMom;
  TVector3 fPrimVtx; // primary vertex estimate of all charged tracks by RhoVtxPoca
  double fPrimVtxQa; // and primary vtx quality

  // ----------------------------
  // *** flags for enable/disable QA ntuple output
  bool fQAPi0;     // QA tuple for pi0
  bool fQAEta;     // QA tuple for eta
  bool fQAKs0;     // QA tuple for KS
  bool fQAEvent;   // QA tuple for event (with tag info)
  bool fQAMc;      // QA tuple for MC lists
  bool fQAMctOnly; // store QA info only for MCT

  // ----------------------------
  // *** parameters for ntuple QA window
  double fPi0QaMin; // min value for pi0 selection
  double fPi0QaMax; // max value for pi0 selection

  double fEtaQaMin; // min value for eta(gg) selection
  double fEtaQaMax; // max value for eta(gg) selection

  double fKs0QaMin; // min value for Ks selection
  double fKs0QaMax; // max value for Ks selection

  // ----------------------------
  // *** signal parameters for different channels
  double fPi0Mean;  // mean value for pi0 signal
  double fPi0Sigma; // sigma value for pi0 signal

  double fEtaMean;  // mean value for eta(gg) signal
  double fEtaSigma; // sigma value for eta(gg) signal

  double fKs0Mean;  // mean value for Ks signal
  double fKs0Sigma; // sigma value for Ks signal

  // *** general cuts
  double fGammaMinE; // minimum energy for gamma candidates
  double fPi0MinE;   // minimum energy for pi0 candidates
  double fEtaMinE;   // minimum energy for eta candidates
  double fTrackMinP; // minimum momentum for charged candidates
  double fIniPidCut; // Tightness of initial PID (cut on probability)

  // *** global mass selectors
  RhoMassParticleSelector *fPi0Sel;    // pi0 selector (g g)
  RhoMassParticleSelector *fPi0PreSel; // pi0 pre selector

  RhoMassParticleSelector *fEtaSel;    // eta selector (g g)
  RhoMassParticleSelector *fEtaPreSel; // eta pre selector

  RhoMassParticleSelector *fKs0Sel;    // Ks0 selector (pi pi)
  RhoMassParticleSelector *fKs0PreSel; // Ks0 pre selector

  // *** global kin selectors
  RhoMomentumParticleSelector *fMomentumSel; // cut for minimum p
  RhoEnergyParticleSelector *fEnergySel;     // cut for minimum E

  // *** pid algos
  TString fAlgoElectron; // Pid algo definition string electrons
  TString fAlgoMuon;     // Pid algo definition string muons
  TString fAlgoPion;     // Pid algo definition string pions
  TString fAlgoKaon;     // Pid algo definition string kaons
  TString fAlgoProton;   // Pid algo definition string protons

  Int_t fPidMult_025[5]; // cache for the PID multiplicities with P>=0.25

  // *** declare NTuples
  RhoTuple *ntp;  // overall info
  RhoTuple *nks0; // Ks0 QA
  RhoTuple *npi0; // pi0 QA
  RhoTuple *neta; // eta QA
  RhoTuple *nmc;  // MC QA

  // *** the PndAnalysis object
  PndAnalysis *fAnalysis;

  // *** Pointer to event shape object
  PndEventShape *fEventShape;

  // *** RhoTuple QA helper class
  PndRhoTupleQA *fQA;

  // *** Poca vertexer
  RhoVtxPoca *fPocaVertexer;

  // PDG database object
  TDatabasePDG *fPdg;

  // *** global RhoCandLists
  RhoCandList fMcTruth;
  RhoCandList fAllCands;
  RhoCandList fChargedCands;
  RhoCandList fNeutralCands;
  RhoCandList fGammaCands;

  RhoCandList fKs0Cands;
  RhoCandList fPi0Cands;
  RhoCandList fEtaCands;

  // *** index PID lists with ordering: e+  e-  mu+  mu- pi+   pi-  K+    K-    p     pb   gam  pi0  KS   eta
  RhoCandList fPidList[16];

  // *** Get parameter containers
  virtual void SetParContainers();

  FairRootManager *fRootManager;
  TClonesArray *fTcaOnlineFilterInfo;

  ClassDef(PndSoftTriggerTask, 1);
};

#endif