FairFilteredPrimaryGenerator.h

Go to the documentation of this file.

#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=NULL){
                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==NULL) 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