PndFilteredPrimaryGenerator.h

Go to the documentation of this file.

#ifndef PndFilteredPrimaryGenerator_H
#define PndFilteredPrimaryGenerator_H

#include "FairPrimaryGenerator.h"
#include "FairEvtFilterParams.h"
#include "FairRunSim.h"
#include "FairRootFileSink.h"

#include "PndSmpFilt.h"
#include "PndSmpCand.h"

#include "TFile.h" // for TFile
#include "TLorentzVector.h"
#include "TString.h"
#include "Rtypes.h" // for Double_t, Bool_t, Int_t, etc

//#include <iosfwd>                     // for ostream
#include <iostream> // for operator<<, basic_ostream, etc
#include <vector>
#include <unordered_set>
#include <map>

class FairGenericStack;
class TDatabasePDG;

typedef vector<PndSmpFilt> PndSmpFilterSet;
typedef std::vector<PndSmpCand> PndSmpCandList;
typedef std::vector<TString> StrVec;

class PndFilteredPrimaryGenerator : public FairPrimaryGenerator {

 public:
  PndFilteredPrimaryGenerator();

  PndFilteredPrimaryGenerator(TString filterset);

  virtual ~PndFilteredPrimaryGenerator(){};

  virtual Bool_t Init();

  void AddFilter(TString filterStr);

  virtual Bool_t GenerateEvent(FairGenericStack *pStack);

  void SetFilterMaxTries(Int_t maxTries = 99999)
  {
    if (maxTries > 0) {
      fEvtFilterStat.fFilterMaxTries = maxTries;
      std::cout << "PndFilteredPrimaryGenerator: maxTries is now set to " << fEvtFilterStat.fFilterMaxTries << "\n";
    } else {
      std::cout << "\n\n\n  -WARNING from PndFilteredPrimaryGenerator: maxTries must be a positive number! Check your SetFilterMaxTries call!\n\n\n";
    }
  }

  Int_t GetNumberOfFilterMaxTries() { return fEvtFilterStat.fFilterMaxTries; }

  Int_t GetNumberOfGeneratedEvents() { return fEvtFilterStat.fGeneratedEvents; }

  void SetEventPrintFrequency(int freq) { fEventPrintFreq = freq; }

  Int_t GetNumberOfFilterFailedEvents() { return fEvtFilterStat.fFailedFilterEvents; }

  void WriteEvtFilterStatsToRootFile(TFile *outputFile = nullptr)
  {
    std::cout << "\n\nGenerated Events = " << GetNumberOfGeneratedEvents() << "\n";
    if (0 < GetNumberOfFilterFailedEvents()) {
      std::cout << "WARNING: Number of events where the event filter FAILED " << GetNumberOfFilterFailedEvents() << "\n\n\n";
      std::cout << "Random events were accepted to avoid infinite loops. \n";
      std::cout << "Try increasing the max. number of tries or change your filter (maybe the generators do not produce such events as you want).\n\n";
    }
    if (outputFile == nullptr)
      outputFile = ((FairRootFileSink*)FairRunSim::Instance()->GetSink())->GetRootFile();
      //outputFile = FairRunSim::Instance()->GetOutputFile();
    outputFile->cd();
    outputFile->mkdir("FairEvtFilter");
    outputFile->cd("FairEvtFilter");
    fEvtFilterStat.Write();
    outputFile->cd();
  }

  void SetVerbose(Int_t verbose = 12)
  {
    if (verbose >= 0) {
      fVerbose = verbose;
      std::cout << "PndFilteredPrimaryGenerator: fVerbose is now set to " << verbose << "\n";
    } else {
      std::cout << "\n\n\n  -WARNING from PndFilteredPrimaryGenerator: verbose must be a positive number! Check your SetVerbose call!\n\n\n";
    }
  }

 protected:
  PndSmpCandList CombineList(int pdg, PndSmpCandList *l0, PndSmpCandList *l1, PndSmpCandList *l2 = nullptr, PndSmpCandList *l3 = nullptr, PndSmpCandList *l4 = nullptr);

  void PrintSmpCandList(PndSmpCandList l, TString name = "");

  StrVec SplitString(TString s, TString delim = " ");

  bool CheckKinematic(const PndSmpFilt &f, const TLorentzVector &p4);

  int AntiPdgCode(int pdg);

  void GetRangeDouble(TString s, double &a, double &b, TString delim = ",", bool forceset = false);

  void GetRangeInt(TString s, int &a, int &b, TString delim = "..");

  std::vector<PndSmpFilterSet> fFilterSets;

  FairEvtFilterParams fEvtFilterStat;

  Int_t fVerbose;

  Int_t fEventNrFiltered;

  Int_t fEventPrintFreq;

  TDatabasePDG *fdbPdg;

  std::vector<TString> fPartNames;

  std::vector<int> fNamePdg;

  std::vector<int> fCombFsPdg;

  std::unordered_set<int> fSetFsPdg;

  std::map<TString, int> fNameCodeMap;

  std::map<int, TString> fCodeNameMap;

 private:
  PndFilteredPrimaryGenerator(const PndFilteredPrimaryGenerator &);
  PndFilteredPrimaryGenerator &operator=(const PndFilteredPrimaryGenerator &);

  ClassDef(PndFilteredPrimaryGenerator, 1);
};

#endif