FairFilteredPrimaryGenerator.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 FairFilteredPrimaryGenerator_H
#define FairFilteredPrimaryGenerator_H

#include "FairPrimaryGenerator.h"

#include "FairEvtFilter.h"
#include "FairEvtFilterParams.h"

#include "TNamed.h" // for TNamed
#include "TFile.h"  // for TFile
#include "FairRunSim.h"

#include "FairGenerator.h" // for FairGenerator

#include <iosfwd>      // for ostream
#include "Rtypes.h"    // for Double_t, Bool_t, Int_t, etc
#include "TObjArray.h" // for TObjArray
#include "TVector3.h"  // for TVector3

#include <iostream> // for operator<<, basic_ostream, etc
#include <vector>

class FairGenericStack;
class FairMCEventHeader;
class TF1;
class TIterator;

class FairFilteredPrimaryGenerator : public FairPrimaryGenerator {

 public:
  FairFilteredPrimaryGenerator();

  FairFilteredPrimaryGenerator(const char *name, const char *title = "Filtered Generator");

  virtual ~FairFilteredPrimaryGenerator();

  virtual Bool_t Init();

  void AndFilter(FairEvtFilter *filter) { AddFilter(filter, FairEvtFilter::kAnd, kFALSE); }

  void AndNotFilter(FairEvtFilter *filter) { AddFilter(filter, FairEvtFilter::kAnd, kTRUE); }

  void OrFilter(FairEvtFilter *filter) { AddFilter(filter, FairEvtFilter::kOr, kFALSE); }

  void OrNotFilter(FairEvtFilter *filter) { AddFilter(filter, FairEvtFilter::kOr, kTRUE); }

  void AddVetoFilter(FairEvtFilter *filter)
  {
    if (!fVetoFilterList) {
      std::cout << "Empty fFilterList pointer ! \n";
      return;
    }
    fVetoFilterList->Add(filter);
    fEventVetoFilterActive = kTRUE;
  }

  virtual Bool_t GenerateEvent(FairGenericStack *pStack);

  TObjArray *GetListOfFilters() { return fFilterList; }

  TObjArray *GetListOfVetoFilters() { return fVetoFilterList; }

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

 protected:
  TObjArray *fVetoFilterList;
  TIterator *fVetoFilterIter; 

  TObjArray *fFilterList;
  TIterator *fFilterIter; 

  FairEvtFilterParams fEvtFilterStat;
  Int_t fVerbose;
  Bool_t fEventVetoFilterActive;
  Bool_t fEventFilterActive;
  std::vector<Bool_t> filterAcceptEvent;
  std::vector<UInt_t> fLogicalFilterOperation;
  std::vector<Bool_t> fFilterNegation;

  Int_t fEventNrFiltered;

  Int_t fEventPrintFreq; // KG, added 03/2017

  void AddFilter(FairEvtFilter *filter, FairEvtFilter::LogicOp op, Bool_t negateFilter)
  {
    if (!fFilterList) {
      std::cout << "Empty fFilterList pointer ! \n";
      return;
    }
    fFilterList->Add(filter);
    fEventFilterActive = kTRUE;
    // add the settings for every new filter
    if (fFilterList->GetEntriesFast() != 1) {
      fLogicalFilterOperation.push_back(op);
    }
    fFilterNegation.push_back(negateFilter);
  }

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

  ClassDef(FairFilteredPrimaryGenerator, 2);
};

#endif