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 "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=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 << "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=0, PndSmpCandList *l3=0, PndSmpCandList *l4=0);

        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