Primary generator with added event filtering capabilities. More...

#include <FairFilteredPrimaryGenerator.h>

Inheritance diagram for FairFilteredPrimaryGenerator:

Public Member Functions
	FairFilteredPrimaryGenerator ()
	Default constructor. More...

	FairFilteredPrimaryGenerator (const char name, const char title="Filtered Generator")
	Constructor with name and title. More...

virtual	~FairFilteredPrimaryGenerator ()
	Destructor. More...

virtual Bool_t	Init ()
	Initialize the event generator(s) and the event (veto) filter(s). More...

void	AndFilter (FairEvtFilter *filter)
	Register a non-veto event filter using a logical AND to connect with previously defined non-veto event filters. More...

void	AndNotFilter (FairEvtFilter *filter)
	Register a non-veto event filter using a logical AND NOT to connect with previously defined non-veto event filters. More...

void	OrFilter (FairEvtFilter *filter)
	Register a non-veto event filter using a logical OR to connect with previously defined non-veto event filters. More...

void	OrNotFilter (FairEvtFilter *filter)
	Register a non-veto event filter using a logical OR NOT to connect with previously defined non-veto event filters. More...

void	AddVetoFilter (FairEvtFilter *filter)
	Register an event veto filter. Veto filters have higher priority than regular event filters. If the event matches any veto filter, it will be skipped. More...

virtual Bool_t	GenerateEvent (FairGenericStack *pStack)
	Calls event generators and the event filters. More...

TObjArray *	GetListOfFilters ()

TObjArray *	GetListOfVetoFilters ()

void	SetFilterMaxTries (Int_t maxTries=99999)
	Define the maximum number of times that this object should try to find an event which suits all event filters. More...

Int_t	GetNumberOfFilterMaxTries ()
	returns the maximum number of times that this object should try to find an event which suits all event filters. More...

Int_t	GetNumberOfGeneratedEvents ()
	returns the total (accepted + rejected) number of events generated by the event generators. If no event filters are used this number is equal to the number of simulated events. More...

void	SetEventPrintFrequency (int freq)
	Sets the frequency (accepted events) for printout (verbose>0) of accepted and generated events. More...

Int_t	GetNumberOfFilterFailedEvents ()
	Returns the number of cases in which no matching event was found within the set max. tries. More...

void	WriteEvtFilterStatsToRootFile (TFile *outputFile=NULL)
	Writes all relevant event filter information to the output root file. More...

void	SetVerbose (Int_t verbose=12)
	Set the level of commenting output. More...

Protected Member Functions
void	AddFilter (FairEvtFilter *filter, FairEvtFilter::LogicOp op, Bool_t negateFilter)
	Registers a regular (non-veto) filter. This method is not supposed to be directly used by the user. See public methods for user interfaces to this method. More...

Protected Attributes
TObjArray *	fVetoFilterList
	List of registered veto filters. More...

TIterator *	fVetoFilterIter
	Iterator over veto filter list. More...

TObjArray *	fFilterList
	List of registered filters. More...

TIterator *	fFilterIter
	Iterator over filter list. More...

FairEvtFilterParams	fEvtFilterStat
	Contains the statistics of the event filtering process. More...

Int_t	fVerbose
	Level of commenting output, 0 means no output, higher gives more output. More...

Bool_t	fEventVetoFilterActive
	returns kTRUE if any event veto filter is registered. More...

Bool_t	fEventFilterActive
	returns kTRUE if any non-veto event filter is registerd. More...

std::vector< Bool_t >	filterAcceptEvent
	Vector containing the results of the EventMatches methods for every registered non-veto event filter in the corresponding order. More...

std::vector< UInt_t >	fLogicalFilterOperation
	vector containing the logical operations with which the outputs of the non-veto event filters should be combined. More...

std::vector< Bool_t >	fFilterNegation
	vector determining whether the output of a non-veto event filter should be negated or not. More...

Int_t	fEventNrFiltered
	Event number (Set by the filtered primary generator. More...

Int_t	fEventPrintFreq
	Print frequency for filtered events. More...

Private Member Functions
	FairFilteredPrimaryGenerator (const FairFilteredPrimaryGenerator &)

FairFilteredPrimaryGenerator &	operator= (const FairFilteredPrimaryGenerator &)

	ClassDef (FairFilteredPrimaryGenerator, 2)

Detailed Description

Primary generator with added event filtering capabilities.

Author: Martin J. Galuska <martin [dot] j [dot] galuska (at) physik [dot] uni (minus) giessen [dot] de>; Katja Kleeberg

This class adds event filtering capabilities to FairPrimaryGenerator which is used internally for handling the event generators and so on. The event filtering is performed after the event generation and before the particle transport through the detector model.

From the description of FairPrimaryGenerator:

The FairFilteredPrimaryGenerator is responsible for the handling of the MC input. Several input generators can be registered to it; these have to be derived from the FairGenerator class. The FairFilteredPrimaryGenerator defines position and (optionally) smearing of the primary vertex. This class should be instantiated only once.

Definition at line 52 of file FairFilteredPrimaryGenerator.h.

Constructor & Destructor Documentation

FairFilteredPrimaryGenerator::FairFilteredPrimaryGenerator ( )

Default constructor.

Definition at line 28 of file FairFilteredPrimaryGenerator.cxx.

 : FairPrimaryGenerator(),
 
   fVetoFilterList(new TObjArray()),
   fVetoFilterIter(fVetoFilterList->MakeIterator()),
   fFilterList(new TObjArray()),
   fFilterIter(fFilterList->MakeIterator()),
   fEvtFilterStat(FairEvtFilterParams()),
   fVerbose(3),
   fEventVetoFilterActive(kFALSE),
   fEventFilterActive(kFALSE),
   filterAcceptEvent(),fLogicalFilterOperation(),fFilterNegation(),
   fEventNrFiltered(0),
   fEventPrintFreq(100)
 {
 }

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

Constructor with name and title.

Definition at line 49 of file FairFilteredPrimaryGenerator.cxx.

 : FairPrimaryGenerator(name,title),
 
   fVetoFilterList(new TObjArray()),
   fVetoFilterIter(fVetoFilterList->MakeIterator()),
   fFilterList(new TObjArray()),
   fFilterIter(fFilterList->MakeIterator()),
   fEvtFilterStat(FairEvtFilterParams()),
   fVerbose(3),
   fEventVetoFilterActive(kFALSE),
   fEventFilterActive(kFALSE),
   filterAcceptEvent(),fLogicalFilterOperation(),fFilterNegation(),
   fEventNrFiltered(0),
   fEventPrintFreq(100)
 {
 }

FairFilteredPrimaryGenerator::~FairFilteredPrimaryGenerator ( )

virtual

Destructor.

Definition at line 85 of file FairFilteredPrimaryGenerator.cxx.

References fFilterIter, fFilterList, fVetoFilterIter, and fVetoFilterList.

 {
         fVetoFilterList->Delete();
         delete fVetoFilterList;
         delete fVetoFilterIter;
 
         fFilterList->Delete();
         delete fFilterList;
         delete fFilterIter;
 
         //cout<<" Leave Destructor of FairFilteredPrimaryGenerator"<<endl;
 }

FairFilteredPrimaryGenerator::FairFilteredPrimaryGenerator ( const FairFilteredPrimaryGenerator & )

private

Member Function Documentation

void FairFilteredPrimaryGenerator::AddFilter	(	FairEvtFilter *	filter,
		FairEvtFilter::LogicOp	op,
		Bool_t	negateFilter
	)

inlineprotected

Registers a regular (non-veto) filter. This method is not supposed to be directly used by the user. See public methods for user interfaces to this method.

Definition at line 233 of file FairFilteredPrimaryGenerator.h.

References fEventFilterActive, fFilterList, fFilterNegation, and fLogicalFilterOperation.

Referenced by AndFilter(), AndNotFilter(), OrFilter(), and OrNotFilter().

                                                                                             {
                 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);
         }

void FairFilteredPrimaryGenerator::AddVetoFilter ( FairEvtFilter * filter )

inline

Register an event veto filter. Veto filters have higher priority than regular event filters. If the event matches any veto filter, it will be skipped.

Definition at line 92 of file FairFilteredPrimaryGenerator.h.

References fEventVetoFilterActive, and fVetoFilterList.

Referenced by sim_filter_ex1().

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

void FairFilteredPrimaryGenerator::AndFilter ( FairEvtFilter * filter )

inline

Register a non-veto event filter using a logical AND to connect with previously defined non-veto event filters.

Definition at line 72 of file FairFilteredPrimaryGenerator.h.

References AddFilter(), and FairEvtFilter::kAnd.

Referenced by prod_fsim(), quickfsimana(), sim_filter_ex1(), sim_filter_ex2(), and sim_filter_inv_mass().

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

void FairFilteredPrimaryGenerator::AndNotFilter ( FairEvtFilter * filter )

inline

Register a non-veto event filter using a logical AND NOT to connect with previously defined non-veto event filters.

Definition at line 77 of file FairFilteredPrimaryGenerator.h.

References AddFilter(), and FairEvtFilter::kAnd.

Referenced by sim_filter_ex1().

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

FairFilteredPrimaryGenerator::ClassDef	(	FairFilteredPrimaryGenerator	,
		2
	)

private

Bool_t FairFilteredPrimaryGenerator::GenerateEvent ( FairGenericStack * pStack )

virtual

Calls event generators and the event filters.

To be called at the beginning of each event from FairMCApplication. Generates an event vertex and calls the ReadEvent methods from the registered generators. Calls defined event (veto) filters to decide whether to process the event or to call the event generators again.

Parameters

pStack The particle stack

Returns: kTRUE if successful, kFALSE if not

Definition at line 102 of file FairFilteredPrimaryGenerator.cxx.

References Bool_t, FairEvtFilter::EventMatches(), fEventFilterActive, fEventNrFiltered, fEventPrintFreq, fEventVetoFilterActive, fEvtFilterStat, FairEvtFilterParams::fFailedFilterEvents, fFilterIter, fFilterList, FairEvtFilterParams::fFilterMaxTries, fFilterNegation, FairEvtFilterParams::fGeneratedEvents, filterAcceptEvent, FairEvtFilter::FilterActive(), fLogicalFilterOperation, fVerbose, fVetoFilterIter, RhoFactory::Instance(), FairEvtFilter::kAnd, FairEvtFilter::kOr, RhoFactory::Reset(), and FairEvtFilter::SetListOfParticles().

 {
         RhoFactory::Instance()->Reset();
 
         Int_t iTry=0; // number of attempts to find the next event that suits your filter
         Bool_t acceptEvent = kFALSE; // is kTRUE if the event is finally accepted
 
         if(kTRUE == fEventFilterActive){
                 // sanity check settings for logical combinations of event filters
                 if((int)fFilterNegation.size()!=fFilterList->GetEntriesFast()){
                         std::cout << "\n\n\n  -WARNING from FairFilteredPrimaryGenerator: size of the negation vector has to be equal to the number of added filters. Check your FilterNegation call!\n\n\n";
                         return kFALSE;
                 }
                 if((int)fLogicalFilterOperation.size()!=fFilterList->GetEntriesFast()-1){
                         std::cout << "\n\n\n  -WARNING from FairFilteredPrimaryGenerator: size of the operation vector has to be equal to the number of added filters minus one. Check your LogicalFilterOperation call!\n\n\n";
                         return kFALSE;
                 }
         }
 
         do{
                 ++iTry; // count how often we run the generators before we accept an event
                 ++fEvtFilterStat.fGeneratedEvents; // total number of generated events
                 Bool_t vetoed = kFALSE; // is kTRUE if event matches any of the veto filters (we will skip such events)
 
 
 
                 pStack->Reset(); // Clean the stack
                 FairPrimaryGenerator::GenerateEvent(pStack); // fill the stack
                 fEventNr = fEventNrFiltered; // Fix event numbering in FairPrimaryGenerator (otherwise fRun will stop too early...)
 
 
                 if(kTRUE == fEventVetoFilterActive){// skip veto filter checking if no veto filters are set
                         // check veto filters. skip event if the event satisfies any of the veto filters' conditions
                         // Call the FilterAccept methods for all veto filters
                         fVetoFilterIter->Reset();
                         TObject* vetoFilterObject = 0;
                         FairEvtFilter* vetoFilter = 0;
                         while( (vetoFilterObject = fVetoFilterIter->Next()) ) {
                                 vetoFilter = dynamic_cast<FairEvtFilter*> (vetoFilterObject);
                                 if ( ! vetoFilter ) { // this should never happen
                                         cout << " \n\n\n  -FATAL ERROR from FairFilteredPrimaryGenerator: Veto filter cast did not work!\n\n\n" << endl;
                                         return kFALSE;
                                 }
                                 if( !( vetoFilter->FilterActive() ) ){
                                         cout << " \n\n\n  -WARNING from FairFilteredPrimaryGenerator: There are no filter settings for filter " << vetoFilter->GetName() << " : " << vetoFilter->GetTitle() << ". Execution is halted!\n\n\n" << endl;
                                         return kFALSE;
                                 }
                                 Bool_t setParticlesOk = vetoFilter->SetListOfParticles(pStack->GetListOfParticles());//committing the list of particles to be checked
                                 if( ! setParticlesOk ) {
                                         cout << " \n\n\n  -WARNING from FairFilteredPrimaryGenerator: Particles were not pushed correctly to veto filter.\n\n\n" << endl;
                                         return kFALSE;
                                 }
                                 if ( vetoFilter->EventMatches(fEvtFilterStat.fGeneratedEvents) ) {
                                         // if event matches veto filter, skip event
                                         if( 3 < fVerbose ){
                                                 cout << "\n Event is NOT accepted because it matches a veto filter \n";
                                         }
                                         vetoed = kTRUE;
                                         break; // no need to check other veto filters as event will be skipped anyway
                                 }
                         } // end while
                 } // if veto filtering
 
                 if ( vetoed ) { continue; }; // skip event if it matches at least one veto filter
 
                 if ( kFALSE == fEventFilterActive ){ // skip event filtering (i.e. accept all events) if filtering is not requested
                         acceptEvent = kTRUE;
                         if( 3 < fVerbose ){
                                 cout << "\n Event is accepted because event filtering is not requested.\n\n";
                         }
                 } else { // do the event filtering (i.e. decide whether to accept or not accept the generated events) if filtering is requested
                         Int_t iCheckFilter=0;
                         // Call the FilterAccept methods for all registered (non-veto) filters
                         fFilterIter->Reset();
                         TObject* eventFilterObject = 0;
                         FairEvtFilter* eventFilter = 0;
                         filterAcceptEvent.clear();
                         while( (eventFilterObject = fFilterIter->Next()) ) {
                                 eventFilter = dynamic_cast<FairEvtFilter*> (eventFilterObject);
                                 if ( ! eventFilter ) {
                                         return kFALSE; } // this should never happen
                                 if( !( eventFilter->FilterActive() ) ){
                                         cout << " \n\n\n  -WARNING from FairFilteredPrimaryGenerator: There are no filter settings for filter " << eventFilter->GetName() << " : " << eventFilter->GetTitle() << ". Execution is halted!\n\n\n" << endl;
                                         return kFALSE;
                                 }
                                 Bool_t setParticlesOk = eventFilter->SetListOfParticles(pStack->GetListOfParticles());//committing the list of particles to be checked
                                 if( ! setParticlesOk ) {
                                         return kFALSE;
                                 }
                                 filterAcceptEvent.push_back(eventFilter->EventMatches(fEvtFilterStat.fGeneratedEvents));
                                 // check whether the simulated event matches the individual event filter
                                 iCheckFilter++;
                         }
 
                         //----------FilterNegation
                         // negate output from the event filters which should be negated
                         for(UInt_t iFil=0; iFil<fFilterNegation.size(); iFil++){
                                 if(kTRUE == fFilterNegation[iFil]){
                                         filterAcceptEvent[iFil]=(!filterAcceptEvent[iFil]);
                                 }
                         }
 
 
                         //----------LogicalFilterOperation
                         // combine (possibly negated) outputs from individual event filters using the logical connections stored in fLogicalFilterOperation
                         // in order to check whether the event is accepted
                         acceptEvent=filterAcceptEvent[0];
                         for(UInt_t iOper=0; iOper<fLogicalFilterOperation.size();iOper++){
                                 if(fLogicalFilterOperation[iOper]==FairEvtFilter::kAnd){
                                         acceptEvent=acceptEvent && filterAcceptEvent[iOper+1];
                                 }else{
                                         if(fLogicalFilterOperation[iOper]==FairEvtFilter::kOr){
                                                 acceptEvent=acceptEvent || filterAcceptEvent[iOper+1];
                                         }else{
                                                 std::cout << "\n\n\n  -WARNING from FairFilteredPrimaryGenerator: the entries of the operation vector have to be kAnd or kOr. Check your LogicalFilterOperation call!\n\n\n";
                                                 return kFALSE;
                                         }
                                 }
                         }
                         if( !acceptEvent && 3 < fVerbose ){
                                 cout << "\n Event is NOT accepted after combining the event filters.\n";
                         }
                 } // if (non-veto) event filtering
         }while(! acceptEvent && iTry < fEvtFilterStat.fFilterMaxTries);
 
 
         // Set the event number ALWAYS when filtering
         ++fEventNrFiltered;
         fEvent->SetEventID(fEventNrFiltered);
 
         if ( !acceptEvent && ( fEventFilterActive||fEventVetoFilterActive ) ){
                 ++fEvtFilterStat.fFailedFilterEvents;
                 cout << "\n -E FairFilteredPrimaryGenerator: No event was found within " << iTry << " tries which satisfies your event filter.\n ";
                 cout << "I accept a random event as evtNr " << fEventNrFiltered << " to avoid infinite loops. \n";
                 cout <<  "Try increasing the max. number of tries or change your filter\n\n";
                 if (fVerbose > 3 ){
                         if(fFilterList->GetEntriesFast() > 0){cout << "\n Event is accepted after combining the appointed filters.\n";}
                         cout << iTry << " events simulated until I found a good one.\n";
                         cout << fEvtFilterStat.fGeneratedEvents << " events generated for finding " << fEventNr << " accepted events.\n";
                         cout << fEvtFilterStat.fFailedFilterEvents << " unsuccessful attempts in total to find an event that suits your filters\n\n";
                 }
         }
 
         if (0 < fVerbose && (fEventNrFiltered%fEventPrintFreq)==0) cout << fEventNrFiltered << " of " << fEvtFilterStat.fGeneratedEvents << " generated events accepted.\n";
 
         return kTRUE;
 }

TObjArray* FairFilteredPrimaryGenerator::GetListOfFilters ( )

inline

Definition at line 115 of file FairFilteredPrimaryGenerator.h.

References fFilterList.

115 { return fFilterList;}

FairFilteredPrimaryGenerator::fFilterList

TObjArray * fFilterList

List of registered filters.

Definition: FairFilteredPrimaryGenerator.h:194

TObjArray* FairFilteredPrimaryGenerator::GetListOfVetoFilters ( )

inline

Definition at line 117 of file FairFilteredPrimaryGenerator.h.

References fVetoFilterList.

117 { return fVetoFilterList;}

FairFilteredPrimaryGenerator::fVetoFilterList

TObjArray * fVetoFilterList

List of registered veto filters.

Definition: FairFilteredPrimaryGenerator.h:190

Int_t FairFilteredPrimaryGenerator::GetNumberOfFilterFailedEvents ( )

inline

Returns the number of cases in which no matching event was found within the set max. tries.

This method returns 0 if everything works fine. If it returns a value >0 it means that you should set a higher limit in SetFilterMaxTries. If it returns a value which is equal to the number of events that you requested, it means that either the max. number of tries is set way too low or that the generator does not create such events that you are interested in or that your event filters cannot be satisfied at all (logical error).

Definition at line 154 of file FairFilteredPrimaryGenerator.h.

References fEvtFilterStat, and FairEvtFilterParams::fFailedFilterEvents.

Referenced by WriteEvtFilterStatsToRootFile().

                                              {
                 return fEvtFilterStat.fFailedFilterEvents;
         }

Int_t FairFilteredPrimaryGenerator::GetNumberOfFilterMaxTries ( )

inline

returns the maximum number of times that this object should try to find an event which suits all event filters.

Definition at line 131 of file FairFilteredPrimaryGenerator.h.

References fEvtFilterStat, and FairEvtFilterParams::fFilterMaxTries.

                                          {
                 return fEvtFilterStat.fFilterMaxTries;
         }

Int_t FairFilteredPrimaryGenerator::GetNumberOfGeneratedEvents ( )

inline

returns the total (accepted + rejected) number of events generated by the event generators. If no event filters are used this number is equal to the number of simulated events.

Definition at line 136 of file FairFilteredPrimaryGenerator.h.

References fEvtFilterStat, and FairEvtFilterParams::fGeneratedEvents.

Referenced by prod_fsim(), and WriteEvtFilterStatsToRootFile().

                                           {
                 return fEvtFilterStat.fGeneratedEvents;
         }

Bool_t FairFilteredPrimaryGenerator::Init ( )

virtual

Initialize the event generator(s) and the event (veto) filter(s).

Definition at line 67 of file FairFilteredPrimaryGenerator.cxx.

References fFilterList, fVetoFilterList, FairEvtFilter::Init(), and Init().

 {
         FairPrimaryGenerator::Init();
         // Initialize list of veto filters
         for(Int_t k=0; k<fVetoFilterList->GetEntries(); ++k ) {
                 FairEvtFilter* vetoFilter= (FairEvtFilter*) fVetoFilterList->At(k);
                 if(vetoFilter) { vetoFilter->Init(); }
         }
         // Initialize list of event filters
         for(Int_t k=0; k<fFilterList->GetEntries(); ++k ) {
                 FairEvtFilter* filter= (FairEvtFilter*) fFilterList->At(k);
                 if(filter) { filter->Init(); }
         }
         return kTRUE;
 }

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

private

void FairFilteredPrimaryGenerator::OrFilter ( FairEvtFilter * filter )

inline

Register a non-veto event filter using a logical OR to connect with previously defined non-veto event filters.

Definition at line 82 of file FairFilteredPrimaryGenerator.h.

References AddFilter(), and FairEvtFilter::kOr.

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

void FairFilteredPrimaryGenerator::OrNotFilter ( FairEvtFilter * filter )

inline

Register a non-veto event filter using a logical OR NOT to connect with previously defined non-veto event filters.

Definition at line 87 of file FairFilteredPrimaryGenerator.h.

References AddFilter(), and FairEvtFilter::kOr.

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

void FairFilteredPrimaryGenerator::SetEventPrintFrequency ( int freq )

inline

Sets the frequency (accepted events) for printout (verbose>0) of accepted and generated events.

Definition at line 141 of file FairFilteredPrimaryGenerator.h.

References fEventPrintFreq.

         {
                 fEventPrintFreq = freq;
         }

void FairFilteredPrimaryGenerator::SetFilterMaxTries ( Int_t maxTries = 99999 )

inline

Define the maximum number of times that this object should try to find an event which suits all event filters.

Definition at line 120 of file FairFilteredPrimaryGenerator.h.

References fEvtFilterStat, and FairEvtFilterParams::fFilterMaxTries.

Referenced by prod_fsim(), quickfsimana(), sim_filter_ex1(), and sim_filter_ex2().

         {
                 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";
                 }
         }

void FairFilteredPrimaryGenerator::SetVerbose ( Int_t verbose = 12 )

inline

Set the level of commenting output.

Parameters

verbose Level of commenting output, 0 means no output, higher gives more output.

Definition at line 177 of file FairFilteredPrimaryGenerator.h.

References fVerbose, and verbose.

Referenced by prod_fsim(), quickfsimana(), sim_complete(), sim_complete_newSTT(), sim_day1(), sim_filter_ex1(), sim_filter_ex2(), sim_radlength_complete(), and tut_sim().

                                          {
                 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";
                 }
         }

void FairFilteredPrimaryGenerator::WriteEvtFilterStatsToRootFile ( TFile * outputFile = NULL )

inline

Writes all relevant event filter information to the output root file.

Definition at line 159 of file FairFilteredPrimaryGenerator.h.

References fEvtFilterStat, GetNumberOfFilterFailedEvents(), and GetNumberOfGeneratedEvents().

Referenced by prod_fsim(), quickfsimana(), sim_filter_ex1(), sim_filter_ex2(), and sim_filter_inv_mass().

                                                                   {
                 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();
         }

Member Data Documentation

Bool_t FairFilteredPrimaryGenerator::fEventFilterActive

protected

returns kTRUE if any non-veto event filter is registerd.

Definition at line 205 of file FairFilteredPrimaryGenerator.h.

Referenced by AddFilter(), and GenerateEvent().

Int_t FairFilteredPrimaryGenerator::fEventNrFiltered

protected

Event number (Set by the filtered primary generator.

Definition at line 226 of file FairFilteredPrimaryGenerator.h.

Referenced by GenerateEvent().

Int_t FairFilteredPrimaryGenerator::fEventPrintFreq

protected

Print frequency for filtered events.

Definition at line 229 of file FairFilteredPrimaryGenerator.h.

Referenced by GenerateEvent(), and SetEventPrintFrequency().

Bool_t FairFilteredPrimaryGenerator::fEventVetoFilterActive

protected

returns kTRUE if any event veto filter is registered.

Definition at line 203 of file FairFilteredPrimaryGenerator.h.

Referenced by AddVetoFilter(), and GenerateEvent().

FairEvtFilterParams FairFilteredPrimaryGenerator::fEvtFilterStat

protected

Contains the statistics of the event filtering process.

Definition at line 199 of file FairFilteredPrimaryGenerator.h.

Referenced by GenerateEvent(), GetNumberOfFilterFailedEvents(), GetNumberOfFilterMaxTries(), GetNumberOfGeneratedEvents(), SetFilterMaxTries(), and WriteEvtFilterStatsToRootFile().

TIterator* FairFilteredPrimaryGenerator::fFilterIter

protected

Iterator over filter list.

Definition at line 196 of file FairFilteredPrimaryGenerator.h.

Referenced by GenerateEvent(), and ~FairFilteredPrimaryGenerator().

TObjArray* FairFilteredPrimaryGenerator::fFilterList

protected

List of registered filters.

Definition at line 194 of file FairFilteredPrimaryGenerator.h.

Referenced by AddFilter(), GenerateEvent(), GetListOfFilters(), Init(), and ~FairFilteredPrimaryGenerator().

std::vector<Bool_t> FairFilteredPrimaryGenerator::fFilterNegation

protected

vector determining whether the output of a non-veto event filter should be negated or not.

The vector grows automatically with every added non-veto event filter. A kTRUE entry at position i in the vector negates the i. filter's output, kFALSE entries do not negate.

Definition at line 222 of file FairFilteredPrimaryGenerator.h.

Referenced by AddFilter(), and GenerateEvent().

std::vector<Bool_t> FairFilteredPrimaryGenerator::filterAcceptEvent

protected

Vector containing the results of the EventMatches methods for every registered non-veto event filter in the corresponding order.

The content of the vector is overwritten for each generated event.

Definition at line 209 of file FairFilteredPrimaryGenerator.h.

Referenced by GenerateEvent().

std::vector<UInt_t> FairFilteredPrimaryGenerator::fLogicalFilterOperation

protected

vector containing the logical operations with which the outputs of the non-veto event filters should be combined.

The vector grows automatically with every added non-veto event filter. It is used to combine multiple filters via && or ||. The expression is evaluated sequentally from the first registered filter to the last one disregarding operator priorities.

Definition at line 216 of file FairFilteredPrimaryGenerator.h.

Referenced by AddFilter(), and GenerateEvent().

Int_t FairFilteredPrimaryGenerator::fVerbose

protected

Level of commenting output, 0 means no output, higher gives more output.

Definition at line 201 of file FairFilteredPrimaryGenerator.h.

Referenced by GenerateEvent(), and SetVerbose().

TIterator* FairFilteredPrimaryGenerator::fVetoFilterIter

protected

Iterator over veto filter list.

Definition at line 192 of file FairFilteredPrimaryGenerator.h.

Referenced by GenerateEvent(), and ~FairFilteredPrimaryGenerator().